Hexagonal BDD

Transcript

1. Hexagonal BDD Scato Eggen @scataco
2. Hexagonal BDD Let’s get started!
3. Setup Instructions Clone https://github.com/scato/hexagonal-bdd.git and follow the instructions in README.md
4. Overview • User Stories • Head First: Behat • Hexagonal Architecture • Head First: PHPSpec • Test Driven Development • Test Doubles • Behaviour Driven Development • Test Terminology
5. User Stories
6. User Stories Feature: Start a new game In order to practice my tic-tac-toe skills As a player I need to be able to start a new game Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" Then I should see an empty board
7. User Stories “Software requirements is a communication problem” – Mike Cohn As a … I want … So that … role behavior business value
8. User Stories: Example As a player I want to start a new game of tic-tac-toe So that I can practice my tic-tac-toe skills
9. User Stories: Roles As a player • Identify the roles used to interact with the system • Look at features from the user’s point of view
10. User Stories: Behavior I want to start a new game of tic-tac-toe • Focus on the intent of the user • Determine conditions of satisfaction
11. User Stories: Business Value So that I can practice my tic-tac-toe skills • Provide background for making informed guesses • Focus on adding value
12. User Stories: Conditions of Satisfaction • Verify that a game has been started. • Verify that the board is empty at the start of the game. • Also known as: acceptance criteria
13. Behaviour Driven Design “Acceptance criteria should be executable” – Dan North Given some initial context (the givens) When an event occurs Then ensure some outcomes
14. Head First: Behat
15. Head First: Behat
16. Behat: Getting Started $ vendor/bin/behat --init # features/start-game.feature Feature: Start a new game In order to practice my tic-tac-toe skills As a player I need to be able to start a new game
17. Behat: Scenarios # features/start-game.feature Feature: Start a new game In order to practice my tic-tac-toe skills As a player I need to be able to start a new game Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" Then I should see an empty board
18. Behat: Step Definitions class FeatureContext implements Context, SnippetAcceptingContext { // ... } $ vendor/bin/behat --append-snippets
19. Behat: Step Definitions Scenario: Choose to go first Given I have not started a game yet TODO: write pending definition When I start a game as player "X" Then I should see an empty board 1 scenario (1 pending) 3 steps (1 pending, 2 skipped) 0m0.03s (10.87Mb)
20. Behat: Step Definitions /** * @Given I have not started a game yet */ public function iHaveNotStartedAGameYet() { throw new PendingException(); }
21. Behat: Step Definitions /** * @Given I have not started a game yet */ public function iHaveNotStartedAGameYet() { $this->gameRepository = new FakeGameRepository([]); }
22. Behat: Fakes // features/bootstrap/Fake/FakeGameRepository.php namespace Fake; class FakeGameRepository { private $games; public function __construct(array $games) { $this->games = $games; } }
23. Behat: Step Definitions Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" TODO: write pending definition Then I should see an empty board 1 scenario (1 pending) 3 steps (1 passed, 1 pending, 1 skipped) 0m0.03s (10.87Mb)
24. Behat: Step Definitions /** * @When I start a game as player :arg1 */ public function iStartAGameAsPlayer($arg1) { throw new PendingException(); }
25. Hexagonal Architecture
26. Hexagonal Architecture “Allow an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases.” – Alistair Cockburn • UI tests are slow and brittle. • Business logic always creeps into the user interface code. • Also known as “ports & adapters”.
27. Hexagonal Architecture up and down don’t mean anything
28. Hexagonal Architecture getting rid of up and down
29. Hexagonal Architecture inside and outside actually mean something
30. Growing Object-Oriented Software “Acceptance tests are customer-facing tests that capture the domain logic the system must perform and demonstrates that it performs them.” – Nat Pryce • Use Ports & Adapters to run acceptance-tests directly against the application domain model. • The domain model is cleanly decoupled from the technical infrastructure that connects it to the outside world.
31. Growing Object-Oriented Software
32. “A project needs a common language that is more robust than the lowest common denominator.” – Eric Evans • Domain experts should object to terms or structures that are awkward or inadequate to convey domain understanding • Developers should watch for ambiguity or inconsistency that will trip up design. Ubiquitous Language
33. Modelling by Example “By embedding Ubiquitous Language in your scenarios, your scenarios naturally become your domain model, which you can use to develop the most important part of your application - a core domain.” – Konstantin Kudryashov • Push for Ubiquitous Language in your scenarios. • Do Domain-Driven Design while you're doing the red- green-refactor cycle.
34. Hexagonal Architecture 1. The application core is where the business value is at. 2. The user interface and persistence should be an afterthought. 3. If it’s easy to test, it’s probably hexagonal. 4. Don’t test for things that are not in the Ubiquitous Language.
35. Head First: PHPSpec
36. Head First: PHPSpec
37. PHPSpec: red-green-refactor Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" TODO: write pending definition Then I should see an empty board 1 scenario (1 pending) 3 steps (1 passed, 1 pending, 1 skipped) 0m0.03s (10.87Mb)
38. PHPSpec: red-green-refactor /** * @When I start a game as player :arg1 */ public function iStartAGameAsPlayer($arg1) { throw new PendingException(); }
39. PHPSpec: red-green-refactor /** * @When I start a game as player :arg1 */ public function iStartAGameAsPlayer($arg1) { $command = new StartGameCommand(); $command->gameId = self::GAME_ID; $command->playerName = $arg1; $handler = new StartGameHandler(); $handler->handle($command); }
40. PHPSpec: red-green-refactor $ vendor/bin/phpspec run 1 specs 1 example (1 broken) 18ms Do you want me to create `StartGameCommand` for you? [Y/n] $ vendor/bin/phpspec desc Application/StartGameCommand
41. PHPSpec: red-green-refactor class StartGameCommandSpec extends ObjectBehavior { function it_should_have_a_game_id() { $this->gameId->shouldBeNull(); } }
42. PHPSpec: red-green-refactor class StartGameCommand { /** * @var string */ public $gameId; }
43. PHPSpec: red-green-refactor class StartGameCommandSpec extends ObjectBehavior { function it_should_have_a_player_name() { $this->playerName->shouldBeNull(); } }
44. PHPSpec: red-green-refactor class StartGameCommand { /** * @var string */ public $playerName; }
45. PHPSpec: red-green-refactor $ vendor/bin/phpspec desc Application/StartGameHandler
46. PHPSpec: red-green-refactor class StartGameHandlerSpec extends ObjectBehavior { function it_should_start_a_game() { $command = new StartGameCommand(); $this->handle($command); } }
47. PHPSpec: red-green-refactor /** * @When I start a game as player :arg1 */ public function iStartAGameAsPlayer($arg1) { $command = new StartGameCommand(); $command->gameId = self::GAME_ID; $command->playerName = $arg1; $handler = new StartGameHandler(); $handler->handle($command); }
48. PHPSpec: red-green-refactor /** * @When I start a game as player :playerName */ public function iStartAGameAsPlayer($playerName) { $command = new StartGameCommand(); $command->gameId = self::GAME_ID; $command->playerName = $playerName; $handler = new StartGameHandler(); $handler->handle($command); }
49. PHPSpec: red-green-refactor Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" Then I should see an empty board TODO: write pending definition 1 scenario (1 pending) 3 steps (2 passed, 1 pending) 0m0.03s (10.87Mb)
50. PHPSpec: red-green-refactor /** * @Then I should see an empty board */ public function iShouldSeeAnEmptyBoard() { $query = new GetGameQuery(); $query->gameId = self::GAME_ID; $handler = new GetGameHandler(); $result = $handler->handle($query); PHPUnit_Framework_Assert::assertTrue($result->getBoard()->isEmpty()); }
51. PHPSpec: red-green-refactor Application\GetGameQuery • it should have a game id Application\GetGameHandler • it should get a game
52. PHPSpec: red-green-refactor class GetGameHandlerSpec extends ObjectBehavior { function it_should_get_a_game() { } }
53. PHPSpec: red-green-refactor Application\Game\Board • it should start out empty
54. PHPSpec: red-green-refactor class Board { public function isEmpty() { return true; } }
55. PHPSpec: red-green-refactor Application\Game\Game • it should have an id • it should have a board Application\Game\GameRepository • get(UuidInterface $id): Game
56. PHPSpec: red-green-refactor class GameSpec extends ObjectBehavior { function let(UuidInterface $id) { $this->beConstructedWith($id); } function it_should_have_an_id(UuidInterface $id) { $this->getId()->shouldBe($id); } }
57. PHPSpec: red-green-refactor interface GameRepository { /** * @param UuidInterface $id * @return Game * @throws RuntimeException if game was not found */ public function get(UuidInterface $id); }
58. PHPSpec: red-green-refactor Application\GetGameHandler • it should get a game
59. PHPSpec: red-green-refactor class GetGameHandlerSpec extends ObjectBehavior { function let( GameRepository $gameRepository, UuidFactoryInterface $uuidFactory, UuidInterface $gameId, Game $game ) { $this->beConstructedWith($gameRepository, $uuidFactory); $uuidFactory->fromString('1234')->willReturn($gameId); $gameRepository->get($gameId)->willReturn($game); } }
60. PHPSpec: red-green-refactor class GameRepositoryStub implements GameRepository { public function get(UuidInterface $id) { // TODO: Implement get() method. } }
61. PHPSpec: red-green-refactor Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" Then I should see an empty board Game with ID xxxxxxxx not found (RuntimeException) 1 scenario (1 failed) 3 steps (2 passed, 1 failed) 0m0.03s (10.87Mb)
62. Are We There Yet?
63. Behaviour Driven Development
64. PHPSpec: red-green-refactor class StartGameHandlerSpec extends ObjectBehavior { function it_should_start_a_game( GameRepository $gameRepository, Game $game ) { $command = new StartGameCommand(); $this->handle($command); $gameRepository->add($game)->shouldHaveBeenCalled(); } }
65. PHPSpec: red-green-refactor class StartGameHandlerSpec extends ObjectBehavior { function let( GameRepository $gameRepository, GameFactory $gameFactory, UuidInterface $gameId, Game $game ) { $this->beConstructedWith($gameRepository, $gameFactory); $gameFactory->create($gameId)->willReturn($game); } }
66. PHPSpec: red-green-refactor Scenario: Choose to go first Given I have not started a game yet When I start a game as player "X" Then I should see an empty board 1 scenario (1 pending) 3 steps (3 passed) 0m0.03s (10.87Mb)
67. PHPSpec: red-green-refactor Use cases: • StartGameCommand • GetGameQuery Ports: • GameRepository Adapters: • FakeGameRepository
68. Next Scenario
69. Next Scenario • Scenario: Make a move • Test Driven Development • Test Doubles • Behaviour Driven Development
70. Scenario: Make a move # features/start-game.feature Scenario: Make a move Given I have started a game as player "X" When I make a move Then I should see a board with one symbol on it
71. Scenario: Make a move
72. Test Driven Development
73. Test Driven Development “Test-driven development is a way of managing fear during programming.” – Kent Beck • Write new code only if you first have a failing automated test. • Eliminate duplication.
74. Test Driven Development Red-Green-Refactor 1. Write a failing test 2. Make the test pass 3. Refactor
75. Test Driven Development Step 1: Write a failing test • Arrange, Act, Assert • Listen for design feedback • Make it compile* *) make it run up to the first assertion.
76. Test Driven Development: Design Feedback • Keep It Simple, Stupid (KISS) • You Ain’t Gonna Need It (YAGNI) • Don’t Repeat Yourself (DRY) • Low Coupling
77. Test Driven Development Step 2: Make the test pass • Fake it • Triangulation • Obvious implementation
78. Test Driven Development: Fake It function testOneAndOneIsTwo() { $c = add(1, 1); $this->assertEquals(2, $c); } function add($a, $b) { return 2; }
79. Test Driven Development: Eliminate Duplication function testOneAndOneIsTwo() { $c = add(1, 1); $this->assertEquals(1 + 1, $c); } function add($a, $b) { return 1 + 1; }
80. Test Driven Development: Triangulation function testOneAndTwoIsThree() { $c = add(1, 2); $this->assertEquals(3, $c); } function add($a, $b) { return 1 + $b; }
81. Test Driven Development Step 3: Refactor • Remove duplication • Improve naming • Improve readability • Preparatory refactoring
82. Scenario: Make a move
83. Test Doubles
84. Test Doubles “The word "mock" is sometimes used in an informal way to refer to the whole family of objects that are used in tests. They are called Test Doubles.” – Robert C. Martin • Dummy • Stub • Fake • Spy • Mock
85. Test Doubles: Prophecy $prophet = new Prophet(); $testDouble = $prophet->prophesize(Authorizer::class); // set up test double $authorizer = $testDouble->reveal();
86. Test Doubles: PHPSpec function let(Authorizer $testDouble) { $this->beConstructedWith($testDouble); } function it_should_(Authorizer $testDouble) { // use test double }
87. Test Doubles: Dummy function let(Authorizer $dummy) { $this->beConstructedWith($dummy); } function it_should_start_without_logins() { $this->loginCount()->shouldBe(0); }
88. Test Doubles: Stub function it_should_count_logins(Authorizer $stub) { $stub->authorize(Argument::any(), Argument::any()) ->willReturn(true); $this->login('user', 'pass'); $this->loginCount()->shouldBe(1); }
89. Test Doubles: Fake function it_should_count_logins(Authorizer $fake) { $fake->authorize('Bob', 'bobspassword') ->willReturn(true); $this->login('Bob', 'bobspassword'); $this->loginCount()->shouldBe(1); }
90. Test Doubles: Spy function it_should_authorize_users(Authorizer $spy) { $this->login('user', 'pass'); $spy->authorize('user', 'pass') ->shouldHaveBeenCalled(); }
91. Test Doubles: Mock function it_should_authorize_users(Authorizer $mock) { $mock->authorize('user', 'pass') ->willReturn(true) ->shouldBeCalled(); $this->login('user', 'pass'); }
92. Scenario: Make a move
93. Behaviour Driven Development
94. Behaviour Driven Development • Test method names should be sentences • A simple sentence template keeps test methods focused • An expressive test name is helpful when a test fails • “Behaviour” is a more useful word than “test” • JBehave PHPSpec emphasizes behaviour over testing • Determine the next most important behaviour • Requirements are behaviour, too • BDD provides a “ubiquitous language” for analysis • Acceptance criteria should be executable from Introducing BDD by Dan North
95. Test method names should be sentences phpunit --testdox BankAccountTest PHPUnit 5.3.0 by Sebastian Bergmann and contributors. BankAccount [x] Balance is initially zero [x] Balance cannot become negative
96. A simple sentence template keeps test methods focused phpunit --testdox BankAccountTest PHPUnit 5.3.0 by Sebastian Bergmann and contributors. BankAccount [x] Should initially have a balance of zero [x] Should never have a negative balance
97. An expressive test name is helpful when a test fails • I had introduced a bug. Bad me. Solution: Fix the bug. • The intended behaviour was still relevant but had moved elsewhere. Solution: Move the test and maybe change it. • The behaviour was no longer correct – the premise of the system had changed. Solution: Delete the test.
98. “Behaviour” is a more useful word than “test” Helps to answer questions about TDD: • What should you call your test? • How much should you cover in one test? • When a test fails, what should you do?
99. PHPSpec emphasizes behaviour over testing • Specification • Example • Describe • Behaviour • Matcher • Expectation The word “test” is nowhere to be found.
100. Determine the next most important behaviour “The customer doesn’t want your code, they want the value of the software.” – Marcello Duarte • Determine what objects should do before you decide how they should do it. (See also: CRC cards.) • Objects expose behaviour, not data, so you have to tell them what to do with the data. (Tell, Don’t Ask)
101. CRC cards Class Responsibilities Collaborators
102. Requirements are behaviour, too Requirements are responsibilities at the application level
103. BDD provides a “ubiquitous language” for analysis Feature: • As a • I want • So that Class: • Arrange • Act • Assert Scenario: • Given • When • Then Story BDD Spec BDD
104. Acceptance criteria should be executable Gherkin
105. Scenario: Make a move
106. Are We There Yet?
107. Behaviour Driven Development
108. Test Terminology
109. Test Terminology
110. Unit Tests
111. Integration Tests
112. Acceptance Tests
113. System Tests
114. Component Tests Limit the scope of the exercised software to a portion of the system under test
115. Functional Tests Verify correct that the correct behaviour is performed
116. Non-Functional Tests Check for requirements like performance and security
117. Smoke Tests You plug in a new board and turn on the power. If you see smoke coming from the board, turn off the power.
118. Learning Tests Instead of just using a new method or a new class, we write a little test that verifies that the API works as expected.
119. Regression Tests Verify that software still performs correctly after a change.
120. System Test
121. System Test # behat.yml default: suites: acceptance: contexts: - FeatureContext
122. System Test # behat.yml default: suites: system: contexts: - WebFeatureContext - Behat\MinkExtension\Context\MinkContext filters: tags: '@critical'
123. System Test # behat.yml default: extensions: Behat\MinkExtension: base_url: http://192.168.33.99/app_dev.php sessions: default: goutte: ~
124. System Test # features/start-game.feature @critical Scenario: Make a move Given I have started a game as player "X" When I make a move Then I should see a board with one symbol on it
125. System Test /** * @BeforeScenario */ public function loadMinkExtension(BeforeScenarioScope $scope) { $environment = $scope->getEnvironment(); $this->minkContext = $environment->getContext(MinkContext::class); }
126. System Test /** * @Given I have started a game as player :playerName */ public function iHaveStartedAGameAsPlayer($playerName) { $this->minkContext->visit('/'); $this->minkContext->pressButton(''); }
127. Integration Test
128. Integration Test • Overloaded term • Test an abstraction that we own but have implemented with some third-party package • Don’t mock what you don’t own
129. Integration Test // tests/AppBundle/Repository/DoctrineGameRepositoryTest.php class DoctrineGameRepositoryTest extends KernelTestCase { /** * @test */ public function shouldGetGames() { } }
130. Integration Test /** * @test */ public function shouldGetGames() { static::bootKernel(); $entityManager = static::$kernel->getContainer() ->get('doctrine.orm.default_entity_manager'); $repository = $entityManager->getRepository(Game::class); $gameId = Uuid::uuid4(); $game = $repository->get($gameId); $this->assertInstanceOf(Game::class, $game); }
131. Integration Test /vagrant$ vendor/bin/phpunit PHPUnit 5.3.2 by Sebastian Bergmann and contributors. .E 2 / 2 (100%) Time: 1.35 seconds, Memory: 18.00Mb There was 1 error: 1) AppBundle\Repository\DoctrineGameRepositoryTest::shouldGetGames Doctrine\Common\Persistence\Mapping\MappingException: The class 'Application\Game\Game' was not found in the chain configured namespaces FAILURES! Tests: 2, Assertions: 2, Errors: 1.
132. Integration Test doctrine: orm: auto_generate_proxy_classes: "%kernel.debug%" naming_strategy: doctrine.orm.naming_strategy.underscore mappings: app: mapping: true type: yml dir: "%kernel.root_dir%/../src/AppBundle/Resources" prefix: "Application" is_bundle: false
133. Integration Test # src/AppBundle/Resources/Game.Game.orm.yml Application\Game\Game: type: entity id: id: type: string
134. Integration Test # src/AppBundle/Resources/Game.Game.orm.yml Application\Game\Game: type: entity repositoryClass: \AppBundle\Repository\DoctrineGameRepository id: id: type: string
135. Integration Test public function setUp() { static::bootKernel(); $application = new Application(static::$kernel); $application->setAutoExit(false); $input = new StringInput('doctrine:schema:create'); $output = new BufferedOutput(); $exitCode = $application->run($input, $output); $this->assertEquals(0, $exitCode, $output->fetch()); }
136. Integration Test # app/config/config_test.yml doctrine: dbal: driver: pdo_sqlite
137. Integration Test doctrine: dbal: types: uuid_binary: class: Ramsey\Uuid\Doctrine\UuidBinaryType
138. Integration Test /** * @test */ public function shouldGetGames() { // ... $this->assertInstanceOf(Game::class, $game); $this->assertInstanceOf(Uuid::class, $game->getId()); $this->assertInstanceOf(Board::class, $game->getBoard()); }
139. Integration Test // tests/AppBundle/Repository/DoctrineGameRepositoryTest.php class DoctrineGameRepositoryTest extends KernelTestCase { /** * @test */ public function shouldFailToGetNonExistentGame() { $this->expectException(RuntimeException::class); } }
140. Integration Test // tests/AppBundle/Repository/DoctrineGameRepositoryTest.php class DoctrineGameRepositoryTest extends KernelTestCase { /** * @test */ public function shouldAddGames() { } }
141. Integration Test // tests/AppBundle/Controller/DefaultControllerTest.php class DefaultControllerTest extends WebTestCase { public function testIndex() { $client = static::createClient(); $crawler = $client->request('GET', '/'); $this->assertEquals(200, $client->getResponse()->getStatusCode()); $this->assertCount(1, $crawler->filter('form[action$="/start"]')); $this->assertCount(1, $crawler->filter('form[action$="/start"] button')); } }
142. Integration Test public function shouldStartAGame() { $prophet = new Prophet(); $startGameHandler = $prophet->prophesize(StartGameHandler::class); $client = static::createClient(); $client->getKernel()->getContainer() ->set('app.start_game_handler', $startGameHandler->reveal()); $client->request('POST', '/start'); $startGameHandler->handle(Argument::type(StartGameCommand::class)) ->shouldHaveBeenCalled(); }
143. Integration Test // tests/AppBundle/AppBundleTest public function shouldExposeStartGameHandler() { static::bootKernel(); $startGameHandler = static::$kernel->getContainer()->get('app.start_game_handler'); $this->assertInstanceOf(StartGameHandler::class, $startGameHandler); }
144. Next Feature
145. Behaviour Driven Development # features/play-against-computer.feature Feature: Play against the computer In order to practice by myself As a player I want to play against the computer Scenario: Choose to go second Given I have not started a game yet When I start a game as player "O" Then I should see a board with one symbol on it Scenario: Computer makes the second move Given I have started a game as player "X" When I make a move Then I should see a board with two symbols on it
146. Round Up
147. Overview • User Stories • Hexagonal Architecture • Test Driven Development • Test Doubles • Behaviour Driven Development • Test Terminology
148. Test Driven Development • Writing tests is a divergent process • Making a test pass is a convergent process • Alternate between formulating a problem and finding a solution
149. Hexagonal Architecture • The application core is about business value • Adapters are about getting things to work • Alternate between the business domain and Google
150. Behaviour Driven Development • Unit tests provide inner quality • Acceptance tests provide outer quality • Alternate between what the system is and what the system does
151. thnx @scataco