The document discusses test doubles, which are objects used in place of real collaborators during unit testing. It describes different types of test doubles like dummies, stubs, fakes, spies and mocks, explaining their behaviors and purposes. Key principles for designing test doubles are also outlined, such as keeping their interfaces simple and avoiding side effects.

1. TDD 101
6. Test doubles: the motion picture

2. Test doubles:
the motion picture

3. The plot

4. You want to test an object that uses collaborators…

5. You need to isolate its behaviour from that of its collaborators

6. Then, you’ll need… test doubles

7. The argument

8. A unit of
software
Can be a query: returns a response
Can be a command: produces a change
in the state of the system
You should test the results of the behavior

9. When you test it You want to prove that the behavior:
• Is produced by the code of the unit of
software
• Is not influenced by any other factor

10. So, you need to
control the
behavior of
collaborators
Cancelling: no behavior at all
Controlling: knowing exactly what they
are doing (by means of programming it)

11. The cast

12. Dummy
No behavior
Only interface

13. namespace DojoHappyBirthdayLogger;
interface SimpleLogger
{
public function log(string $channel, string $message): void;
}

14. namespace TestsDojoHappyBirthdayDouble;
use DojoHappyBirthdayLoggerSimpleLogger;
class LoggerDummy implements SimpleLogger
{
public function log(string $channel, string $message): void
{
}
}

15. namespace TestsDojoHappyBirthday;
use DojoHappyBirthdaySendGreetings;
use PHPUnitFrameworkTestCase;
class SendGreetingsTest extends TestCase
{
public function testSendGreetingToCustomersWhenIsTheirBirthday()
{
$clockService = $this->getClockServiceStub();
$logger = $this->getLoggerDummy();
$customerRepository = $this->getCustomerRepositoryStub();
$mailer = $this->getMailerSpy([
new Customer('cust1@example.com'),
new Customer('cust2@example.com'),
new Customer('cust3@example.com')
]);
$sendGreetings = new SendGreetings(
$clockService,
$customerRepository,
$mailer,
$logger
);
$sendGreetings->execute();
$this->assertEquals(3. $mailer->getMessagesSent());
}
}

16. Stub
Programmed behavior

17. namespace DojoHappyBirthdayClock;
use DateTimeImmutable;
interface ClockService
{
public function currentDate(): DateTimeImmutable;
}

18. namespace TestsDojoHappyBirthdayDouble;
use DateTimeImmutable;
use DojoHappyBirthdayClockClockService;
class ClockServiceStub implements ClockService
{
/** @var DateTimeImmutable */
private $dateTime;
public function __construct(DateTimeImmutable $dateTime)
{
$this->dateTime = $dateTime;
}
public function currentDate() : DateTimeImmutable
{
return $this->dateTime;
}
}

19. namespace TestsDojoHappyBirthday;
use DojoHappyBirthdaySendGreetings;
use PHPUnitFrameworkTestCase;
class SendGreetingsTest extends TestCase
{
public function testSendGreetingToCustomersWhenIsTheirBirthday()
{
$clockService = $this->getClockServiceStub();
$logger = $this->getLoggerDummy();
$customerRepository = $this->getCustomerRepositoryStub();
$mailer = $this->getMailerSpy([
new Customer('cust1@example.com'),
new Customer('cust2@example.com'),
new Customer('cust3@example.com')
]);
$sendGreetings = new SendGreetings(
$clockService,
$customerRepository,
$mailer,
$logger
);
$sendGreetings->execute();
$this->assertEquals(3. $mailer->getMessagesSent());
}
}

20. Fake
Behavior
implementation…
but best suited for
testing
Needs its own tests

21. namespace DojoHappyBirthdayContacts;
interface ContactRepositoryInterface
{
public function retrieveById(UUid $uuid): Contact;
}

22. namespace DojoHappyBirthdayContacts;
class InMemoryContactRepository implements ContactRepository
{
public function retrieveById(UUid $uuid): Contact
{
}
}

23. Spy
Registers how is used
Fragility (coupling)

24. interface Mailer
{
public function send(Message $message) : void;
}

25. class MailerSpy implements Mailer
{
private $calls = 0;
public function send(Message $message) : void
{
$this->calls++;
}
public function getCalls()
{
return $this->calls;
}
}

26. Mock
Has expectations
about how is used
Takes assertions
away from the test
Fragility (coupling)

27. Taxonomy

28. Behavior
Knowledge

29. test doubles by behavior
dummy stub fake
no behavior fixed complete
Applies to any kind of double by knowledge

30. test doubles by knowledge
passive spy mock
Applies to any kind of double by behavior
knows
nothing
registers
use
has
expectations

31. How to

32. i

33. Design principles
Dem
SRP
OCP DIP
ISP
LSP
DRY Yagni

34. The “real” object
Should have:
• No behavior
• No side effects
• Immutability

35. Self-shunt Exploratory and sparse use
Simple interface

36. class ServiceTest extends TestCase implements Mailer
{
private $mailerCalls = 0;
public function testMailer()
{
$sut = new Service($this);
$sut->execute();
$this->assertEquals(2, $this->getCalls());
}
public function send(Message $message) : void
{
$this->mailerCalls++;
}
}

37. Anonymous
class
Exploratory
Single use
Simple interface
No side effects

38. class ServiceTest extends TestCase
{
public function testMailer()
{
$mailer = new class implements Mailer {
private $calls = 0;
public function send(Message $message) : void
{
$this->calls++;
}
puablic function getCalls()
{
return $this->calls;
}
};
$sut = new Service($mailer);
$sut->execute();
$this->assertEquals(2, $mailer->getCalls());
}
}

39. Hand made
double
Simple interfaces
Simple behaviour
Could need its
own tests

40. Mocking
library
Large interfaces
Complex behaviour
Multiple scenarios

41. class ServiceTest extends TestCase
{
public function testMailer()
{
$mailer = $this->createMock(Mailer::class);
$mailer->expects($this->once())
->method(‘send’)
->with($this->isInstanceOf(Message::class))
->willReturn(true);
$sut = new Service($mailer);
$sut->execute();
}
}