Real Developers Don’t Need Unit Tests
Mythbusting TDD myths




                        John Ferguson Smart
              ...
Introduction
Real Developers Don’t Need Unit Tests
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?




             Chuck Norris’s code doesn’t have bugs
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?




               Chuck Norris’s code doesn’t have bugs




...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?




                     Chuck Norris’s co...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?




                      Chuck Norris’s c...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?


            ...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?


            ...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
    Bugs?
  Emergent design?
   Technical documentation?
      Executab...
Introduction
Real Developers Don’t Need Unit Tests
Introduction
Real Developers Don’t Need Unit Tests




           OK, so Chuck Norris doesn’t need Unit Tests
Introduction
Real Developers Don’t Need Unit Tests




           OK, so Chuck Norris doesn’t need Unit Tests




        ...
TDD Basics
TDD Basics




         So what is this TDD thing, anyway?
TDD Basics
TDD is not about writing tests




              So what is this TDD thing, anyway?
TDD Basics
TDD is not about writing tests
TDD is a design strategy:




              So what is this TDD thing, anyway?
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code




               So what...
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code
 Have more confidence in ou...
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code
 Have more confidence in ou...
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code
 Have more confidence in ou...
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code
 Have more confidence in ou...
TDD Basics
TDD is not about writing tests
TDD is a design strategy:
 Write better-designed code
 Have more confidence in ou...
TDD Basics
The TDD development process
“Never write a single line of code unless you have a failing automated test.
      ...
TDD Basics
The TDD development process
“Never write a single line of code unless you have a failing automated test.
      ...
TDD Basics
The TDD development process
“Never write a single line of code unless you have a failing automated test.
      ...
TDD Basics
The TDD development process
“Never write a single line of code unless you have a failing automated test.
      ...
TDD Basics
               TEST


              CODE


             REFACTOR
TDD Basics
Step 1) Write a test     TEST


                        CODE


                       REFACTOR
TDD Basics
Step 1) Write a test                      TEST

 Design your code from the outside-in
                         ...
TDD Basics
Step 1) Write a test                      TEST

 Design your code from the outside-in
  How will your code be u...
TDD Basics
Step 1) Write a test                         TEST

 Design your code from the outside-in
  How will your code b...
TDD Basics
Step 1) Write a test                                 TEST

 Design your code from the outside-in
  How will you...
TDD Basics
Step 1) Write a test                                 TEST

 Design your code from the outside-in
  How will you...
TDD Basics
Step 1) Write a test                                      TEST

 Design your code from the outside-in
  How wil...
TDD Basics
               TEST


              CODE


             REFACTOR
TDD Basics
Step 2) Write some code     TEST


                           CODE


                          REFACTOR
TDD Basics
Step 2) Write some code                      TEST

 Just enough code to make the tests pass
                   ...
TDD Basics
Step 2) Write some code                                 TEST

 Just enough code to make the tests pass
 Might m...
TDD Basics
Step 2) Write some code                                  TEST

 Just enough code to make the tests pass
 Might ...
TDD Basics
               TEST


              CODE


             REFACTOR
TDD Basics
                                                     TEST


                                                   ...
TDD Basics
Step 3) Tidy up                                           TEST


                                              ...
TDD Basics
Step 3) Tidy up                                             TEST

 Evolutionary (emerging) design
             ...
TDD Basics
Step 3) Tidy up                                              TEST

 Evolutionary (emerging) design
  Keep the c...
TDD Basics
Step 3) Tidy up                                              TEST

 Evolutionary (emerging) design
  Keep the c...
TDD Basics
Step 3) Tidy up                                                TEST

 Evolutionary (emerging) design
  Keep the...
TDD Basics
Step 3) Tidy up                                                 TEST

 Evolutionary (emerging) design
  Keep th...
TDD in Action - the Game Of Life
TDD in Action - the Game Of Life


         So where do we start?
TDD in Action - the Game Of Life


         So where do we start?


             Let’s list some requirements
TDD in Action - the Game Of Life


                 So where do we start?


                     Let’s list some requireme...
TDD in Action




              The Game of Life
- Live cells with less than 2 live neighbours die
- Live cells with more ...
TDD in Action


                     Now what?




              The Game of Life
- Live cells with less than 2 live neigh...
TDD in Action


                     Now what?


                       So what do we mean by this first requirement?



 ...
TDD in Action




              The Game of Life
- Live cells with less than 2 live neighbours die
- Live cells with more ...
TDD in Action


                  So what do we have to code for this one.




              The Game of Life
- Live cells...
TDD in Action


                  So what do we have to code for this one.


                   Dunno yet. Let’s write som...
TDD in Action


                  So what do we have to code for this one.


                    Dunno yet. Let’s write so...
TDD in Action
TDD in Action


        Great, so now I can start coding, right?
TDD in Action


        Great, so now I can start coding, right?

               Not so fast, hot shot. We need to turn th...
TDD in Action


        Great, so now I can start coding, right?

                 Not so fast, hot shot. We need to turn ...
TDD in Action




        public class GameOfLifeTest {

            @Test
            public void aCellWithNoNeighboursSh...
TDD in Action


            I still don’t know what to write in this test...




        public class GameOfLifeTest {

  ...
TDD in Action


            I still don’t know what to write in this test...


                  Start by expressing what ...
TDD in Action


            I still don’t know what to write in this test...


                  Start by expressing what ...
TDD in Action




        public class GameOfLifeTest {

            @Test
            public void aCellWithNoNeighboursSh...
TDD in Action


        But that test will fail! What now?




        public class GameOfLifeTest {

            @Test
  ...
TDD in Action


        But that test will fail! What now?


            How you would like the code to look, if you had t...
TDD in Action


        But that test will fail! What now?


            How you would like the code to look, if you had t...
TDD in Action


     public class GameOfLifeTest {

         @Test
         public void aCellWithNoNeighboursShouldDieInTh...
TDD in Action
         So what’s so special about this test?


     public class GameOfLifeTest {

         @Test
        ...
TDD in Action
         So what’s so special about this test?
                                                   The test n...
TDD in Action
         So what’s so special about this test?
                                                   The test n...
TDD in Action
         So what’s so special about this test?
                                                   The test n...
TDD in Action
                   So what’s so special about this test?
                                                   ...
TDD in Action




        public class GameOfLifeTest {

            @Test
            public void aCellWithNoNeighboursSh...
TDD in Action


                  So what now?




        public class GameOfLifeTest {

            @Test
            pu...
TDD in Action


                  So what now?


                  This is our acceptance test. Now we drill down.



    ...
TDD in Action


                  So what now?


                  This is our acceptance test. Now we drill down.



    ...
TDD in Action




        public class GameOfLifeTest {

            @Test
            public void aCellWithNoNeighboursSh...
TDD in Action


            So I guess you’ll say we need to write a test?




        public class GameOfLifeTest {

    ...
TDD in Action


            So I guess you’ll say we need to write a test?


                  Spot on! You catch on fast!...
TDD in Action


            So I guess you’ll say we need to write a test?


                   Spot on! You catch on fast...
TDD in Action




        public class UniverseTest {

            @Test
            public void aUniverseSeededWithAnEmpy...
TDD in Action


            So now can we code?




        public class UniverseTest {

             @Test
             p...
TDD in Action


            So now can we code?


                   Yes, but just a little bit

        public class Univ...
TDD in Action


            So now can we code?


                   Yes, but just a little bit

        public class Univ...
TDD in Action
TDD in Action


       Er, isn’t that a bit too simple.
TDD in Action


       Er, isn’t that a bit too simple.

            Yes. We need another test to tease out
              ...
TDD in Action


       Er, isn’t that a bit too simple.

            Yes. We need another test to tease out
              ...
TDD in Action


       Er, isn’t that a bit too simple.

            Yes. We need another test to tease out
              ...
TDD in Action


       Er, isn’t that a bit too simple.

            Yes. We need another test to tease out
              ...
TDD in Action




         public class Universe {

             private String currentContent;

         	   public Unive...
TDD in Action

       Well, now at least those two
               tests pass.




           public class Universe {

    ...
TDD in Action

       Well, now at least those two
               tests pass.

                 Now we need to implement t...
TDD for unbelievers


              So TDD is the answer to all my problems?


                No, sorry, TDD is not a Sil...
TDD for unbelievers

             But how can I write tests if I don’t know what the code looks like?


                  ...
TDD for unbelievers


                          I don’t have time to write tests

                  But you have time to f...
TDD for unbelievers


              But I'm writing more test code than application code!

                Sure, writing t...
TDD for unbelievers


                 My tests break whenever I change my code

                  Try to test the behavio...
TDD for unbelievers


           Our tests are too hard and take too much time to keep up to date

                       ...
TDD for unbelievers


                 I found a bug in the production code. TDD doesn’t work.

                          ...
TDD for unbelievers

             I’ve heard TDD encourages sloppy design. Isn't it better to have a
                  gen...
TDD for unbelievers

             I use a database/network/web service... and TDD-style unit tests
                       ...
TDD for unbelievers


                   Our BAs and product owners aren’t buying this TDD stuff

                        ...
TDD for unbelievers


                   Our BAs and product owners aren’t buying this TDD stuff

                        ...
TDD for unbelievers


                   Our BAs and product owners aren’t buying this TDD stuff

                        ...
TDD for unbelievers

           Many BDD tools also have great reporting features




                                    ...
TDD for unbelievers

            Many BDD tools have great reporting features

                                           ...
TDD for unbelievers


            “I’ve tried TDD, but I soon lapse back into my old code-first habits”

                 ...
Conclusion
Real Developers Don’t Need Unit Tests?




            So maybe Chuck should be writing
                  unit ...
Thank You



     John Ferguson Smart
     Wakaleo Consulting Ltd.
     http://www.wakaleo.com
     Email: john.smart@waka...
Upcoming SlideShare
Loading in...5
×

Real Developers Don't Need Unit Tests

5,443

Published on

Unit testing is a vital but neglected art. Good unit tests don't just test code: they are executable requirements that tell the story of your application, clarify your design, document your code and help track your progress. They help you find bugs fast, and fix them with confidence. If Real programmers don't need unit tests, they sure make life easier for the rest of us!

Published in: Technology

Transcript of "Real Developers Don't Need Unit Tests"

  1. 1. Real Developers Don’t Need Unit Tests Mythbusting TDD myths John Ferguson Smart Wakaleo Consulting Ltd. http://www.wakaleo.com Email: john.smart@wakaleo.com Twitter: wakaleo
  2. 2. Introduction Real Developers Don’t Need Unit Tests
  3. 3. Introduction Real Developers Don’t Need Unit Tests Bugs?
  4. 4. Introduction Real Developers Don’t Need Unit Tests Bugs? Chuck Norris’s code doesn’t have bugs
  5. 5. Introduction Real Developers Don’t Need Unit Tests Bugs? Chuck Norris’s code doesn’t have bugs His code always work. ALWAYS.
  6. 6. Introduction Real Developers Don’t Need Unit Tests Bugs?
  7. 7. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design?
  8. 8. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Chuck Norris’s code is perfectly designed the first time round
  9. 9. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Chuck Norris’s code is perfectly designed the first time round His favorite design pattern is the Roundhouse Kick
  10. 10. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design?
  11. 11. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation?
  12. 12. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Chuck Norris doesn’t need technical documentation
  13. 13. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Chuck Norris doesn’t need technical documentation He just stares down the code until it tells him everything he wants to know
  14. 14. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation?
  15. 15. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements?
  16. 16. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements? Chuck Norris doesn’t need requirements to be executable
  17. 17. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements? Chuck Norris doesn’t need requirements to be executable He can execute whatever he wants
  18. 18. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements?
  19. 19. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements? Acceptance Tests?
  20. 20. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements? Acceptance Tests? Chuck Norris doesn’t need acceptance tests
  21. 21. Introduction Real Developers Don’t Need Unit Tests Bugs? Emergent design? Technical documentation? Executable requirements? Acceptance Tests? Chuck Norris doesn’t need acceptance tests No one refuses to accept Chuck
  22. 22. Introduction Real Developers Don’t Need Unit Tests
  23. 23. Introduction Real Developers Don’t Need Unit Tests OK, so Chuck Norris doesn’t need Unit Tests
  24. 24. Introduction Real Developers Don’t Need Unit Tests OK, so Chuck Norris doesn’t need Unit Tests But what about the rest of us?
  25. 25. TDD Basics
  26. 26. TDD Basics So what is this TDD thing, anyway?
  27. 27. TDD Basics TDD is not about writing tests So what is this TDD thing, anyway?
  28. 28. TDD Basics TDD is not about writing tests TDD is a design strategy: So what is this TDD thing, anyway?
  29. 29. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code So what is this TDD thing, anyway?
  30. 30. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code Have more confidence in our code So what is this TDD thing, anyway?
  31. 31. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code Have more confidence in our code Make changes more easily So what is this TDD thing, anyway?
  32. 32. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code Have more confidence in our code Make changes more easily Write code that meets user requirements more accurately So what is this TDD thing, anyway?
  33. 33. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code Have more confidence in our code Make changes more easily Write code that meets user requirements more accurately (and incidentally...) So what is this TDD thing, anyway?
  34. 34. TDD Basics TDD is not about writing tests TDD is a design strategy: Write better-designed code Have more confidence in our code Make changes more easily Write code that meets user requirements more accurately (and incidentally...) Build up a comprehensive set of automated tests So what is this TDD thing, anyway?
  35. 35. TDD Basics The TDD development process “Never write a single line of code unless you have a failing automated test. Eliminate duplication.” - Kent Beck
  36. 36. TDD Basics The TDD development process “Never write a single line of code unless you have a failing automated test. Eliminate duplication.” - Kent Beck TEST Write a failing unit test. Ensure that it fails.
  37. 37. TDD Basics The TDD development process “Never write a single line of code unless you have a failing automated test. Eliminate duplication.” - Kent Beck TEST Write a failing unit test. Ensure that it fails. CODE Write production code to make the test pass.
  38. 38. TDD Basics The TDD development process “Never write a single line of code unless you have a failing automated test. Eliminate duplication.” - Kent Beck TEST Write a failing unit test. Ensure that it fails. CODE Write production code to make the test pass. REFACTOR Tidy up the design
  39. 39. TDD Basics TEST CODE REFACTOR
  40. 40. TDD Basics Step 1) Write a test TEST CODE REFACTOR
  41. 41. TDD Basics Step 1) Write a test TEST Design your code from the outside-in CODE REFACTOR
  42. 42. TDD Basics Step 1) Write a test TEST Design your code from the outside-in How will your code be used? CODE REFACTOR
  43. 43. TDD Basics Step 1) Write a test TEST Design your code from the outside-in How will your code be used? CODE Design a clean interface for your code REFACTOR
  44. 44. TDD Basics Step 1) Write a test TEST Design your code from the outside-in How will your code be used? CODE Design a clean interface for your code Implement only features that are really needed REFACTOR
  45. 45. TDD Basics Step 1) Write a test TEST Design your code from the outside-in How will your code be used? CODE Design a clean interface for your code Implement only features that are really needed REFACTOR Provide examples of how you expect your code to be used
  46. 46. TDD Basics Step 1) Write a test TEST Design your code from the outside-in How will your code be used? CODE Design a clean interface for your code Implement only features that are really needed REFACTOR Provide examples of how you expect your code to be used How will my code be used by the rest of the application? ?
  47. 47. TDD Basics TEST CODE REFACTOR
  48. 48. TDD Basics Step 2) Write some code TEST CODE REFACTOR
  49. 49. TDD Basics Step 2) Write some code TEST Just enough code to make the tests pass CODE REFACTOR
  50. 50. TDD Basics Step 2) Write some code TEST Just enough code to make the tests pass Might mean a non-optimal solution at this stage... CODE REFACTOR
  51. 51. TDD Basics Step 2) Write some code TEST Just enough code to make the tests pass Might mean a non-optimal solution at this stage... CODE REFACTOR Just make it pass the test...
  52. 52. TDD Basics TEST CODE REFACTOR
  53. 53. TDD Basics TEST CODE REFACTOR It works. Now let’s tidy things up.
  54. 54. TDD Basics Step 3) Tidy up TEST CODE REFACTOR It works. Now let’s tidy things up.
  55. 55. TDD Basics Step 3) Tidy up TEST Evolutionary (emerging) design CODE REFACTOR It works. Now let’s tidy things up.
  56. 56. TDD Basics Step 3) Tidy up TEST Evolutionary (emerging) design Keep the code clean! CODE REFACTOR It works. Now let’s tidy things up.
  57. 57. TDD Basics Step 3) Tidy up TEST Evolutionary (emerging) design Keep the code clean! CODE Remove duplication and fix design problems REFACTOR It works. Now let’s tidy things up.
  58. 58. TDD Basics Step 3) Tidy up TEST Evolutionary (emerging) design Keep the code clean! CODE Remove duplication and fix design problems Restructure existing code - no new features! REFACTOR It works. Now let’s tidy things up.
  59. 59. TDD Basics Step 3) Tidy up TEST Evolutionary (emerging) design Keep the code clean! CODE Remove duplication and fix design problems Restructure existing code - no new features! REFACTOR Make sure the tests still pass! It works. Now let’s tidy things up.
  60. 60. TDD in Action - the Game Of Life
  61. 61. TDD in Action - the Game Of Life So where do we start?
  62. 62. TDD in Action - the Game Of Life So where do we start? Let’s list some requirements
  63. 63. TDD in Action - the Game Of Life So where do we start? Let’s list some requirements The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live cells with 2 or 3 live neighbours remain alive - Dead cells with 3 neighbours become alive
  64. 64. TDD in Action The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  65. 65. TDD in Action Now what? The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  66. 66. TDD in Action Now what? So what do we mean by this first requirement? The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  67. 67. TDD in Action The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  68. 68. TDD in Action So what do we have to code for this one. The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  69. 69. TDD in Action So what do we have to code for this one. Dunno yet. Let’s write some acceptance tests to find out The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live User Story 1or Less than 2 neighbours die cells with 2 - 3 live neighbours remain alive - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive When the next generation is created Then this cell will die
  70. 70. TDD in Action So what do we have to code for this one. Dunno yet. Let’s write some acceptance tests to find out The Game of Life - Live cells with less than 2 live neighbours die - Live cells with more than 3 live neighbours die - Live UserUser StoryLessAcceptance criteria die cells Story 1or 3 live neighbours remain alive with 2 - 1 - than 2 neighbours - Dead cells cell with less than 2 live neighbours Given a with 3 neighbours become alive Sample grid transitions: 1) 2) When the next generation is created Then this cell will die
  71. 71. TDD in Action
  72. 72. TDD in Action Great, so now I can start coding, right?
  73. 73. TDD in Action Great, so now I can start coding, right? Not so fast, hot shot. We need to turn this into an ‘executable requirement’
  74. 74. TDD in Action Great, so now I can start coding, right? Not so fast, hot shot. We need to turn this into an ‘executable requirement’ public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { } }
  75. 75. TDD in Action public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { } }
  76. 76. TDD in Action I still don’t know what to write in this test... public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { } }
  77. 77. TDD in Action I still don’t know what to write in this test... Start by expressing what you are trying to achieve public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { } }
  78. 78. TDD in Action I still don’t know what to write in this test... Start by expressing what you are trying to achieve public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; String nextGrid = null; assertThat(nextGrid, is(expectedNextGrid)); } }
  79. 79. TDD in Action public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; String nextGrid = null; assertThat(nextGrid, is(expectedNextGrid)); } }
  80. 80. TDD in Action But that test will fail! What now? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; String nextGrid = null; assertThat(nextGrid, is(expectedNextGrid)); } }
  81. 81. TDD in Action But that test will fail! What now? How you would like the code to look, if you had to use it? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; String nextGrid = null; assertThat(nextGrid, is(expectedNextGrid)); } }
  82. 82. TDD in Action But that test will fail! What now? How you would like the code to look, if you had to use it? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  83. 83. TDD in Action public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  84. 84. TDD in Action So what’s so special about this test? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  85. 85. TDD in Action So what’s so special about this test? The test name describes the expected behaviour public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  86. 86. TDD in Action So what’s so special about this test? The test name describes the expected behaviour public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } } We started by expressing our expectations
  87. 87. TDD in Action So what’s so special about this test? The test name describes the expected behaviour public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + The code is written for API "...n" + users, not API developers "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } } We started by expressing our expectations
  88. 88. TDD in Action So what’s so special about this test? The test name describes the expected behaviour public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; It’s a working String expectedNextGrid = "...n" + The code is written for API example of how "...n" + users, not API developers to use the class "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } } We started by expressing our expectations
  89. 89. TDD in Action public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  90. 90. TDD in Action So what now? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  91. 91. TDD in Action So what now? This is our acceptance test. Now we drill down. public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  92. 92. TDD in Action So what now? This is our acceptance test. Now we drill down. public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  93. 93. TDD in Action public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  94. 94. TDD in Action So I guess you’ll say we need to write a test? public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  95. 95. TDD in Action So I guess you’ll say we need to write a test? Spot on! You catch on fast! public class GameOfLifeTest { @Test public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { String initialGrid = "...n" + "...n" + "..."; String expectedNextGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  96. 96. TDD in Action So I guess you’ll say we need to write a test? Spot on! You catch on fast! public class UniverseTest { @Test public class GameOfLifeTest { public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() { @Test String seededGrid = "...n" + public void aCellWithNoNeighboursShouldDieInTheNextGeneration() { "...n" + String initialGrid = "...n" + "..."; "...n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); String expectedNextGrid = "...n" + assertThat(currentGrid, is(seededGrid)); "...n" + } "..."; } Universe theUniverse = new Universe(seededWith(initialGrid)); theUniverse.createNextGeneration(); String nextGrid = theUniverse.getGrid(); assertThat(nextGrid, is(expectedNextGrid)); } }
  97. 97. TDD in Action public class UniverseTest { @Test public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() { String seededGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } }
  98. 98. TDD in Action So now can we code? public class UniverseTest { @Test public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() { String seededGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } }
  99. 99. TDD in Action So now can we code? Yes, but just a little bit public class UniverseTest { @Test public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() { String seededGrid = "...n" + "...n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } }
  100. 100. TDD in Action So now can we code? Yes, but just a little bit public class UniverseTest { @Test public class Universe { public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() { public Universe(String initialGridContents) {} String seededGrid = "...n" + public static String seededWith(String gridContents) { "...n" + return null; "..."; } Universe theUniverse = new Universe(seededWith(seededGrid)); public void createNextGeneration() {} String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } public String getGrid() { } return "...n" + "...n" + "..."; } }
  101. 101. TDD in Action
  102. 102. TDD in Action Er, isn’t that a bit too simple.
  103. 103. TDD in Action Er, isn’t that a bit too simple. Yes. We need another test to tease out a more complete design
  104. 104. TDD in Action Er, isn’t that a bit too simple. Yes. We need another test to tease out a more complete design public class UniverseTest { @Test public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() {...} @Test public void aUniverseSeededWithANonEmpyGridContentWillContainThatGrid() { String seededGrid = "...n" + ".*.n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } }
  105. 105. TDD in Action Er, isn’t that a bit too simple. Yes. We need another test to tease out a more complete design public class UniverseTest { @Test public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() {...} @Test public void aUniverseSeededWithANonEmpyGridContentWillContainThatGrid() { String seededGrid = "...n" + ".*.n" + "..."; Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); assertThat(currentGrid, is(seededGrid)); } }
  106. 106. TDD in Action Er, isn’t that a bit too simple. Yes. We need another test to tease out a more complete design public class Universe { public class UniverseTest { private String currentContent; @Test public Universe(String initialGridContents) { public void aUniverseSeededWithAnEmpyGridContentWillContainAnEmptyGrid() {...} currentContent = initialGridContents; } @Test public void aUniverseSeededWithANonEmpyGridContentWillContainThatGrid() { public static String seededWith(String gridContents) { return gridContents; String seededGrid = "...n" + } ".*.n" + "..."; public void createNextGeneration() { } Universe theUniverse = new Universe(seededWith(seededGrid)); String currentGrid = theUniverse.getGrid(); public String getGrid() { assertThat(currentGrid, is(seededGrid)); return currentContent; } } } }
  107. 107. TDD in Action public class Universe { private String currentContent; public Universe(String initialGridContents) { currentContent = initialGridContents; } public static String seededWith(String gridContents) { return gridContents; } public void createNextGeneration() { } public String getGrid() { return currentContent; } }
  108. 108. TDD in Action Well, now at least those two tests pass. public class Universe { private String currentContent; public Universe(String initialGridContents) { currentContent = initialGridContents; } public static String seededWith(String gridContents) { return gridContents; } public void createNextGeneration() { } public String getGrid() { return currentContent; } }
  109. 109. TDD in Action Well, now at least those two tests pass. Now we need to implement the ‘createNextGeneration()’ method... public class Universe { private String currentContent; public Universe(String initialGridContents) { currentContent = initialGridContents; } public static String seededWith(String gridContents) { return gridContents; } public void createNextGeneration() { } public String getGrid() { return currentContent; } }
  110. 110. TDD for unbelievers So TDD is the answer to all my problems? No, sorry, TDD is not a Silver Bullet You still have to use your brain Also use other design activities (domain modeling, DDD,...) TDD is not applicable everywhere Highly visual coding, ‘know it when you see it’ stuff,... TDD works best if you have a vision
  111. 111. TDD for unbelievers But how can I write tests if I don’t know what the code looks like? How can you write code when you can’t express what it should do? “Write code for others as you would have them write code for you” - Some agile dude TDD is about expressing the intent of your code It is a design practice Design your code “outside-in”
  112. 112. TDD for unbelievers I don’t have time to write tests But you have time to fix the code afterwards, right? “I can get it done much faster if it doesn’t have to work” - Kent Beck (paraphrased) New TDDers will take maybe 20-30% longer Experienced TDD developers don’t spend much (if any) more time coding But the code is of much higher quality
  113. 113. TDD for unbelievers But I'm writing more test code than application code! Sure, writing tests is part of the process You will write lots of tests... ...but your code will be more focused and more accurate
  114. 114. TDD for unbelievers My tests break whenever I change my code Try to test the behaviour, not the implementation Validate behaviour, don’t verify implementation
  115. 115. TDD for unbelievers Our tests are too hard and take too much time to keep up to date Treat your test code as production code Be wary of test maintenance overhead Test code is not second-class code Refactor to keep your test code maintanable Avoid technical dept
  116. 116. TDD for unbelievers I found a bug in the production code. TDD doesn’t work. see “TDD is not a Silver Bullet” You still need your testers! You can still make mistakes... ...but they are easier to isolate and to fix If you find a bug, just add another test to reproduce it, then fix it!
  117. 117. TDD for unbelievers I’ve heard TDD encourages sloppy design. Isn't it better to have a general vision of the problem before coding the solution?" Sometimes, yes. That's what the refactoring phase is for. TDD does not preclude initial high-level design Brainstorm a high-level design approach Define a common well-known domain language Use an ‘Iteration 0’ and spikes Don’t be afraid to refactor TDD works better when you have a vision
  118. 118. TDD for unbelievers I use a database/network/web service... and TDD-style unit tests can't test it. TDD doesn't work You will need integration tests too Unit tests when you can, integrations tests when you must Integration tests for system boundaries Mock out these boundary classes for the rest of your tests
  119. 119. TDD for unbelievers Our BAs and product owners aren’t buying this TDD stuff Try putting them into the feedback loop Acceptance-Test Driven Development is about communication BDD help BAs and POs participate in writing executable requirements scenario "A cell with less than 2 live neighbours should die", { given "Given a cell with no live neighbours", when "a new generation is generated", then "that cell will have died" }
  120. 120. TDD for unbelievers Our BAs and product owners aren’t buying this TDD stuff Try putting them into the feedback loop Acceptance-Test Driven Development is about communication BDD help BAs and POs participate in writing executable requirements scenario "A cell with less than 2 live neighbours should die", { given "Given a cell with no live neighbours", { initialGrid = ""... .*. ..."" theUniverse = new Universe(seededWith(initialGrid)); } when "a new generation is generated", { theUniverse.createNextGeneration() } then "that cell will have died", { theUniverse.grid.shouldBe ""... ... ..."" } }
  121. 121. TDD for unbelievers Our BAs and product owners aren’t buying this TDD stuff Try putting them into the feedback loop Acceptance-Test Driven Development is about communication BDD help BAs and POs participate in writing executable requirements Given a living cell with no live neighbours like this ... .*. ... When a new generation is generated then the grid should look like this: ... ... ...
  122. 122. TDD for unbelievers Many BDD tools also have great reporting features Test results summary Unimplemented stories Failed stories
  123. 123. TDD for unbelievers Many BDD tools have great reporting features Test results summary Test failure details Unimplemented stories
  124. 124. TDD for unbelievers “I’ve tried TDD, but I soon lapse back into my old code-first habits” TDD takes practice and know-how Unit tests when you can, integrations tests when you must Learn about TDD - read books on TDD practices Do pair program with someone who knows TDD Participate in and organize coding dojos <blatant plug>Training/mentoring</blatant plug>
  125. 125. Conclusion Real Developers Don’t Need Unit Tests? So maybe Chuck should be writing unit tests after all... I agree. You go talk to him
  126. 126. Thank You John Ferguson Smart Wakaleo Consulting Ltd. http://www.wakaleo.com Email: john.smart@wakaleo.com Twitter: wakaleo
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×