function testDisableCheckingForEntireMock() { Mockster::stub($this->foo->returnsDateTime())->will()->return_(null); $this->foo->enableReturnTypeChecking(false); Mockster::stub($this->foo->returnsString())->will()->return_(null); $this->mock->returnsString(); $this->mock->returnsDateTime(); $this->pass(); }
public function printAll(Mockster $mockster) { $class = (new \ReflectionClass($mockster->mock()))->getParentClass(); $all = []; foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) { $arguments = array_map(function () { return Argument::any(); }, $method->getParameters()); $calls = $mockster->__call($method->getName(), $arguments)->has()->calls(); if ($calls) { $all[] = $this->printCalls($method->getName(), $calls); } } return "History of [{$class->getName()}]\n " . implode("\n ", $all); }
function testPrintStubHistory() { Mockster::stub($this->foo->foo(Arg::any(), Arg::any()))->will()->return_('foo')->once()->then()->return_(['foo'])->once()->then()->return_(new \DateTime('2011-12-13 14:15:16 UTC'))->once()->then()->throw_(new \InvalidArgumentException("Oh no")); $this->mock->foo(4, 2); $this->mock->foo('One', 'Two'); $this->mock->foo('Three'); try { $this->mock->foo('Four', new RecordStubUsageTest_ToString()); } catch (\InvalidArgumentException $ignored) { } $this->assert((new HistoryPrinter())->printStub($this->foo->foo()), "No calls recorded for [" . RecordStubUsageTest_FooClass::class . "::foo()]"); $this->assert((new HistoryPrinter())->printStub($this->foo->foo(Arg::integer(), Arg::integer())), "History of [" . RecordStubUsageTest_FooClass::class . "::foo()]\n" . " foo(4, 2) -> 'foo'"); $this->assert((new HistoryPrinter())->printStub($this->foo->foo(Arg::string(), Arg::any())), "History of [" . RecordStubUsageTest_FooClass::class . "::foo()]\n" . " foo('One', 'Two') -> ['foo']\n" . " foo('Three', NULL) -> <DateTime>(2011-12-13T14:15:16+00:00)\n" . " foo('Four', <" . RecordStubUsageTest_ToString::class . ">('foo')) !! <InvalidArgumentException>('Oh no')"); }
function testDoNotStubStaticMethods() { try { $foo = new Mockster(StubMethodsTest_FooClass::class); /** @noinspection PhpUndefinedMethodInspection */ Mockster::stub($foo->staticMethod()); $this->fail("Should have thrown an exception"); } catch (\ReflectionException $e) { $this->assert->contains($e->getMessage(), 'static methods'); $this->assert->contains($e->getMessage(), 'FooClass::staticMethod'); } }
function testChangeInjectionFilters() { $factory = Mockster::createFactory(function (MockProvider $provider) { $provider->setPropertyFilter(function (\ReflectionProperty $property) { return strpos($property->getDocComment(), '@inject'); }); }); /** @var InjectMocksTest_AnnotatedInjectableClass $mock */ $mock = (new Mockster(InjectMocksTest_AnnotatedInjectableClass::class, $factory))->uut(); $this->assert->isInstanceOf($mock->foo, InjectMocksTest_FooClass::class); $this->assert->isNull($mock->bar); }
function testKeepVariadicMethod() { /** @var Mockster|CreateMocksTest_Methods $methods */ $methods = new Mockster(CreateMocksTest_Methods::class); /** @var CreateMocksTest_Methods $mock */ $mock = $methods->mock(); Mockster::stub($methods->variadic('one', 'two'))->will()->call(function ($args) { return json_encode($args); }); $this->assert->contains($mock->variadic('one', 'two'), '"0":"one","1":"two"'); }
/** * A typical test with *mockster* might look like this. */ public function testQuickStart() { /** * <a href="javascript:" onclick="$('#quickStartDefinitions').toggle();"> * Show class definitions for this example * </a><div id="quickStartDefinitions" style="display: none;"> */ eval(' class FooClass { /** @var MyDatabase <- */ protected $database; public function setUserName($id, $name) { $user = $this->database->readUser($id); $user->setName($name); $this->database->update($user); } } class MyDatabase { public function readUser($id) { // [...] } public function update($object) { // [...] } } class MyUser { public function setName($name) { // [...] } }'); // </div> /* * First create `Mockster` instances of the classes we're gonna mock. */ $foo = new Mockster('FooClass'); $user = new Mockster('MyUser'); /* * Then configure the behaviour of the dependencies of our *Unit Under Test*. * * The `Database` should return a mock of the `User` class when called with the argument `1`. */ $userMock = $user->mock(); $foo->database->readUser(1)->will()->return_($userMock); /* * Now execute the code to be tested. * * The `uut()` method will create an instance of the `FooClass` with * all it's dependencies replaced by mocks and none of it's methods stubbed. */ $foo->uut()->setUserName(1, 'Bart'); /* * Last, assert the expected behaviour. * * There should have been one call to `User::setName()` with the argument * `'Bart'` and one call on `Database::update()` with the `User` mock instance. */ $this->assert($user->setName('Bart')->has()->beenCalled()); $this->assert($foo->database->update($userMock)->has()->beenCalled()); }