Index
A
- acceptance criteria / Behavior-driven development
- acceptance test-driven development (ATDD) / The difference between quality checking and quality assurance
- acceptance tests / Why not use unit tests exclusively?
- Alexandria project
- about / Description
- technical comments / Technical comments
- new feature, adding / Adding a new feature
- black-box testing / Black-box or spike testing
- spike testing / Black-box or spike testing
- preliminary investigation / Preliminary investigation
- legacy code algorithm, applying / Applying the legacy code algorithm
- call, extracting / Extract and override call
- call, overriding / Extract and override call
- primitive obsession, removing with status as int / Removing the primitive obsession with status as int
- application debugging
- avoiding / No debugging
- Awesome Gambling Corp
- about / Case study – Awesome Gambling Corp
- codebase, exploring / Exploring the codebase
- release procedure / Release procedure
- production, deployments / Deployments to production
- conclusions / Conclusions
B
- Bamboo
- reference link / Processes
- behavior-driven development (BDD)
- about / Black-box testing, Behavior-driven development
- specifications / Different specifications
- narrative / Narrative
- scenarios / Scenarios
- book store / The book store BDD story
- black-box testing
- about / Black-box testing
- advantages / Black-box testing
- disadvantages / Black-box testing
- reference link / Black-box or spike testing
C
- call extraction, Alexandria project
- constructor, parameterizing / Parameterizing a constructor
- new feature, adding / Adding a new feature
- call override, Alexandria project
- constructor, parameterizing / Parameterizing a constructor
- new feature, adding / Adding a new feature
- Clover
- reference link / Tools
- Cobertura
- reference link / Tools
- code coverage
- reference link / Legacy code example
- code refactoring / Code refactoring
- code smell
- reference link / Legacy code
- commands, remote-controlled ship development
- single commands / Specification – single commands, Implementation
- combined commands / Specification – combined commands, Implementation
- Connect 4 game
- about / Connect 4
- reference link / Connect 4
- requirements / Requirements
- constructor chaining / Parameterizing a constructor
- continuous delivery
- about / Continuous integration, delivery, and deployment, Towards continuous delivery
- improvements / Possible improvements
- test coverage, increasing / Increasing test coverage
- continuous integration, implementing / Implementing continuous integration
- Jenkins installation / Jenkins installation
- builds, automating / Automating builds
- executing / First execution
- example / What is next?
- continuous deployment (CD) / Towards continuous delivery
- continuous integration (CI) / Executable documentation, Continuous integration, delivery, and deployment, Release procedure
- curl
- reference link / Writing end-to-end test cases
D
- DbUnit
- reference link / Applying the legacy code algorithm
- dependency injection / Final considerations, Preliminary investigation
- Don't Repeat Yourself (DRY) principle
- reference link / Don't Repeat Yourself
E
- environment
- setting up, with Gradle / Setting up the environment with Gradle and JUnit
- setting up, with JUnit / Setting up the environment with Gradle and JUnit
- executable documentation / Executable documentation
- extract / Breaking dependencies
- Extreme Programming (XP)
- about / Red-Green-Refactor
- reference link / Unit testing
F
- Feature Flags / Feature Toggles
- Feature Flipping / Feature Toggles
- Feature Toggles
- about / Feature Toggles
- Togglz / Feature Toggles
- FF4J / Feature Toggles
- feature toggles, example
- about / A Feature Toggle example
- Fibonacci service, implementing / Implementing the Fibonacci service
- template engine, working with / Working with the template engine
- FF4J
- reference link / Feature Toggles
- Fibonacci's sequence
- reference link / Implementing the Fibonacci service
- functional tests / Why not use unit tests exclusively?
- functions
- about / Functions revisited
- Reverse Polish Notation (RPN) / Kata – Reverse Polish Notation
G
- Gradle project
- setting up, in IntelliJ IDEA / Setting up Gradle/Java project in IntelliJ IDEA
- Grizzly
- reference link / Automating the test cases
H
- helper classes / Helper classes
- Hudson
- reference link / Processes
I
- infrastructure team (IT) / Deployments to production
- integration tests / Why not use unit tests exclusively?, Integration tests
- IntelliJ IDEA
- Gradle project, setting up / Setting up Gradle/Java project in IntelliJ IDEA
- Java project, setting up / Setting up Gradle/Java project in IntelliJ IDEA
J
- Java Code Coverage (JaCoCo)
- reference link / Tools
- Java Functional Programming
- environment, setting up / Setting up the environment
- Java project
- setting up, in IntelliJ IDEA / Setting up Gradle/Java project in IntelliJ IDEA
- JBehave
- about / JBehave
- runner / JBehave runner
- pending steps / Pending steps
- steps / JBehave steps
- final validation / Final validation
- JBehave stories, writing
- reference link / The book store BDD story
- Jenkins
- reference link / Processes
- JUnit
- @Test annotation / The @Test annotation
- @BeforeClass annotation / The @BeforeClass and @AfterClass annotations
- @BeforeMethod annotation / The @BeforeMethod and @AfterMethod annotations
- @AfterMethod annotation / The @BeforeMethod and @AfterMethod annotations
- @Test(expectedExceptions = SomeClass.class) annotation argument / The @Test(expectedExceptions = SomeClass.class) annotation argument
- versus TestNG / TestNG versus JUnit summary
- reference link / TestNG versus JUnit summary
K
- kata exercise / The kata exercise
- keep it simple, stupid (KISS)
- about / Unit testing with TDD, Development practices
- reference link / Keep it simple, stupid
L
- legacy code
- about / Legacy code
- example / Legacy code example
- recognition / Other ways to recognize legacy code
- lack of dependency injection / A lack of dependency injection
- legacy code algorithm, applying
- about / Applying the legacy code algorithm
- end-to-end test cases, writing / Writing end-to-end test cases
- test cases, automating / Automating the test cases
- BookRepository dependency, injecting / Injecting the BookRepository dependency
- legacy code change algorithm / The legacy code change algorithm
- legacy code change algorithm, applying
- about / Applying the legacy code change algorithm
- change points, identifying / Identifying change points
- test points, finding / Finding test points
- dependencies, breaking / Breaking dependencies
- tests, writing / Writing tests
- legacy kata
- about / Legacy kata
- Alexandria project / Legacy kata
M
- markdown
- reference link / Documentation for coders
- Mars Rover / Remote-controlled ship requirements
- method reference / map
- Minimum Viable Product (MVP) / Narrative
- mocking
- about / Mocking, Mocking
- features / Why mocks?
- terminology / Terminology
- mock objects / Mock objects
- Mockito
- about / Mockito
N
- null class / Optional – dealing with uncertainty
O
- Occam's razor principle
- reference link / Occam's razor
- Optional class
- about / Example of Optional
- example / Example of Optional
- orientation, remote-controlled ship development
- position, keeping in memory / Specification – keeping position and direction in memory
- direction, keeping in memory / Specification – keeping position and direction in memory
- implementation / Implementation
- refactoring / Refactoring
- override call / Breaking dependencies
P
- partial mocking / Specification – adding items to the Mongo collection
- players, Tic-Tac-Toe game
- player X / Test – X plays first, Implementation
- player O / Test – O plays right after X, Implementation
- X's turn, checking / Test – X plays right after O
- police syndrome / Better tests
- Postman
- reference link / Writing end-to-end test cases
- preliminary investigation
- about / Preliminary investigation
- candidates, finding for refactoring / How to find candidates for refactoring
- new feature, introduction / Introducing the new feature
- primitive obsession
- reference link / Removing the primitive obsession with status as int
- Principles of OOD
- reference link / SOLID principles
- product owner (PO) / Adding a new feature
Q
- quality assurance (QA)
- versus quality checking / The difference between quality checking and quality assurance
- about / The difference between quality checking and quality assurance, Exploring the codebase
R
- red-green-refactor process
- about / Red-Green-Refactor, The Red-Green-Refactor process, TDD in a nutshell
- test, writing / Writing a test
- tests, executing / Running all the tests and confirming that the last one is failing, Running all the tests
- last test failure, confirming / Running all the tests and confirming that the last one is failing
- implementation code, writing / Writing the implementation code
- refactoring / Refactoring
- repeating / Repeating
- remote-controlled ship
- requirements / Remote-controlled ship requirements
- remote-controlled ship development
- about / Developing the remote-controlled ship
- project setup / Project setup
- helper classes / Helper classes
- starting point / Requirement – starting point and orientation
- orientation / Requirement – starting point and orientation
- forward moves / Requirement – forward and backward moves, Specification – moving forward
- backward moves / Requirement – forward and backward moves, Specification – moving backward
- ship, rotating / Requirement – rotating the ship
- commands / Requirement – commands
- spheric maps, representing / Requirement – representing spheric maps
- obstacles detection / Requirement – detecting obstacles
- REpresentational State Transfer (REST) / Release procedure
- requisites, Reverse Polish Notation (RPN)
- invalid input, handling / Requirement – handling invalid input
- single operations / Requirement – single operations
- complex operations / Requirement – complex operations
- RestAssured
- reference link / Automating the test cases
- Reverse Polish Notation (RPN)
- about / Functions revisited, Kata – Reverse Polish Notation
- requisites / Requirements
- Rule feature, JUnit
- reference link / Requirement 1 – placing pieces
S
- Selenide
- reference link / Selenium and Selenide
- Selenium
- reference link / Selenium and Selenide
- ship rotation, remote-controlled ship development
- specification, for turning left / Specification – turning left
- specification, for turning right / Specification – turning right
- software design / Why should we care about design?
- software design principles
- about / Design principles
- You Ain't Gonna Need It principle / You Ain't Gonna Need It
- Don't Repeat Yourself (DRY) principle / Don't Repeat Yourself
- keep it simple, stupid (KISS) / Keep it simple, stupid
- Occam's razor principle / Occam's razor
- SOLID principles
- single responsibility principle / SOLID principles
- open-closed principle / SOLID principles
- liskov substitution principle / SOLID principles
- interface segregation principle / SOLID principles
- dependency inversion principle / SOLID principles
- specifications, Behavior-Driven Development (BDD)
- documentation / Documentation
- documentation, for coders / Documentation for coders
- documentation, for non-coders / Documentation for non-coders
- spheric maps, remote-controlled ship development
- planet information / Specification – planet information, Implementation, Refactoring
- map boundaries / Specification – dealing with map boundaries
- Spring Boot
- reference link / A Feature Toggle example
- store moves, Tic-Tac-Toe v2
- DB name, specifying / Specification – DB name, Implementation
- name, defining for Mongo collection / Specification – a name for the Mongo collection, Refactoring
- items, adding to Mongo collection / Specification – adding items to the Mongo collection
- operation feedback, adding / Specification – adding operation feedback, Refactoring
- error handling / Specification – error handling, Specification – error handling
- clear state between games / Specification – clear state between games
- drop operation feedback / Specification – drop operation feedback
- store turn, Tic-Tac-Toe v2
- collection, creating / Specification – creating new collection, Specification refactoring
- current move, storing / Specification – storing current move
- error handling / Specification – error handling
- alternate players / Specification – alternate players, Exercises
- strategy pattern
- reference link / Identifying change points
- Streams
- about / Streams
- reference link / Streams
- filter function / filter
- map function / map
- flatMap function / flatMap
- reduce function / reduce
T
- TDD best practices
- about / Best practices
- naming conventions / Naming conventions
- processes / Processes
- development practices / Development practices
- tools / Tools
- test-driven development (TDD)
- about / Why TDD?, Understanding TDD, TDD in a nutshell
- red-green-refactor process / Red-Green-Refactor
- features / Speed is the key
- testable code design / It's not about testing
- test-first implementation, of Connect 4 game
- about / The TDD or test-first implementation
- Hamcrest, using / Hamcrest
- board / Requirement 1 – the game's board
- discs / Requirement 2 – introducing discs
- player shifts / Requirement 3 – player shifts
- output / Requirement 4 – the game's output
- win condition, scenarios / Requirement 5 – win condition (I), Requirement 7 – win condition (III), Requirement 8 – win condition (IV)
- test-last implementation, of Connect 4 game
- about / Test-last implementation of Connect 4
- board / Requirement 1 – the game's board
- discs / Requirement 2 – introducing discs
- player shifts / Requirement 3 – player shifts
- output / Requirement 4 – the game's output
- win condition, scenarios / Requirement 5 – win conditions (I), Requirement 7 – win condition (III), Requirement 8 – win condition (IV)
- test double / Mocking, Why not use unit tests exclusively?
- testing
- about / Testing
- black-box testing / Black-box testing
- white-box testing / White-box testing
- quality checking, versus quality assurance / The difference between quality checking and quality assurance
- TestNG
- about / TestNG
- @Test annotation / The @Test annotation
- @BeforeSuite annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @BeforeTest annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @BeforeGroups annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @AfterGroups annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @AfterTest annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @AfterSuite annotation / The @BeforeSuite, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest, and @AfterSuite annotations
- @AfterClass annotation / The @BeforeClass and @AfterClass annotations
- @Test(enable = false) annotation argument / The @Test(enable = false) annotation argument
- versus JUnit / TestNG versus JUnit summary
- reference link / TestNG versus JUnit summary
- tests
- separation, in Gradle / Tests separation
- thimblerig service / Case study – Awesome Gambling Corp
- Thymeleaf
- reference link / A Feature Toggle example
- Tic-Tac-Toe game
- requirements / Tic-Tac-Toe game requirements
- reference link / Tic-Tac-Toe game requirements
- developing / Developing Tic-Tac-Toe
- pieces, placing / Requirement 1 – placing pieces
- board boundaries / Test – board boundaries I, Implementation, Test – board boundaries II, Implementation
- pieces, placing on unoccupied spaces / Test – occupied spot, Implementation, Refactoring
- two players support, adding / Requirement 2 – adding two-player support
- win conditions, adding / Requirement 3 – adding winning conditions, Test – by default there's no winner, Implementation, Test – winning condition I, Implementation, Refactoring, Test – winning condition II, Implementation, Test – winning condition III, Implementation, Test – winning condition IV, Implementation, Refactoring
- tie condition / Requirement 4 – tie conditions, Test – handling a tie situation, Implementation, Refactoring
- code coverage / Code coverage
- integration test / The integration test
- Tic-Tac-Toe v2 game
- requirements / Tic-Tac-Toe v2 requirements
- Tic-Tac-Toe v2 game, developing
- about / Developing Tic-Tac-Toe v2
- moves, storing / Requirement 1 – store moves
- turn, storing / Requirement 2 – store every turn
- Togglz
- reference link / Feature Toggles
- Travis
- reference link / Processes
U
- unit testing
- about / Unit testing
- need for / Why unit testing?
- limitations / Why not use unit tests exclusively?
- with test-driven development (TDD) / Unit testing with TDD
- user acceptance tests / Test-last implementation of Connect 4
W
- white-box testing
- about / White-box testing
- advantages / White-box testing
- disadvantages / White-box testing
Y
- YAML Ain't Markup Language (YAML) / A Feature Toggle example
- You Ain't Gonna Need It principle
- reference link / You Ain't Gonna Need It