ok
Direktori : /home2/selectio/www/limpiar.in.net/install/vendor/mockery/mockery/library/ |
Current File : //home2/selectio/www/limpiar.in.net/install/vendor/mockery/mockery/library/Mockery.php |
<?php /** * Mockery * * LICENSE * * This source file is subject to the new BSD license that is bundled * with this package in the file LICENSE.txt. * It is also available through the world-wide-web at this URL: * http://github.com/padraic/mockery/blob/master/LICENSE * If you did not receive a copy of the license and are unable to * obtain it through the world-wide-web, please send an email * to padraic@php.net so we can send you a copy immediately. * * @category Mockery * @package Mockery * @copyright Copyright (c) 2010 Pádraic Brady (http://blog.astrumfutura.com) * @license http://github.com/padraic/mockery/blob/master/LICENSE New BSD License */ use Mockery\ClosureWrapper; use Mockery\ExpectationInterface; use Mockery\Generator\CachingGenerator; use Mockery\Generator\Generator; use Mockery\Generator\MockConfigurationBuilder; use Mockery\Generator\MockNameBuilder; use Mockery\Generator\StringManipulationGenerator; use Mockery\Loader\EvalLoader; use Mockery\Loader\Loader; use Mockery\Matcher\MatcherAbstract; use Mockery\Reflector; class Mockery { const BLOCKS = 'Mockery_Forward_Blocks'; /** * Global container to hold all mocks for the current unit test running. * * @var \Mockery\Container|null */ protected static $_container = null; /** * Global configuration handler containing configuration options. * * @var \Mockery\Configuration */ protected static $_config = null; /** * @var \Mockery\Generator\Generator */ protected static $_generator; /** * @var \Mockery\Loader\Loader */ protected static $_loader; /** * @var array */ private static $_filesToCleanUp = []; /** * Defines the global helper functions * * @return void */ public static function globalHelpers() { require_once __DIR__ . '/helpers.php'; } /** * @return array * * @deprecated since 1.3.2 and will be removed in 2.0. */ public static function builtInTypes() { return array( 'array', 'bool', 'callable', 'float', 'int', 'iterable', 'object', 'self', 'string', 'void', ); } /** * @param string $type * @return bool * * @deprecated since 1.3.2 and will be removed in 2.0. */ public static function isBuiltInType($type) { return in_array($type, \Mockery::builtInTypes()); } /** * Static shortcut to \Mockery\Container::mock(). * * @param mixed ...$args * * @return \Mockery\MockInterface|\Mockery\LegacyMockInterface */ public static function mock(...$args) { return call_user_func_array(array(self::getContainer(), 'mock'), $args); } /** * Static and semantic shortcut for getting a mock from the container * and applying the spy's expected behavior into it. * * @param mixed ...$args * * @return \Mockery\MockInterface|\Mockery\LegacyMockInterface */ public static function spy(...$args) { if (count($args) && $args[0] instanceof \Closure) { $args[0] = new ClosureWrapper($args[0]); } return call_user_func_array(array(self::getContainer(), 'mock'), $args)->shouldIgnoreMissing(); } /** * Static and Semantic shortcut to \Mockery\Container::mock(). * * @param mixed ...$args * * @return \Mockery\MockInterface|\Mockery\LegacyMockInterface */ public static function instanceMock(...$args) { return call_user_func_array(array(self::getContainer(), 'mock'), $args); } /** * Static shortcut to \Mockery\Container::mock(), first argument names the mock. * * @param mixed ...$args * * @return \Mockery\MockInterface|\Mockery\LegacyMockInterface */ public static function namedMock(...$args) { $name = array_shift($args); $builder = new MockConfigurationBuilder(); $builder->setName($name); array_unshift($args, $builder); return call_user_func_array(array(self::getContainer(), 'mock'), $args); } /** * Static shortcut to \Mockery\Container::self(). * * @throws LogicException * * @return \Mockery\MockInterface|\Mockery\LegacyMockInterface */ public static function self() { if (is_null(self::$_container)) { throw new \LogicException('You have not declared any mocks yet'); } return self::$_container->self(); } /** * Static shortcut to closing up and verifying all mocks in the global * container, and resetting the container static variable to null. * * @return void */ public static function close() { foreach (self::$_filesToCleanUp as $fileName) { @unlink($fileName); } self::$_filesToCleanUp = []; if (is_null(self::$_container)) { return; } $container = self::$_container; self::$_container = null; $container->mockery_teardown(); $container->mockery_close(); } /** * Static fetching of a mock associated with a name or explicit class poser. * * @param string $name * * @return \Mockery\Mock */ public static function fetchMock($name) { return self::getContainer()->fetchMock($name); } /** * Lazy loader and getter for * the container property. * * @return Mockery\Container */ public static function getContainer() { if (is_null(self::$_container)) { self::$_container = new Mockery\Container(self::getGenerator(), self::getLoader()); } return self::$_container; } /** * Setter for the $_generator static property. * * @param \Mockery\Generator\Generator $generator */ public static function setGenerator(Generator $generator) { self::$_generator = $generator; } /** * Lazy loader method and getter for * the generator property. * * @return Generator */ public static function getGenerator() { if (is_null(self::$_generator)) { self::$_generator = self::getDefaultGenerator(); } return self::$_generator; } /** * Creates and returns a default generator * used inside this class. * * @return CachingGenerator */ public static function getDefaultGenerator() { return new CachingGenerator(StringManipulationGenerator::withDefaultPasses()); } /** * Setter for the $_loader static property. * * @param Loader $loader */ public static function setLoader(Loader $loader) { self::$_loader = $loader; } /** * Lazy loader method and getter for * the $_loader property. * * @return Loader */ public static function getLoader() { if (is_null(self::$_loader)) { self::$_loader = self::getDefaultLoader(); } return self::$_loader; } /** * Gets an EvalLoader to be used as default. * * @return EvalLoader */ public static function getDefaultLoader() { return new EvalLoader(); } /** * Set the container. * * @param \Mockery\Container $container * * @return \Mockery\Container */ public static function setContainer(Mockery\Container $container) { return self::$_container = $container; } /** * Reset the container to null. * * @return void */ public static function resetContainer() { self::$_container = null; } /** * Return instance of ANY matcher. * * @return \Mockery\Matcher\Any */ public static function any() { return new \Mockery\Matcher\Any(); } /** * Return instance of AndAnyOtherArgs matcher. * * An alternative name to `andAnyOtherArgs` so * the API stays closer to `any` as well. * * @return \Mockery\Matcher\AndAnyOtherArgs */ public static function andAnyOthers() { return new \Mockery\Matcher\AndAnyOtherArgs(); } /** * Return instance of AndAnyOtherArgs matcher. * * @return \Mockery\Matcher\AndAnyOtherArgs */ public static function andAnyOtherArgs() { return new \Mockery\Matcher\AndAnyOtherArgs(); } /** * Return instance of TYPE matcher. * * @param mixed $expected * * @return \Mockery\Matcher\Type */ public static function type($expected) { return new \Mockery\Matcher\Type($expected); } /** * Return instance of DUCKTYPE matcher. * * @param array ...$args * * @return \Mockery\Matcher\Ducktype */ public static function ducktype(...$args) { return new \Mockery\Matcher\Ducktype($args); } /** * Return instance of SUBSET matcher. * * @param array $part * @param bool $strict - (Optional) True for strict comparison, false for loose * * @return \Mockery\Matcher\Subset */ public static function subset(array $part, $strict = true) { return new \Mockery\Matcher\Subset($part, $strict); } /** * Return instance of CONTAINS matcher. * * @param mixed $args * * @return \Mockery\Matcher\Contains */ public static function contains(...$args) { return new \Mockery\Matcher\Contains($args); } /** * Return instance of HASKEY matcher. * * @param mixed $key * * @return \Mockery\Matcher\HasKey */ public static function hasKey($key) { return new \Mockery\Matcher\HasKey($key); } /** * Return instance of HASVALUE matcher. * * @param mixed $val * * @return \Mockery\Matcher\HasValue */ public static function hasValue($val) { return new \Mockery\Matcher\HasValue($val); } /** * Return instance of CLOSURE matcher. * * @param $reference * * @return \Mockery\Matcher\Closure */ public static function capture(&$reference) { $closure = function ($argument) use (&$reference) { $reference = $argument; return true; }; return new \Mockery\Matcher\Closure($closure); } /** * Return instance of CLOSURE matcher. * * @param mixed $closure * * @return \Mockery\Matcher\Closure */ public static function on($closure) { return new \Mockery\Matcher\Closure($closure); } /** * Return instance of MUSTBE matcher. * * @param mixed $expected * * @return \Mockery\Matcher\MustBe */ public static function mustBe($expected) { return new \Mockery\Matcher\MustBe($expected); } /** * Return instance of NOT matcher. * * @param mixed $expected * * @return \Mockery\Matcher\Not */ public static function not($expected) { return new \Mockery\Matcher\Not($expected); } /** * Return instance of ANYOF matcher. * * @param array ...$args * * @return \Mockery\Matcher\AnyOf */ public static function anyOf(...$args) { return new \Mockery\Matcher\AnyOf($args); } /** * Return instance of NOTANYOF matcher. * * @param array ...$args * * @return \Mockery\Matcher\NotAnyOf */ public static function notAnyOf(...$args) { return new \Mockery\Matcher\NotAnyOf($args); } /** * Return instance of PATTERN matcher. * * @param mixed $expected * * @return \Mockery\Matcher\Pattern */ public static function pattern($expected) { return new \Mockery\Matcher\Pattern($expected); } /** * Lazy loader and Getter for the global * configuration container. * * @return \Mockery\Configuration */ public static function getConfiguration() { if (is_null(self::$_config)) { self::$_config = new \Mockery\Configuration(); } return self::$_config; } /** * Utility method to format method name and arguments into a string. * * @param string $method * @param array $arguments * * @return string */ public static function formatArgs($method, array $arguments = null) { if (is_null($arguments)) { return $method . '()'; } $formattedArguments = array(); foreach ($arguments as $argument) { $formattedArguments[] = self::formatArgument($argument); } return $method . '(' . implode(', ', $formattedArguments) . ')'; } /** * Gets the string representation * of any passed argument. * * @param mixed $argument * @param int $depth * * @return mixed */ private static function formatArgument($argument, $depth = 0) { if ($argument instanceof MatcherAbstract) { return (string) $argument; } if (is_object($argument)) { return 'object(' . get_class($argument) . ')'; } if (is_int($argument) || is_float($argument)) { return $argument; } if (is_array($argument)) { if ($depth === 1) { $argument = '[...]'; } else { $sample = array(); foreach ($argument as $key => $value) { $key = is_int($key) ? $key : "'$key'"; $value = self::formatArgument($value, $depth + 1); $sample[] = "$key => $value"; } $argument = "[" . implode(", ", $sample) . "]"; } return ((strlen($argument) > 1000) ? substr($argument, 0, 1000) . '...]' : $argument); } if (is_bool($argument)) { return $argument ? 'true' : 'false'; } if (is_resource($argument)) { return 'resource(...)'; } if (is_null($argument)) { return 'NULL'; } return "'" . (string) $argument . "'"; } /** * Utility function to format objects to printable arrays. * * @param array $objects * * @return string */ public static function formatObjects(array $objects = null) { static $formatting; if ($formatting) { return '[Recursion]'; } if (is_null($objects)) { return ''; } $objects = array_filter($objects, 'is_object'); if (empty($objects)) { return ''; } $formatting = true; $parts = array(); foreach ($objects as $object) { $parts[get_class($object)] = self::objectToArray($object); } $formatting = false; return 'Objects: ( ' . var_export($parts, true) . ')'; } /** * Utility function to turn public properties and public get* and is* method values into an array. * * @param object $object * @param int $nesting * * @return array */ private static function objectToArray($object, $nesting = 3) { if ($nesting == 0) { return array('...'); } $defaultFormatter = function ($object, $nesting) { return array('properties' => self::extractInstancePublicProperties($object, $nesting)); }; $class = get_class($object); $formatter = self::getConfiguration()->getObjectFormatter($class, $defaultFormatter); $array = array( 'class' => $class, 'identity' => '#' . md5(spl_object_hash($object)) ); $array = array_merge($array, $formatter($object, $nesting)); return $array; } /** * Returns all public instance properties. * * @param mixed $object * @param int $nesting * * @return array */ private static function extractInstancePublicProperties($object, $nesting) { $reflection = new \ReflectionClass(get_class($object)); $properties = $reflection->getProperties(\ReflectionProperty::IS_PUBLIC); $cleanedProperties = array(); foreach ($properties as $publicProperty) { if (!$publicProperty->isStatic()) { $name = $publicProperty->getName(); try { $cleanedProperties[$name] = self::cleanupNesting($object->$name, $nesting); } catch (\Exception $exception) { $cleanedProperties[$name] = $exception->getMessage(); } } } return $cleanedProperties; } /** * Utility method used for recursively generating * an object or array representation. * * @param mixed $argument * @param int $nesting * * @return mixed */ private static function cleanupNesting($argument, $nesting) { if (is_object($argument)) { $object = self::objectToArray($argument, $nesting - 1); $object['class'] = get_class($argument); return $object; } if (is_array($argument)) { return self::cleanupArray($argument, $nesting - 1); } return $argument; } /** * Utility method for recursively * gerating a representation * of the given array. * * @param array $argument * @param int $nesting * * @return mixed */ private static function cleanupArray($argument, $nesting = 3) { if ($nesting == 0) { return '...'; } foreach ($argument as $key => $value) { if (is_array($value)) { $argument[$key] = self::cleanupArray($value, $nesting - 1); } elseif (is_object($value)) { $argument[$key] = self::objectToArray($value, $nesting - 1); } } return $argument; } /** * Utility function to parse shouldReceive() arguments and generate * expectations from such as needed. * * @param Mockery\LegacyMockInterface $mock * @param array ...$args * @param callable $add * @return \Mockery\CompositeExpectation */ public static function parseShouldReturnArgs(\Mockery\LegacyMockInterface $mock, $args, $add) { $composite = new \Mockery\CompositeExpectation(); foreach ($args as $arg) { if (is_array($arg)) { foreach ($arg as $k => $v) { $expectation = self::buildDemeterChain($mock, $k, $add)->andReturn($v); $composite->add($expectation); } } elseif (is_string($arg)) { $expectation = self::buildDemeterChain($mock, $arg, $add); $composite->add($expectation); } } return $composite; } /** * Sets up expectations on the members of the CompositeExpectation and * builds up any demeter chain that was passed to shouldReceive. * * @param \Mockery\LegacyMockInterface $mock * @param string $arg * @param callable $add * @throws Mockery\Exception * @return \Mockery\ExpectationInterface */ protected static function buildDemeterChain(\Mockery\LegacyMockInterface $mock, $arg, $add) { /** @var Mockery\Container $container */ $container = $mock->mockery_getContainer(); $methodNames = explode('->', $arg); reset($methodNames); if (!\Mockery::getConfiguration()->mockingNonExistentMethodsAllowed() && !$mock->mockery_isAnonymous() && !in_array(current($methodNames), $mock->mockery_getMockableMethods()) ) { throw new \Mockery\Exception( 'Mockery\'s configuration currently forbids mocking the method ' . current($methodNames) . ' as it does not exist on the class or object ' . 'being mocked' ); } /** @var ExpectationInterface|null $expectations */ $expectations = null; /** @var Callable $nextExp */ $nextExp = function ($method) use ($add) { return $add($method); }; $parent = get_class($mock); while (true) { $method = array_shift($methodNames); $expectations = $mock->mockery_getExpectationsFor($method); if (is_null($expectations) || self::noMoreElementsInChain($methodNames)) { $expectations = $nextExp($method); if (self::noMoreElementsInChain($methodNames)) { break; } $mock = self::getNewDemeterMock($container, $parent, $method, $expectations); } else { $demeterMockKey = $container->getKeyOfDemeterMockFor($method, $parent); if ($demeterMockKey) { $mock = self::getExistingDemeterMock($container, $demeterMockKey); } } $parent .= '->' . $method; $nextExp = function ($n) use ($mock) { return $mock->shouldReceive($n); }; } return $expectations; } /** * Gets a new demeter configured * mock from the container. * * @param \Mockery\Container $container * @param string $parent * @param string $method * @param Mockery\ExpectationInterface $exp * * @return \Mockery\Mock */ private static function getNewDemeterMock( Mockery\Container $container, $parent, $method, Mockery\ExpectationInterface $exp ) { $newMockName = 'demeter_' . md5($parent) . '_' . $method; $parRef = null; $parRefMethod = null; $parRefMethodRetType = null; $parentMock = $exp->getMock(); if ($parentMock !== null) { $parRef = new ReflectionObject($parentMock); } if ($parRef !== null && $parRef->hasMethod($method)) { $parRefMethod = $parRef->getMethod($method); $parRefMethodRetType = Reflector::getReturnType($parRefMethod, true); if ($parRefMethodRetType !== null && $parRefMethodRetType !== 'mixed') { $nameBuilder = new MockNameBuilder(); $nameBuilder->addPart('\\' . $newMockName); $mock = self::namedMock($nameBuilder->build(), $parRefMethodRetType); $exp->andReturn($mock); return $mock; } } $mock = $container->mock($newMockName); $exp->andReturn($mock); return $mock; } /** * Gets an specific demeter mock from * the ones kept by the container. * * @param \Mockery\Container $container * @param string $demeterMockKey * * @return mixed */ private static function getExistingDemeterMock( Mockery\Container $container, $demeterMockKey ) { $mocks = $container->getMocks(); $mock = $mocks[$demeterMockKey]; return $mock; } /** * Checks if the passed array representing a demeter * chain with the method names is empty. * * @param array $methodNames * * @return bool */ private static function noMoreElementsInChain(array $methodNames) { return empty($methodNames); } public static function declareClass($fqn) { return static::declareType($fqn, "class"); } public static function declareInterface($fqn) { return static::declareType($fqn, "interface"); } private static function declareType($fqn, $type) { $targetCode = "<?php "; $shortName = $fqn; if (strpos($fqn, "\\")) { $parts = explode("\\", $fqn); $shortName = trim(array_pop($parts)); $namespace = implode("\\", $parts); $targetCode.= "namespace $namespace;\n"; } $targetCode.= "$type $shortName {} "; /* * We could eval here, but it doesn't play well with the way * PHPUnit tries to backup global state and the require definition * loader */ $tmpfname = tempnam(sys_get_temp_dir(), "Mockery"); file_put_contents($tmpfname, $targetCode); require $tmpfname; \Mockery::registerFileForCleanUp($tmpfname); } /** * Register a file to be deleted on tearDown. * * @param string $fileName */ public static function registerFileForCleanUp($fileName) { self::$_filesToCleanUp[] = $fileName; } }