Mocking Demystified

Mocking
Demystified

by @_md

how many of you
write tests?

how many
write tests before the code?

how many of you
know what a mock is?

ALL YOU NEED TO KNOW ABOUT TESTING
(in 5 minutes)

test

Arrange

Act

Assert

test
instantiate
Arrange
tested object
Act

Assert

instantiate
Arrange
tested object

$parser = new MarkdownParser;

test

Arrange
run the method
Act you want to test
Assert

run the method
Act
you want to test


$html = $parser->toHtml('Hello World');

test

Arrange

Act

Assert specify the
expected outcome

specify the
Assert
expected outcome

$html = $parser->toHtml('Hello World');

assertTrue('Hello World' == $html);

test

Arrange instantiate tested object

Act run the method

Assert check expected outcome

$this->toHtml('Hello World')
->shouldReturn('Hello World');

$this->toHtml('Hello World')
->shouldReturn('Hello World');

a test is an executable example
of a class expected behaviour

class ParserSubject
{
public function notify(Event $event)
{
foreach ($this->subscribers as $subscriber) {
$subscriber->onChange($event);
}
}

}

HOW DO I KNOW NOTIFY WORKS?

class ParserSubjectTest extends TestCase
{
/** @test */
function it_notifies_subscribers()
{
// arrange
$parser = new ParserSubject;

// act
// I need an event!!!
$parser->notify(/* $event ??? */);

// assert
// how do I know subscriber::onChange got called?
}

}

HOW DO I KNOW NOTIFY WORKS?

class EndOfListListener extends EventListener
{

public function onNewLine(Event $event)
{
$html = $event->getText();
if ($this->document->getNextLine() == "") {
$html .= "</li></ul>";
}
return $html;
}

}

HOW DO I CONTROL EVENT AND DOCUMENT

{
focus on unit
expensive to instantiate
why? control on collaborators’ state
indirect outputs
undesirable side effects
[Meszaros 2007]

a mock is just 1 of
many test double patterns

doubles are replacement of anything
that is not the tested object

{
dummy
fake
doubles stub
mock
spy
[Meszaros 2007]

{
dummy no behaviour
fake
control indirect output
doubles stub
mock
check indirect output
spy
[Meszaros 2007]

a mockist TDD, London school, approach:

only the tested object is real

dummy

http://wicker123.deviantart.com/art/Slappy-The-Dummy-148136425

arrange
{
instantiate (may require collaborators)

class MarkdownParser
{
private $eventDispatcher;

public function __construct(EventDispatcher $dispatcher)
{
$this->eventDispatcher = $dispatcher;
}
}

USE DOUBLES TO BYPASS TYPE HINTING

class MarkdownParserTest extends TestCase
{

function setUp()
{
$dispatcher = $this->getMock('EventDispatcher');
$this->parser = new MardownParser($dispatcher);
}

}

XUNIT EXAMPLE

class MarkdownParser extends ObjectBehavior
{

function let($dispatcher)
{
$dispatcher->beAMockOf('EventDispatcher');
$this->beConstructedWith($dispatcher);
}

}

PHPSPEC EXAMPLE

“Dummy is a placeholder passed to the
SUT (tested object), but never used”

[Meszaros 2007]

dummy: double with no behaviour


DOUBLES TO CONTROL INDIRECT OUPUT

arrange
{
further change state

class MarkdownParserTest extends TestCase
{

function setUp()
{
$dispatcher = $this->getMock('EventDispatcher');
$this->parser = new MardownParser($dispatcher);

$this->parser->setEncoding('UTF-8');

}

}

FURTHER CHANGE TO THE STATE IN ARRANGE

arrange
{
further change state
configure indirect output

{

{
$html .= "</li></ul>";
}
return $html;
}

}

INDIRECT OUTPUTS

fake
stub
doubles for controlling indirect output

http://www.ﬂickr.com/photos/fcharlton/1841638596/
http://www.ﬂickr.com/photos/64749744@N00/476724045

$event->getText(); // will return “Hello World”
$this->document->getNextLine(); // will return “”

STUBBING: CONTROLLING DOUBLES INDIRECT OUTPUTS

function let($event, $document)
{
$event->beAMockOf("Event");
$document->beAMockOf("Document");
$this->beConstructedWith($document);
}

IN PHPSPEC

{
}

function it_ends_list_when_next_is_empty($event, $document)
{
$event->getText()->willReturn("Some text");
$document->getNextLine()->willReturn("");

}

IN PHPSPEC

{
}

{

$this->onNewLine($event)
->shouldReturn("Some text</li></ul>");

}

IN PHPSPEC

{

{
$html .= "</li></ul>";
}
return $html;
}

}

THE CODE AGAIN

{
}

{

$this->onNewLine($event)
->shouldReturn("Some text</li></ul>");

}

THE SPEC AGAIN

double behaviour

loose demand returns null to any method call
fake returns null to defined set methods
stub returns value defined or raise error

DOUBLES TO SPEC MESSAGE EXCHANGE

we said before

a test is an executable example
of a class expected behaviour

B = I + O

behaviour = input + output

{
return a value
modify state
methods print something
throw an exception
delegate

{
return a value
not the final
modify state
behaviour
methods print something
throw an exception
delegate

{
methods
return a value we should probably
print something delegate that too
throw an exception
delegate

{
methods
return a value
throw an exception
delegate

method strategy

returns a value
throws an exception

delegates

method strategy

returns a value assertions/
throws an exception expectations

delegates mocks & spies

Viewpoints Research Institute Source - Bonnie Macbird URL -http://www.vpri.org
“The key in making great and growable systems is much more to
design how its modules communicate
rather than what their internal properties
and behaviours should be.”

Messaging

$this->person->getCar()->getEngine()->ignite();

tell, don’t ask!

[Sharp 1997]

exposing lower level implementation
makes the code rigid

focus on messaging
makes the code flexible

mock
spy
doubles for messaging

http://www.ﬂickr.com/photos/scribe215/3234974208/
http://www.ﬂickr.com/photos/21560098@N06/5772919201/

use mocks to describe how your
method will impact collaborators

use PHPUnit_Framework_TestCase as TestCase;

{
/** @test */ function it_notifies_subscribers()
{
$event = $this->getMock("Event");

$subscriber = $this->getMock("Subscriber");
$subscriber->expects($this->once())
->method("onChange")
->with($event);

$parser = new ParserSubject();
$parser->attach($subscriber);
$parser->notify($event);
}
}

USING PHPUNIT NATIVE MOCK CONSTRUCT

public function testUpdateWithEqualTypes()
{
$installer = $this->createInstallerMock();
$manager = new InstallationManager('vendor');
$manager->addInstaller($installer);

$initial = $this->createPackageMock();
$target = $this->createPackageMock();
$operation = new UpdateOperation($initial, $target, 'test');

$initial
->expects($this->once())
->method('getType')
->will($this->returnValue('library'));
$target
->method('getType')
->will($this->returnValue('library'));

$installer
->method('supports')
->with('library')
->will($this->returnValue(true));

$installer
->method('update')
->with($this->repository, $initial, $target);

EXCESSIVE SETUP

use PHPUnit_Framework_TestCase as TestCase;

{
/** @test */ function it_notifies_subscribers()
{
$event = Mockery::mock("Event");

$subscriber = Mockery::mock("Subscriber");
$subscriber->shouldReceive("onChange")
->with($event);

$parser = new ParserSubject();
$parser->attach($subscriber);
$parser->notify($event);
}
}

USING MOCKERY

class ParserSubject extends PHPSpec2ObjectBehavior
{
/**
* @param Event $event
* @param Subscriber $subscriber
*/
function it_notifies_subscribers($event, $subscriber)
{
$subscriber->onChange($event)->shouldBeCalled();
$this->attach($subscriber);

$this->notify($event);
}
}

SAME EXAMPLE IN PHPSPEC

use spies to describe indirect output
expectations, retrospectively

use PHPSpec2ObjectBehavior;

class ParserSubject extends ObjectBehavior
{
function it_notifies_subscribers()
{
$event = Doubles::fromClass('Event');
$subscriber = Doubles::fromClass('Subscriber');

$subscriber->spy('onChange')->callCount()->shoudBe(1);

}
}

SPY EXAMPLE – WITH “DOUBLES” FRAMEWORK

use PHPSpec2ObjectBehavior;

class ParserSubject extends ObjectBehavior
{
/**
* @param Event $event
* @param Subscriber $subscriber
*/
function it_notifies_subscribers($event, $subscriber)
{
$subscriber->onChange($event)
->shouldHaveBeenCalled();
}
}

SPY EXAMPLE – AVAILABLE WITH PROPHECY INTEGRATION

use ProphecyProphet;

class TestCase extends SomeUnitTestingFrameworkTestCase
{
function createDoubler($name)
{
$this->prophet = new ProphecyProphet;
return $this->prophet->prophesize($name);
}

function createDummy($name)
{
return $this->createDoubler($name)->reveal();
}
}

INTEGRATING PROPHECY

{
dummy no behaviour
fake
control indirect output
doubles stub
mock
messaging
spy
[Meszaros 2007]

Marcello Duarte

I work here
I contribute here
I tweet here @_md

Questions or Comments?

want to improve on testing? bit.ly/inviqa-bdd-training

Mocking Demystified

More Related Content

Mocking Demystified