protected function user() { $user = new UserModel(); double::registerObject($user); $user = new InstanceProxy($user); return $user; }
public function testVerifyThatWasCalledWithParameters() { $user = new UserModel(); double::registerObject($user); $user = new InstanceProxy($user); $user->setName('davert'); $user->setName('jon'); $user->verifyInvokedOnce('setName', ['davert']); }
public function testVerifyInvocationClosures() { $info = array('address' => 'foo', 'email' => '*****@*****.**'); $user = new UserModel(); double::registerObject($user); $user = new InstanceProxy($user); $user->setInfo($info); $user->setInfo([]); $matcher = function ($params) use($info) { $args = $params[0][0]; // first call, first arg $empty = $params[1][0]; // second call, first arg verify($info)->equals($args); verify($empty)->isEmpty(); }; $this->specify('closure was called', function () use($user, $info, $matcher) { $user->verifyInvokedMultipleTimes('setInfo', 2, $matcher); $user->verifyInvoked('setInfo', $matcher); }); }
public function testVerifyMagicMethods() { $this->specify('works for class proxy', function () { // Set up user object. double::registerClass("demo\\UserModel", ['renameUser' => "Bob Jones", 'save' => null]); $userProxy = new ClassProxy("demo\\UserModel"); $user = new UserModel(['name' => "John Smith"]); // Rename the user via magic method. UserService::renameStatic($user, "Bob Jones"); // Assert rename was counted. $userProxy->verifyInvoked('renameUser'); }); $this->specify('works for instance proxy', function () { // Set up user object. $user = new UserModel(['name' => "John Smith"]); double::registerObject($user); $user = new InstanceProxy($user); // Rename the user via magic method. $user->renameUser("Bob Jones"); // Assert rename was counted. $user->verifyInvoked('renameUser'); }); }
/** * @param $object * @param array $params * @return InstanceProxy|null */ public static function doubleProxy($object, $params = array()) { $object = Registry::getRealClassOrObject($object); $proxy = null; if (is_object($object)) { Core\Registry::registerObject($object, $params); $proxy = new Proxy\InstanceProxy($object); } return $proxy; }
public function testObjectInstance() { $user = new UserModel(['name' => 'davert']); double::registerObject($user, ['save' => null]); $user->save(); }
/** * `test::double` registers class or object to track its calls. * In second argument you may pass values that mocked mathods should return. * * Returns either of [**ClassProxy**](https://github.com/Codeception/AspectMock/blob/master/docs/ClassProxy.md) (when a string was passed) * or [**InstanceProxy**](https://github.com/Codeception/AspectMock/blob/master/docs/InstanceProxy.md) (when an object was passed). * Proxies are used to verify method invocations, and some other useful things (check out the links above for more). * * Examples: * * ``` php * <?php * * # simple * $user = test::double(new User, ['getName' => 'davert']); * $user->getName() // => davert * $user->verifyInvoked('getName'); // => success * $user->getObject() // => returns instance of User, i.e. real, not proxified object * * # with closure * $user = test::double(new User, ['getName' => function() { return $this->login; }]); * $user->login = '******'; * $user->getName(); // => davert * * # on a class * $ar = test::double('ActiveRecord', ['save' => null]); * $user = new User; * $user->name = 'davert'; * $user->save(); // passes to ActiveRecord->save() and does not insert any SQL. * $ar->verifyInvoked('save'); // true * * # on static method call * User::tableName(); // 'users' * $user = test::double('User', ['tableName' => 'fake_users']); * User::tableName(); // 'fake_users' * $user->verifyInvoked('tableName'); // success * * # append declaration * $user = new User; * test::double($user, ['getName' => 'davert']); * test::double($user, ['getEmail' => '*****@*****.**']); * $user->getName(); // => 'davert' * $user->getEmail(); => '*****@*****.**' * * # create an instance of mocked class * test::double('User')->construct(['name' => 'davert']); // via constructir * test::double('User')->make(); // without calling constructor * * # stub for magic method * test::double('User', ['findByUsernameAndPasswordAndEmail' => false]); * User::findByUsernameAndPasswordAndEmail(); // null * * # stub for method of parent class * # if User extends ActiveRecord * test::double('ActiveRecord', ['save' => false]); * $user = new User(['name' => 'davert']); * $user->save(); // false * * ?> * ``` * * @api * @param string|object $classOrObject * @param array $params [ 'methodName' => 'returnValue' ] * @throws \Exception * @return Verifier Usually Proxy\ClassProxy|Proxy\InstanceProxy */ public static function double($classOrObject, array $params = array()) { $classOrObject = Registry::getRealClassOrObject($classOrObject); if (is_string($classOrObject)) { if (!class_exists($classOrObject)) { throw new \Exception("Class {$classOrObject} not loaded.\nIf you want to test undefined class use 'test::spec' method"); } Core\Registry::registerClass($classOrObject, $params); return new Proxy\ClassProxy($classOrObject); } if (is_object($classOrObject)) { Core\Registry::registerObject($classOrObject, $params); return new Proxy\InstanceProxy($classOrObject); } return null; }