public static function instance($class)
{
\Arg::_($class, 'Class name')->is_string()->assert(class_exists($class), 'Class to getMock must be defined');
$instance = new self();
$instance->class = $class;
return $instance;
}
public static function on($times)
{
\Arg::_($times, 'Times')->is_int();
$instance = new static();
$instance->times = $times;
return $instance;
}
public static function instance($class)
{
\Arg::_($class, 'Class name')->is_string()->assert(class_exists($class) || interface_exists($class) || trait_exists($class), 'Class must be a defined one');
$instance = new self();
$instance->requestClassName = $class;
$instance->isStaticMethod = false;
$instance->isInstanceMethod = true;
$instance->isFunction = false;
$instance->isMethod = true;
$instance->methodName = '';
return $instance;
}
public static function make($times)
{
\Arg::_($times, 'Times')->is_int()->_or()->is_string();
if (is_numeric($times)) {
$times = (int) $times;
return EqualMatchingStrategy::on($times);
}
$matches = array();
if (!preg_match("/(>|>=|<|<=|==|!=)*(\\d)+/uU", $times, $matches)) {
throw new \InvalidArgumentException('If times is a string it must follow the pattern [==|!=|<=|<|>=|>]*\\d+');
}
$prefix = $matches[1];
$times = (int) $matches[2];
switch ($prefix) {
case '>':
$matchingStrategy = GreaterThanMatchingStrategy::on($times);
break;
case '>=':
$matchingStrategy = AtLeastMatchingStrategy::on($times);
break;
case '==':
$matchingStrategy = EqualMatchingStrategy::on($times);
break;
case '<':
$matchingStrategy = LessThanMatchingStrategy::on($times);
break;
case '<=':
$matchingStrategy = AtMostMatchingStrategy::on($times);
break;
case '!=':
$matchingStrategy = NotEqualMatchingStrategy::on($times);
break;
default:
$matchingStrategy = EqualMatchingStrategy::on($times);
break;
}
return $matchingStrategy;
}
public static function fromName($functionName)
{
if (!self::$systemFunctions) {
self::$systemFunctions = get_defined_functions()['internal'];
}
$condition = !in_array($functionName, self::$systemFunctions);
\Arg::_($functionName)->assert($condition, 'Function must not be an internal one.');
$instance = new self();
$instance->isEvalCreated = false;
$instance->functionName = $functionName;
$isMethod = preg_match("/^[\\w\\d_\\\\]+::[\\w\\d_]+\$/", $functionName);
if (!$isMethod && !function_exists($functionName)) {
$namespace = self::hasNamespace($functionName) ? 'namespace ' . self::getNamespaceFrom($functionName) . ";" : '';
$functionName = self::hasNamespace($functionName) ? self::getFunctionNameFrom($functionName) : $functionName;
$code = sprintf('%sfunction %s(){return null;}', $namespace, $functionName);
$ok = eval($code);
if ($ok === false) {
throw new \Exception("Could not eval code {$code} for function {$functionName}");
}
$instance->isEvalCreated = true;
}
return $instance;
}
public function setOriginalClassName($className)
{
\Arg::_($className, "Original class name")->is_string()->assert(class_exists($className) || interface_exists($className) || trait_exists($className), 'Original class, interface or trait must be defined');
$this->originalClassName = $className;
}
/**
* @test
* it should fail if array has not all the values
*/
public function it_should_fail_if_array_has_not_all_the_values()
{
$this->setExpectedException('InvalidArgumentException');
$array = ['foo' => 23, 'format' => 11];
Arg::_($array)->has_value(13, 23);
}
/**
* @param string $functionName
*
* @return LoggerInterface
*/
public static function make($functionName)
{
\Arg::_($functionName, 'Function name')->is_string();
$invocation = new SpyCallLogger();
return $invocation;
}
/**
* Sets a global value restoring the state after the test ran.
*
* @param string $globalHandle The key the value will be associated to in the $GLOBALS array.
* @param mixed $replacement The value that will be set in the $GLOBALS array.
*
* @return mixed The object that's been set in the $GLOBALS array.
*/
public static function setGlobal($globalHandle, $replacement = null)
{
\Arg::_($globalHandle, 'Global var key')->is_string();
self::backupGlobal($globalHandle);
$GLOBALS[$globalHandle] = $replacement;
return $replacement;
}
public static function normalizePathFrag($path)
{
\Arg::_($path, 'Path')->is_string();
return trim(trim($path), '/');
}
public static function on($mockRequest)
{
\Arg::_($mockRequest, 'Function or method name')->is_string();
$type = self::getType($mockRequest);
return self::getInstanceForTypeAndRequest($type, $mockRequest);
}
