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;
}
