This document discusses test-driven development (TDD). TDD is an agile software development process where test cases are developed before code to validate functionality, with the goal of breaking problems into smaller pieces and preventing regressions. The key steps of TDD are writing a failing test, making the test pass by writing the minimum code, and refactoring the code. The document provides an example of incrementally building a Fibonacci number calculator using TDD. Benefits of TDD include breaking problems down into smaller pieces and preventing regressions, though critics argue it can add complexity and dogmatism if not applied properly.

1. TDD
what is it
good for?

2. David Simons
Developer
@
Softwire
<3 Databases
Part-time
Elf

6. Automated
Testing

7. Functional Testing

8. Stress Testing

9. Unit Testing

11. Flight
Availability
Repository
Flight
Availability
Service

12. Flight
Availability
Repository
Flight
Availability
Service

13. Test Double

14. Flight
Availability
Service
Flight
Availability
Repository

15. Flight
Availability
Service
Flight
Availability
Repository
isAvailable?

16. Flight
Availability
Service
Flight
Availability
Repository
no

17. What is TDD?

18. Test
Driven
Development

19. Failing Test
Make it Pass
Refactor

20. Failing Test
Make it Pass
Refactor

21. Failing Test
Make it Pass
Refactor

22. Failing Test
Make it Pass
Refactor

23. Failing Test
Make it Pass
Refactor

24. Failing Test
Make it Pass
Refactor

25. Failing Test
Make it Pass
Refactor

26. Failing Test
Make it Pass
Refactor

27. Failing Test
Make it Pass
Refactor

28. Failing Test
Make it Pass
Refactor

29. Failing Test
Make it Pass
Refactor

30. Failing Test
Make it Pass
Refactor

31. Failing Test
Make it Pass
Refactor

32. All possible tests pass

34. @Unroll
def "Fib Number #input is #result"() {
given:
def fibCalc = new FibCalculator()
expect:
fibCalc.calculate(input) == result
}
where:
input| result
0 | | 0

35. where:
input| result
0 | 0
int calculate(int input) {
0
}

36. where:
input| result
0 | 0
1 | 1
int calculate(int input) {
0
}

37. where:
input| result
0 | 0
1 | 1
int calculate(int input) {
input
}

38. where:
input| result
0 | 0
1 | 1
2 | 1
int calculate(int input) {
input
}

39. where:
input| result
0 | 0
1 | 1
2 | 1
int calculate(int input) {
if(input == 0) {
return 0
}
1
}

40. where:
input| result
0 | 0
1 | 1
2 | 1
3 | 2
int calculate(int input) {
if(input == 0) {
return 0
}
1
}

41. where:
input| result
0 | 0
1 | 1
2 | 1
3 | 2
int calculate(int input) {
if(input == 0) {
return 0
}
if(input <= 2) {
return 1
}
2
}

42. where:
input| result
0 | 0
1 | 1
2 | 1
3 | 2
int calculate(int input) {
if(input < 2) {
return input
}
1 + calculate(input – 2)
}

43. where:
input| result
0 | 0
1 | 1
2 | 1
3 | 2
4 | 3
int calculate(int input) {
if(input < 2) {
return input
}
1 + calculate(input – 2)
}

44. where:
input| result
0 | 0
1 | 1
2 | 1
3 | 2
4 | 3
int calculate(int input) {
if(input < 2) {
return input
}
calculate(input - 2) + calculate(input – 1)
}

45. The Benefits

46. Breaking Down
Pr o b l e m s

47. Testing Anti-Patterns

48. Regression
Testing

49. DHH

50. “the test-first
rhetoric got louder
and angrier”

51. “look at what that
approach is doing to
the integrity of your
system design”

52. (I had to
do this)

53. Is TDD Dead?

54. Added
Complexity

55. Dogmatism

56. TDD
is it dead?

58. any
questions?
@SwamWithTurtles