init

vendor/codeception/stub/src/Stub.php

@@ -0,0 +1,686 @@
+<?php
+namespace Codeception;
+
+require_once __DIR__ . DIRECTORY_SEPARATOR . 'shim.php';
+
+use Codeception\Stub\ConsecutiveMap;
+use Codeception\Stub\StubMarshaler;
+use PHPUnit\Framework\MockObject\Generator;
+use PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount;
+use PHPUnit\Framework\MockObject\Stub\ConsecutiveCalls;
+use PHPUnit\Framework\MockObject\Stub\ReturnCallback;
+use PHPUnit\Framework\MockObject\Stub\ReturnStub;
+
+class Stub
+{
+    public static $magicMethods = ['__isset', '__get', '__set'];
+
+    /**
+     * Instantiates a class without executing a constructor.
+     * Properties and methods can be set as a second parameter.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::make('User');
+     * Stub::make('User', ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * Stub::make(new User, ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::make('User', ['save' => function () { return true; }]);
+     * Stub::make('User', ['save' => true]);
+     * ?>
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::make('User', [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class - A class to be mocked
+     * @param array $params - properties and methods to set
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object - mock
+     * @throws \RuntimeException when class does not exist
+     * @throws \Exception
+     */
+    public static function make($class, $params = [], $testCase = false)
+    {
+        $class = self::getClassname($class);
+        if (!class_exists($class)) {
+            if (interface_exists($class)) {
+                throw new \RuntimeException("Stub::make can't mock interfaces, please use Stub::makeEmpty instead.");
+            }
+            throw new \RuntimeException("Stubbed class $class doesn't exist.");
+        }
+
+        $reflection = new \ReflectionClass($class);
+        $callables = self::getMethodsToReplace($reflection, $params);
+        if ($reflection->isAbstract()) {
+            $arguments = empty($callables) ? [] : array_keys($callables);
+            $mock = self::generateMockForAbstractClass($class, $arguments, '', false, $testCase);
+        } else {
+            $arguments = empty($callables) ? null : array_keys($callables);
+            $mock = self::generateMock($class, $arguments, [], '', false, $testCase);
+        }
+
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflection);
+    }
+
+    /**
+     * Set __mock flag, if at all possible
+     *
+     * @param object $mock
+     * @param \ReflectionClass $reflection
+     * @return object
+     */
+    private static function markAsMock($mock, \ReflectionClass $reflection)
+    {
+        if (!$reflection->hasMethod('__set')) {
+            $mock->__mocked = $reflection->getName();
+        }
+        return $mock;
+    }
+
+    /**
+     * Creates $num instances of class through `Stub::make`.
+     *
+     * @param mixed $class
+     * @param int $num
+     * @param array $params
+     *
+     * @return array
+     * @throws \Exception
+     */
+    public static function factory($class, $num = 1, $params = [])
+    {
+        $objects = [];
+        for ($i = 0; $i < $num; $i++) {
+            $objects[] = self::make($class, $params);
+        }
+
+        return $objects;
+    }
+
+    /**
+     * Instantiates class having all methods replaced with dummies except one.
+     * Constructor is not triggered.
+     * Properties and methods can be replaced.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::makeEmptyExcept('User', 'save');
+     * Stub::makeEmptyExcept('User', 'save', ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * * Stub::makeEmptyExcept(new User, 'save');
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::makeEmptyExcept('User', 'save', ['isValid' => function () { return true; }]);
+     * Stub::makeEmptyExcept('User', 'save', ['isValid' => true]);
+     * ?>
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::makeEmptyExcept('User', 'validate', [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class
+     * @param string $method
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     * @throws \Exception
+     */
+    public static function makeEmptyExcept($class, $method, $params = [], $testCase = false)
+    {
+        $class = self::getClassname($class);
+        $reflectionClass = new \ReflectionClass($class);
+
+        $methods = $reflectionClass->getMethods();
+
+        $methods = array_filter(
+            $methods,
+            function ($m) {
+                return !in_array($m->name, Stub::$magicMethods);
+            }
+        );
+
+        $methods = array_filter(
+            $methods,
+            function ($m) use ($method) {
+                return $method != $m->name;
+            }
+        );
+
+        $methods = array_map(
+            function ($m) {
+                return $m->name;
+            },
+            $methods
+        );
+
+        $methods = count($methods) ? $methods : null;
+        $mock = self::generateMock($class, $methods, [], '', false, $testCase);
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflectionClass);
+    }
+
+    /**
+     * Instantiates class having all methods replaced with dummies.
+     * Constructor is not triggered.
+     * Properties and methods can be set as a second parameter.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::makeEmpty('User');
+     * Stub::makeEmpty('User', ['name' => 'davert']);
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * Stub::makeEmpty(new User, ['name' => 'davert']);
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::makeEmpty('User', ['save' => function () { return true; }]);
+     * Stub::makeEmpty('User', ['save' => true));
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::makeEmpty('User', [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     * @throws \Exception
+     */
+    public static function makeEmpty($class, $params = [], $testCase = false)
+    {
+        $class = self::getClassname($class);
+        $reflection = new \ReflectionClass($class);
+
+        $methods = get_class_methods($class);
+        $methods = array_filter(
+            $methods,
+            function ($i) {
+                return !in_array($i, Stub::$magicMethods);
+            }
+        );
+        $mock = self::generateMock($class, $methods, [], '', false, $testCase);
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflection);
+    }
+
+    /**
+     * Clones an object and redefines it's properties (even protected and private)
+     *
+     * @param       $obj
+     * @param array $params
+     *
+     * @return mixed
+     * @throws \Exception
+     */
+    public static function copy($obj, $params = [])
+    {
+        $copy = clone($obj);
+        self::bindParameters($copy, $params);
+
+        return $copy;
+    }
+
+    /**
+     * Instantiates a class instance by running constructor.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::construct('User', ['autosave' => false]);
+     * Stub::construct('User', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * Stub::construct(new User, ['autosave' => false), ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::construct('User', [], ['save' => function () { return true; }]);
+     * Stub::construct('User', [], ['save' => true]);
+     * ?>
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::construct('User', [], [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class
+     * @param array $constructorParams
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     * @throws \Exception
+     */
+    public static function construct($class, $constructorParams = [], $params = [], $testCase = false)
+    {
+        $class = self::getClassname($class);
+        $reflection = new \ReflectionClass($class);
+
+        $callables = self::getMethodsToReplace($reflection, $params);
+
+        $arguments = empty($callables) ? null : array_keys($callables);
+        $mock = self::generateMock($class, $arguments, $constructorParams, $testCase);
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflection);
+    }
+
+    /**
+     * Instantiates a class instance by running constructor with all methods replaced with dummies.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmpty('User', ['autosave' => false]);
+     * Stub::constructEmpty('User', ['autosave' => false), ['name' => 'davert']);
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmpty(new User, ['autosave' => false], ['name' => 'davert']);
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmpty('User', [], ['save' => function () { return true; }]);
+     * Stub::constructEmpty('User', [], ['save' => true]);
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::constructEmpty('User', [], [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class
+     * @param array $constructorParams
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     */
+    public static function constructEmpty($class, $constructorParams = [], $params = [], $testCase = false)
+    {
+        $class = self::getClassname($class);
+        $reflection = new \ReflectionClass($class);
+
+        $methods = get_class_methods($class);
+        $methods = array_filter(
+            $methods,
+            function ($i) {
+                return !in_array($i, Stub::$magicMethods);
+            }
+        );
+        $mock = self::generateMock($class, $methods, $constructorParams, $testCase);
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflection);
+    }
+
+    /**
+     * Instantiates a class instance by running constructor with all methods replaced with dummies, except one.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmptyExcept('User', 'save');
+     * Stub::constructEmptyExcept('User', 'save', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmptyExcept(new User, 'save', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * Stub::constructEmptyExcept('User', 'save', [], ['save' => function () { return true; }]);
+     * Stub::constructEmptyExcept('User', 'save', [], ['save' => true]);
+     * ?>
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * Stub::constructEmptyExcept('User', 'save', [], [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ], $this);
+     * ```
+     *
+     * @param mixed $class
+     * @param string $method
+     * @param array $constructorParams
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     */
+    public static function constructEmptyExcept(
+        $class,
+        $method,
+        $constructorParams = [],
+        $params = [],
+        $testCase = false
+    ) {
+        $class = self::getClassname($class);
+        $reflectionClass = new \ReflectionClass($class);
+        $methods = $reflectionClass->getMethods();
+        $methods = array_filter(
+            $methods,
+            function ($m) {
+                return !in_array($m->name, Stub::$magicMethods);
+            }
+        );
+        $methods = array_filter(
+            $methods,
+            function ($m) use ($method) {
+                return $method != $m->name;
+            }
+        );
+        $methods = array_map(
+            function ($m) {
+                return $m->name;
+            },
+            $methods
+        );
+        $methods = count($methods) ? $methods : null;
+        $mock = self::generateMock($class, $methods, $constructorParams, $testCase);
+        self::bindParameters($mock, $params);
+
+        return self::markAsMock($mock, $reflectionClass);
+    }
+
+    private static function generateMock()
+    {
+        return self::doGenerateMock(func_get_args());
+    }
+
+    /**
+     * Returns a mock object for the specified abstract class with all abstract
+     * methods of the class mocked. Concrete methods to mock can be specified with
+     * the last parameter
+     *
+     * @return object
+     * @since  Method available since Release 1.0.0
+     */
+    private static function generateMockForAbstractClass()
+    {
+        return self::doGenerateMock(func_get_args(), true);
+    }
+
+    private static function doGenerateMock($args, $isAbstract = false)
+    {
+        $testCase = self::extractTestCaseFromArgs($args);
+        $methodName = $isAbstract ? 'getMockForAbstractClass' : 'getMock';
+        $generatorClass = new Generator;
+
+        // using PHPUnit 5.4 mocks registration
+        if (version_compare(\PHPUnit\Runner\Version::series(), '5.4', '>=')
+            && $testCase instanceof \PHPUnit\Framework\TestCase
+        ) {
+            $mock = call_user_func_array([$generatorClass, $methodName], $args);
+            $testCase->registerMockObject($mock);
+            return $mock;
+        }
+        if ($testCase instanceof  \PHPUnit\Framework\TestCase) {
+            $generatorClass = $testCase;
+        }
+        return call_user_func_array([$generatorClass, $methodName], $args);
+    }
+
+    private static function extractTestCaseFromArgs(&$args)
+    {
+        $argsLength = count($args) - 1;
+        $testCase = $args[$argsLength];
+
+        unset($args[$argsLength]);
+
+        return $testCase;
+    }
+
+    /**
+     * Replaces properties of current stub
+     *
+     * @param \PHPUnit\Framework\MockObject\MockObject $mock
+     * @param array $params
+     *
+     * @return mixed
+     * @throws \LogicException
+     */
+    public static function update($mock, array $params)
+    {
+        //do not rely on __mocked property, check typ eof $mock
+        if (!$mock instanceof \PHPUnit\Framework\MockObject\MockObject) {
+            throw new \LogicException('You can update only stubbed objects');
+        }
+
+        self::bindParameters($mock, $params);
+
+        return $mock;
+    }
+
+    /**
+     * @param \PHPUnit\Framework\MockObject\MockObject $mock
+     * @param array $params
+     * @throws \LogicException
+     */
+    protected static function bindParameters($mock, $params)
+    {
+        $reflectionClass = new \ReflectionClass($mock);
+        if ($mock instanceof \PHPUnit\Framework\MockObject\MockObject) {
+            $parentClass = $reflectionClass->getParentClass();
+            if ($parentClass !== false) {
+                $reflectionClass = $reflectionClass->getParentClass();
+            }
+        }
+
+        foreach ($params as $param => $value) {
+            // redefine method
+            if ($reflectionClass->hasMethod($param)) {
+                if ($value instanceof StubMarshaler) {
+                    $marshaler = $value;
+                    $mock
+                        ->expects($marshaler->getMatcher())
+                        ->method($param)
+                        ->will(new ReturnCallback($marshaler->getValue()));
+                } elseif ($value instanceof \Closure) {
+                    $mock
+                        ->expects(new AnyInvokedCount)
+                        ->method($param)
+                        ->will(new ReturnCallback($value));
+                } elseif ($value instanceof ConsecutiveMap) {
+                    $consecutiveMap = $value;
+                    $mock
+                        ->expects(new AnyInvokedCount)
+                        ->method($param)
+                        ->will(new ConsecutiveCalls($consecutiveMap->getMap()));
+                } else {
+                    $mock
+                        ->expects(new AnyInvokedCount)
+                        ->method($param)
+                        ->will(new ReturnStub($value));
+                }
+            } elseif ($reflectionClass->hasProperty($param)) {
+                $reflectionProperty = $reflectionClass->getProperty($param);
+                $reflectionProperty->setAccessible(true);
+                $reflectionProperty->setValue($mock, $value);
+                continue;
+            } else {
+                if ($reflectionClass->hasMethod('__set')) {
+                    try {
+                        $mock->{$param} = $value;
+                    } catch (\Exception $e) {
+                        throw new \LogicException(
+                            sprintf(
+                                'Could not add property %1$s, class %2$s implements __set method, '
+                                . 'and no %1$s property exists',
+                                $param,
+                                $reflectionClass->getName()
+                            ),
+                            $e->getCode(),
+                            $e
+                        );
+                    }
+                } else {
+                    $mock->{$param} = $value;
+                }
+                continue;
+            }
+        }
+    }
+
+    /**
+     * @todo should be simplified
+     */
+    protected static function getClassname($object)
+    {
+        if (is_object($object)) {
+            return get_class($object);
+        }
+
+        if (is_callable($object)) {
+            return call_user_func($object);
+        }
+
+        return $object;
+    }
+
+    /**
+     * @param \ReflectionClass $reflection
+     * @param $params
+     * @return array
+     */
+    protected static function getMethodsToReplace(\ReflectionClass $reflection, $params)
+    {
+        $callables = [];
+        foreach ($params as $method => $value) {
+            if ($reflection->hasMethod($method)) {
+                $callables[$method] = $value;
+            }
+        }
+
+        return $callables;
+    }
+
+
+    /**
+     * Stubbing a method call to return a list of values in the specified order.
+     *
+     * ``` php
+     * <?php
+     * $user = Stub::make('User', array('getName' => Stub::consecutive('david', 'emma', 'sam', 'amy')));
+     * $user->getName(); //david
+     * $user->getName(); //emma
+     * $user->getName(); //sam
+     * $user->getName(); //amy
+     * ?>
+     * ```
+     *
+     * @return ConsecutiveMap
+     */
+    public static function consecutive()
+    {
+        return new ConsecutiveMap(func_get_args());
+    }
+}

vendor/codeception/stub/src/Stub/ConsecutiveMap.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Codeception\Stub;
+
+/**
+ * Holds matcher and value of mocked method
+ */
+class ConsecutiveMap
+{
+    private $consecutiveMap = [];
+    public function __construct(array $consecutiveMap)
+    {
+        $this->consecutiveMap = $consecutiveMap;
+    }
+    public function getMap()
+    {
+        return $this->consecutiveMap;
+    }
+}

vendor/codeception/stub/src/Stub/Expected.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace Codeception\Stub;
+
+require_once __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'shim.php';
+
+use PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastOnce;
+use PHPUnit\Framework\MockObject\Matcher\InvokedCount;
+
+class Expected
+{
+    /**
+     * Checks if a method never has been invoked
+     *
+     * If method invoked, it will immediately throw an
+     * exception.
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Stub\Expected;
+     *
+     * $user = $this->make('User', [
+     *      'getName' => Expected::never(),
+     *      'someMethod' => function() {}
+     * ]);
+     * $user->someMethod();
+     * ?>
+     * ```
+     *
+     * @param mixed $params
+     * @return StubMarshaler
+     */
+    public static function never($params = null)
+    {
+        return new StubMarshaler(
+            new InvokedCount(0),
+            self::closureIfNull($params)
+        );
+    }
+
+    /**
+     * Checks if a method has been invoked exactly one
+     * time.
+     *
+     * If the number is less or greater it will later be checked in verify() and also throw an
+     * exception.
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Stub\Expected;
+     *
+     * $user = $this->make(
+     *     'User',
+     *     array(
+     *         'getName' => Expected::once('Davert'),
+     *         'someMethod' => function() {}
+     *     )
+     * );
+     * $userName = $user->getName();
+     * $this->assertEquals('Davert', $userName);
+     * ?>
+     * ```
+     * Alternatively, a function can be passed as parameter:
+     *
+     * ```php
+     * <?php
+     * Expected::once(function() { return Faker::name(); });
+     * ```
+     *
+     * @param mixed $params
+     *
+     * @return StubMarshaler
+     */
+    public static function once($params = null)
+    {
+        return new StubMarshaler(
+            new InvokedCount(1),
+            self::closureIfNull($params)
+        );
+    }
+
+    /**
+     * Checks if a method has been invoked at least one
+     * time.
+     *
+     * If the number of invocations is 0 it will throw an exception in verify.
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Stub\Expected;
+     *
+     * $user = $this->make(
+     *     'User',
+     *     array(
+     *         'getName' => Expected::atLeastOnce('Davert')),
+     *         'someMethod' => function() {}
+     *     )
+     * );
+     * $user->getName();
+     * $userName = $user->getName();
+     * $this->assertEquals('Davert', $userName);
+     * ?>
+     * ```
+     *
+     * Alternatively, a function can be passed as parameter:
+     *
+     * ```php
+     * <?php
+     * Expected::atLeastOnce(function() { return Faker::name(); });
+     * ```
+     *
+     * @param mixed $params
+     *
+     * @return StubMarshaler
+     */
+    public static function atLeastOnce($params = null)
+    {
+        return new StubMarshaler(
+            new InvokedAtLeastOnce(),
+            self::closureIfNull($params)
+        );
+    }
+
+    /**
+     * Checks if a method has been invoked a certain amount
+     * of times.
+     * If the number of invocations exceeds the value it will immediately throw an
+     * exception,
+     * If the number is less it will later be checked in verify() and also throw an
+     * exception.
+     *
+     * ``` php
+     * <?php
+     * use \Codeception\Stub;
+     * use \Codeception\Stub\Expected;
+     *
+     * $user = $this->make(
+     *     'User',
+     *     array(
+     *         'getName' => Expected::exactly(3, 'Davert'),
+     *         'someMethod' => function() {}
+     *     )
+     * );
+     * $user->getName();
+     * $user->getName();
+     * $userName = $user->getName();
+     * $this->assertEquals('Davert', $userName);
+     * ?>
+     * ```
+     * Alternatively, a function can be passed as parameter:
+     *
+     * ```php
+     * <?php
+     * Expected::exactly(function() { return Faker::name() });
+     * ```
+     *
+     * @param int $count
+     * @param mixed $params
+     *
+     * @return StubMarshaler
+     */
+    public static function exactly($count, $params = null)
+    {
+        return new StubMarshaler(
+            new InvokedCount($count),
+            self::closureIfNull($params)
+        );
+    }
+
+    private static function closureIfNull($params)
+    {
+        if ($params instanceof \Closure) {
+            return $params;
+        }
+        return function() use ($params) {
+            return $params;
+        };
+    }
+
+}

vendor/codeception/stub/src/Stub/StubMarshaler.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Codeception\Stub;
+
+use PHPUnit\Framework\MockObject\Matcher\InvokedRecorder;
+
+/**
+ * Holds matcher and value of mocked method
+ */
+class StubMarshaler
+{
+    private $methodMatcher;
+
+    private $methodValue;
+
+    public function __construct(InvokedRecorder $matcher, $value)
+    {
+        $this->methodMatcher = $matcher;
+        $this->methodValue = $value;
+    }
+
+    public function getMatcher()
+    {
+        return $this->methodMatcher;
+    }
+
+    public function getValue()
+    {
+        return $this->methodValue;
+    }
+}

vendor/codeception/stub/src/Test/Feature/Stub.php

@@ -0,0 +1,312 @@
+<?php
+
+namespace Codeception\Test\Feature;
+
+/**
+ * ### Usage in Codeception
+ *
+ * Since Codeception 2.3.8 this trait is enabled in `\Codeception\Test\Unit` class.
+ *
+ * ### Usage in PHPUnit
+ *
+ * Include this trait into a TestCase to be able to use Stubs and Mocks:
+ *
+ * ```php
+ * <?php
+ * class MyTest extends \PHPUnit\Framework\TestCase
+ * {
+ *      use Codeception\Test\Feature\Stub;
+ * }
+ * ```
+ */
+trait Stub
+{
+    private $mocks;
+
+    protected function stubStart()
+    {
+        if ($this instanceof \PHPUnit\Framework\TestCase) {
+            return;
+        }
+        $this->mocks = [];
+    }
+
+    protected function stubEnd($status, $time)
+    {
+        if ($this instanceof \PHPUnit\Framework\TestCase) {
+            return;
+        }
+        if ($status !== 'ok') { // Codeception status
+            return;
+        }
+
+        foreach ($this->mocks as $mockObject) {
+            if ($mockObject->__phpunit_hasMatchers()) {
+                $this->assertTrue(true); // incrementing assertions
+            }
+
+            $mockObject->__phpunit_verify(true);
+        }
+    }
+
+    /**
+     * Instantiates a class without executing a constructor.
+     * Properties and methods can be set as a second parameter.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->make('User');
+     * $this->make('User', ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * $this->make(new User, ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->make('User', ['save' => function () { return true; }]);
+     * $this->make('User', ['save' => true]);
+     * ```
+     *
+     * @param mixed $class - A class to be mocked
+     * @param array $params - properties and methods to set
+     *
+     * @return object - mock
+     * @throws \RuntimeException when class does not exist
+     * @throws \Exception
+     */
+    public function make($class, $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::make($class, $params, $this);
+    }
+
+    /**
+     * Instantiates class having all methods replaced with dummies.
+     * Constructor is not triggered.
+     * Properties and methods can be set as a second parameter.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->makeEmpty('User');
+     * $this->makeEmpty('User', ['name' => 'davert']);
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * $this->makeEmpty(new User, ['name' => 'davert']);
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->makeEmpty('User', ['save' => function () { return true; }]);
+     * $this->makeEmpty('User', ['save' => true));
+     * ```
+     *
+     * @param mixed $class
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     * @throws \Exception
+     */
+
+    public function makeEmpty($class, $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::makeEmpty($class, $params, $this);
+    }
+
+    /**
+     * Instantiates class having all methods replaced with dummies except one.
+     * Constructor is not triggered.
+     * Properties and methods can be replaced.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->makeEmptyExcept('User', 'save');
+     * $this->makeEmptyExcept('User', 'save', ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * * $this->makeEmptyExcept(new User, 'save');
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in second parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->makeEmptyExcept('User', 'save', ['isValid' => function () { return true; }]);
+     * $this->makeEmptyExcept('User', 'save', ['isValid' => true]);
+     * ```
+     *
+     * @param mixed $class
+     * @param string $method
+     * @param array $params
+     *
+     * @return object
+     * @throws \Exception
+     */
+    public function makeEmptyExcept($class, $method, $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::makeEmptyExcept($class, $method, $params, $this);
+    }
+
+    /**
+     * Instantiates a class instance by running constructor.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->construct('User', ['autosave' => false]);
+     * $this->construct('User', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * $this->construct(new User, ['autosave' => false), ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->construct('User', [], ['save' => function () { return true; }]);
+     * $this->construct('User', [], ['save' => true]);
+     * ?>
+     * ```
+     *
+     * @param mixed $class
+     * @param array $constructorParams
+     * @param array $params
+     * @param bool|\PHPUnit\Framework\TestCase $testCase
+     *
+     * @return object
+     * @throws \Exception
+     */
+    public function construct($class, $constructorParams = [], $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::construct($class, $constructorParams, $params, $this);
+    }
+
+    /**
+     * Instantiates a class instance by running constructor with all methods replaced with dummies.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmpty('User', ['autosave' => false]);
+     * $this->constructEmpty('User', ['autosave' => false), ['name' => 'davert']);
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmpty(new User, ['autosave' => false], ['name' => 'davert']);
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmpty('User', array(), array('save' => function () { return true; }));
+     * $this->constructEmpty('User', array(), array('save' => true));
+     * ```
+     *
+     * **To create a mock, pass current testcase name as last argument:**
+     *
+     * ```php
+     * <?php
+     * $this->constructEmpty('User', [], [
+     *      'save' => \Codeception\Stub\Expected::once()
+     * ]);
+     * ```
+     *
+     * @param mixed $class
+     * @param array $constructorParams
+     * @param array $params
+     *
+     * @return object
+     */
+
+    public function constructEmpty($class, $constructorParams = [], $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::constructEmpty($class, $constructorParams, $params, $this);
+    }
+
+    /**
+     * Instantiates a class instance by running constructor with all methods replaced with dummies, except one.
+     * Parameters for constructor passed as second argument
+     * Properties and methods can be set in third argument.
+     * Even protected and private properties can be set.
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmptyExcept('User', 'save');
+     * $this->constructEmptyExcept('User', 'save', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * Accepts either name of class or object of that class
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmptyExcept(new User, 'save', ['autosave' => false], ['name' => 'davert']);
+     * ?>
+     * ```
+     *
+     * To replace method provide it's name as a key in third parameter
+     * and it's return value or callback function as parameter
+     *
+     * ``` php
+     * <?php
+     * $this->constructEmptyExcept('User', 'save', [], ['save' => function () { return true; }]);
+     * $this->constructEmptyExcept('User', 'save', [], ['save' => true]);
+     * ?>
+     * ```
+     *
+     * @param mixed $class
+     * @param string $method
+     * @param array $constructorParams
+     * @param array $params
+     *
+     * @return object
+     */
+    public function constructEmptyExcept($class, $method, $constructorParams = [], $params = [])
+    {
+        return $this->mocks[] = \Codeception\Stub::constructEmptyExcept($class, $method, $constructorParams, $params, $this);
+    }
+
+}

vendor/codeception/stub/src/shim.php

@@ -0,0 +1,40 @@
+<?php
+if (!class_exists('PHPUnit\Framework\TestCase') && class_exists('PHPUnit_Framework_TestCase')) {
+    class_alias('PHPUnit_Framework_TestCase', 'PHPUnit'.'\Framework\TestCase');
+}
+
+if (!class_exists('PHPUnit\Runner\Version')) {
+    class_alias('PHPUnit_Runner_Version', 'PHPUnit\Runner\Version');
+}
+if (class_exists('PHPUnit_Framework_MockObject_Generator')) {
+    class_alias('PHPUnit_Framework_MockObject_Generator', 'PHPUnit\Framework\MockObject\Generator');
+    class_alias('PHPUnit_Framework_MockObject_InvocationMocker', 'PHPUnit\Framework\MockObject\InvocationMocker');
+    class_alias('PHPUnit_Framework_MockObject_Invokable', 'PHPUnit\Framework\MockObject\Invokable');
+    class_alias('PHPUnit_Framework_MockObject_Matcher', 'PHPUnit\Framework\MockObject\Matcher');
+    class_alias('PHPUnit_Framework_MockObject_MockBuilder', 'PHPUnit\Framework\MockObject\MockBuilder');
+    if (interface_exists('PHPUnit_Framework_MockObject_MockObject')) {
+        /*
+         * old name still exists in https://github.com/sebastianbergmann/phpunit-mock-objects/blob/master/src/MockObject.php
+         * but namespaced alias is provided by https://github.com/sebastianbergmann/phpunit-mock-objects/blob/master/src/ForwardCompatibility/MockObject.php
+         */
+        class_alias('PHPUnit_Framework_MockObject_MockObject', 'PHPUnit\Framework\MockObject\MockObject');
+    }
+    class_alias('PHPUnit_Framework_MockObject_Stub', 'PHPUnit\Framework\MockObject\Stub');
+    class_alias('PHPUnit_Framework_MockObject_Verifiable', 'PHPUnit\Framework\MockObject\Verifiable');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_AnyInvokedCount', 'PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters', 'PHPUnit\Framework\MockObject\Matcher\ConsecutiveParameters');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_Invocation', 'PHPUnit\Framework\MockObject\Matcher\Invocation');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedAtIndex', 'PHPUnit\Framework\MockObject\Matcher\InvokedAtIndex');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedAtLeastCount', 'PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastCount');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedAtLeastOnce', 'PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastOnce');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedAtMostCount', 'PHPUnit\Framework\MockObject\Matcher\InvokedAtMostCount');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedCount', 'PHPUnit\Framework\MockObject\Matcher\InvokedCount');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_InvokedRecorder', 'PHPUnit\Framework\MockObject\Matcher\InvokedRecorder');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_MethodName', 'PHPUnit\Framework\MockObject\Matcher\MethodName');
+    class_alias('PHPUnit_Framework_MockObject_Matcher_Parameters', 'PHPUnit\Framework\MockObject\Matcher\Parameters');
+    class_alias('PHPUnit_Framework_MockObject_Stub_ConsecutiveCalls', 'PHPUnit\Framework\MockObject\Stub\ConsecutiveCalls');
+    class_alias('PHPUnit_Framework_MockObject_Stub_Exception', 'PHPUnit\Framework\MockObject\Stub\Exception');
+    class_alias('PHPUnit_Framework_MockObject_Stub_ReturnArgument', 'PHPUnit\Framework\MockObject\Stub\ReturnArgument');
+    class_alias('PHPUnit_Framework_MockObject_Stub_ReturnCallback', 'PHPUnit\Framework\MockObject\Stub\ReturnCallback');
+    class_alias('PHPUnit_Framework_MockObject_Stub_Return', 'PHPUnit\Framework\MockObject\Stub\ReturnStub');
+}