SlideShare a Scribd company logo

TDD for the Win

Download as PPTX, PDF
Thoughtworks, profile picture
Thoughtworks

The document discusses test-driven development (TDD). It explains that TDD involves writing tests before writing code to ensure full test coverage and prevent bugs. Tests are written to specify all functionality and edge cases, which serves as documentation. The process of red-green-refactor is demonstrated, where tests are written to fail initially ("red"), then minimum code is written to pass the tests ("green"), and code is refactored to improve design. An example of using TDD to develop a string mommifier method is provided across multiple code snippets to illustrate the process.

Technology
Related topics:
Agile Development • Software Testing Insights • agile-software-development
1 of 76
Downloaded 11 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
TDD FOR THE WIN Basics to Test Driven Development May 2014 Minh Ngoc Dang
Senior Developer at ThoughtWorks ThoughtWorks University Trainer Minh Ngoc Dang
TESTING
WHY TESTING? Lots of reasons! Here are a select few Verify functionality of application Catch bugs and prevent them from coming back Serve as documentation for maintainability purposes
BUT WHAT ABOUT…? ? How do we make sure we have full test coverage? ? How can we be confident all cases are covered? ? How can we prevent bugs from happening?
TDD!
TEST DRIVEN DEVELOPMENT!
BUT WAIT…WHAT IS IT?
BUT WAIT…WHAT IS IT?
TEST DRIVING MEANS Writing tests before writing code Write the minimum amount of code necessary to make tests pass Rinse and repeat
TESTS FIRST?! BUT WHY?
WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
TEST COVERAGE Tests written before code
TEST COVERAGE Tests written before code Ensure all code covered by tests
TEST COVERAGE Tests written before code Ensure all code covered by tests High test coverage
WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
TEST CASES Test cases reflect exactly what code does
TEST CASES Test cases reflect exactly what code does Visible list of functionality
TEST CASES Test cases reflect exactly what code does Visible list of functionality Easy to see which cases are missing
WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
BUG PREVENTION Mental shift in thinking up test case before code
BUG PREVENTION Mental shift in thinking up test case before code Encourage edge case testing
BUG PREVENTION Mental shift in thinking up test case before code Encourage edge case testing Help prevent bugs in edge cases
WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
AND THAT’S NOT ALL!
TIME SAVER Ease in debugging Confidence in refactoring
DRIVING DESIGN Help define usage – How should the code be used? Only write necessary code – YAGNI!
SO HOW CAN I TDD?
RED – GREEN - REFACTOR New Test New Test New Test Red GreenRefactor Red GreenRefactor Red GreenRefactor
EXAMPLE You are given strings of different lengths. If the number of vowels are more than 30% of the string length then insert ‘mommy’ for each continuous set of vowels.  his → hmommys  hear → hmommyr ✗ hear → hmommymommyr
TEST CASES “” → “” // empty string “str” → “str” // no vowels “a” → “mommy” // single vowel “blah” → “blah” // < 30% length “bla” → “blmommy” // > 30% length “blaa” → “blmommy” // continuous vowels “blaaha” → “blmommyhmommy” // multi sets of vowels “blA” → “blmommy” // capital letters Null → raise exception // null checks
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
SOURCE public class Mommifier { public String mommify(String word) { return null; } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
SOURCE public class Mommifier { public String mommify(String word) { return ""; } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
SOURCE public class Mommifier { public String mommify(String word) { return word; } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
SOURCE public class Mommifier { public String mommify(String word) { for (char character : word.toCharArray()) { if (character == 'a' || character == 'e' || character == 'i' || character == 'o' || character == 'u'){ return "mommy"; } } return word; } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
SOURCE public class Mommifier { public String mommify(String word) { for (char character : word.toCharArray()) { if (character == 'a' || character == 'e' || character == 'i' || character == 'o' || character == 'u'){ return "mommy"; } } return word; } }
SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; public String mommify(String word) { for (Character character : word.toCharArray()) { if (isAVowel(character)) { return REPLACEMENT_WORD; } } return word; } private boolean isAVowel(Character character) { return VOWELS.contains(character.toString()); } }
TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
TEST private Mommifier mommifier; @Before public void setUp() { mommifier = new Mommifier(); } @Test public void shouldNotMommifyEmptyString() { assertEquals("", mommifier.mommify("")); } @Test public void shouldNotMommifyWordsWithNoVowels() { assertEquals("str", mommifier.mommify("str")); } @Test public void shouldMommifyVowel() { assertEquals("mommy", mommifier.mommify("a")); }
TEST private Mommifier mommifier; @Before public void setUp() { mommifier = new Mommifier(); } @Test public void shouldNotMommifyEmptyString() { assertEquals("", mommifier.mommify("")); } @Test public void shouldNotMommifyWordsWithNoVowels() { assertEquals("str", mommifier.mommify("str")); } @Test public void shouldMommifyVowel() { assertEquals("mommy", mommifier.mommify("a")); }
TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; public String mommify(String word) { String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (isAVowel(character)) { mommifiedWord += REPLACEMENT_WORD; } else { mommifiedWord += character; } } return mommifiedWord; } private boolean isAVowel(Character character) { return VOWELS.contains(character.toString()); } }
TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
SOURCE ... private static final double THRESHOLD = 0.3; public String mommify(String word) { int vowelCount = 0; String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (isAVowel(character)) { mommifiedWord += REPLACEMENT_WORD; vowelCount++; } else { mommifiedWord += character; } } if((double)vowelCount/word.toCharArray().length < THRESHOLD){ return word; } return mommifiedWord; } ...
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
SOURCE public String mommify(String word) { if(vowelCountLessThanThreshold(word)){ return word; } return replaceVowels(word); } private boolean vowelCountLessThanThreshold(String word){...} private String replaceVowels(String word) {...} private boolean isAVowel(Character character) {...}
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
SOURCE ... public String mommify(String word) {...} private String replaceVowels(String word) { String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (!isVowel(character)) { mommifiedWord += character; } else if(!mommifiedWord.endsWith(REPLACEMENT_WORD)){ mommifiedWord += REPLACEMENT_WORD; } } return mommifiedWord; } private boolean vowelCountLessThanThreshold(String word){...} private boolean isVowel(Character character) {...} ...
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() { assertEquals("blmommyhmommy”, mommifier.mommify("blaha")); }
TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() { assertEquals("blmommyhmommy”, mommifier.mommify("blaha")); }
TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; private static final double THRESHOLD = 0.3; public String mommify(String word) {...} private String replaceVowels(String word) {...} private boolean vowelCountLessThanThreshold(String word){...} private boolean isVowel(Character character) { Character lowerCase = Character.toLowerCase(character); return VOWELS.contains(lowerCase.toString()); } }
TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
TEST @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() {...} @Test(expected = NullPointerException.class) public void shouldErrorOnNull() { mommifier.mommify(null); }
TEST @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() {...} @Test(expected = NullPointerException.class) public void shouldErrorOnNull() { mommifier.mommify(null); }
TEST CASES “” → “” “str” → “str” “a” → “mommy” “blah” → “blah” “bla” → “blmommy” “blaa” → “blmommy” “blaaha” → “blmommyhmommy” “blA” → “blmommy” Null → raise exception
TEST CASES public void shouldNotMommifyEmptyString public void shouldNotMommifyWordsWithNoVowels public void shouldMommifyVowel public void shouldMommifyConsonantsAndSingleVowel public void shouldNotMommifyLessThan30PercentVowels public void shouldMommifyContinuousVowelsOnlyOnce public void shouldMommifyMultipleSetsOfVowels public void shouldMommifyCapitalVowels public void shouldErrorOnNull
TOP DOWN TESTING
SOME USEFUL BOOKS
THANK YOU Gabriel Gavasso Anand Iyengar Thao Dang Hung Dang Mommifier Dojo by TWU team

More Related Content

PPT
Sviluppo percettivo-motorio
imartini
 
PDF
Tdd in android (mvp)
Prateek Jain
 
PDF
Android TDD
Chuck Greb
 
PPTX
TDD - Agile
harinderpisces
 
PDF
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...
Zohirul Alam Tiemoon
 
PPTX
Test-Driven Development (TDD)
Brian Rasmussen
 
PDF
Test Driven Development (TDD)
David Ehringer
 
PPT
TDD - Ketan Soni
Thoughtworks
 
Sviluppo percettivo-motorio
imartini
 
Tdd in android (mvp)
Prateek Jain
 
Android TDD
Chuck Greb
 
TDD - Agile
harinderpisces
 
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...
Zohirul Alam Tiemoon
 
Test-Driven Development (TDD)
Brian Rasmussen
 
Test Driven Development (TDD)
David Ehringer
 
TDD - Ketan Soni
Thoughtworks
 

Similar to TDD for the Win (20)

PDF
Tomasz Polanski - Automated mobile testing 2016 - Testing: why, when, how
Tomasz Polanski
 
PPTX
Navigating the xDD Alphabet Soup
Dror Helper
 
PPTX
Tomasz Polanski - Droidcon Berlin 2016
Tomasz Polanski
 
PPTX
JDD 2016 - Sebastian Malaca - You Dont Need Unit Tests
PROIDEA
 
PPS
Bdd: Tdd and beyond the infinite
Giordano Scalzo
 
PDF
tdd-2013-calpoly.pdf
Ted M. Young
 
PDF
Introduction to TDD (Test Driven development) - Ahmed Shreef
Ahmed Shreef
 
PPT
jUnit
sundar22in
 
PDF
Reloaded
Shunsaku Kudo
 
PDF
Confitura 2012 Bad Tests, Good Tests
Tomek Kaczanowski
 
PPT
05 junit
mha4
 
PDF
DOES NOT NEED TO BE ANSWERED UNTIL NOV 13thWords AssignmentRober.pdf
archanaemporium
 
PDF
Unit Testing Standards - Recommended Best Practices
Vitaliy Kulikov
 
PDF
Test string and array
Nabeel Ahmed
 
PDF
Testing Java Code Effectively - BaselOne17
Andres Almiray
 
PPTX
Dat testing - An introduction to Java and Android Testing
Saúl Díaz González
 
PDF
Operator Overloading In Scala
Joey Gibson
 
PDF
Improve your tests in the CI with STAMP, OW2con'19, June 12-13, 2019, Paris
OW2
 
PDF
Improve your tests in the CI with STAMP, OW2con'19, June 12-13, Paris.
OW2
 
PDF
GeeCON 2012 Bad Tests, Good Tests
Tomek Kaczanowski
 
Tomasz Polanski - Automated mobile testing 2016 - Testing: why, when, how
Tomasz Polanski
 
Navigating the xDD Alphabet Soup
Dror Helper
 
Tomasz Polanski - Droidcon Berlin 2016
Tomasz Polanski
 
JDD 2016 - Sebastian Malaca - You Dont Need Unit Tests
PROIDEA
 
Bdd: Tdd and beyond the infinite
Giordano Scalzo
 
tdd-2013-calpoly.pdf
Ted M. Young
 
Introduction to TDD (Test Driven development) - Ahmed Shreef
Ahmed Shreef
 
jUnit
sundar22in
 
Reloaded
Shunsaku Kudo
 
Confitura 2012 Bad Tests, Good Tests
Tomek Kaczanowski
 
05 junit
mha4
 
DOES NOT NEED TO BE ANSWERED UNTIL NOV 13thWords AssignmentRober.pdf
archanaemporium
 
Unit Testing Standards - Recommended Best Practices
Vitaliy Kulikov
 
Test string and array
Nabeel Ahmed
 
Testing Java Code Effectively - BaselOne17
Andres Almiray
 
Dat testing - An introduction to Java and Android Testing
Saúl Díaz González
 
Operator Overloading In Scala
Joey Gibson
 
Improve your tests in the CI with STAMP, OW2con'19, June 12-13, 2019, Paris
OW2
 
Improve your tests in the CI with STAMP, OW2con'19, June 12-13, Paris.
OW2
 
GeeCON 2012 Bad Tests, Good Tests
Tomek Kaczanowski
 
Ad

More from Thoughtworks (20)

PDF
Design System as a Product
Thoughtworks
 
PDF
Designers, Developers & Dogs
Thoughtworks
 
PDF
Cloud-first for fast innovation
Thoughtworks
 
PDF
More impact with flexible teams
Thoughtworks
 
PDF
Culture of Innovation
Thoughtworks
 
PDF
Dual-Track Agile
Thoughtworks
 
PDF
Developer Experience
Thoughtworks
 
PDF
When we design together
Thoughtworks
 
PDF
Hardware is hard(er)
Thoughtworks
 
PDF
Customer-centric innovation enabled by cloud
Thoughtworks
 
PDF
Amazon's Culture of Innovation
Thoughtworks
 
PDF
When in doubt, go live
Thoughtworks
 
PDF
Don't cross the Rubicon
Thoughtworks
 
PDF
Error handling
Thoughtworks
 
PDF
Your test coverage is a lie!
Thoughtworks
 
PDF
Docker container security
Thoughtworks
 
PDF
Redefining the unit
Thoughtworks
 
PPTX
Technology Radar Webinar UK - Vol. 22
Thoughtworks
 
PDF
A Tribute to Turing
Thoughtworks
 
PDF
Rsa maths worked out
Thoughtworks
 
Design System as a Product
Thoughtworks
 
Designers, Developers & Dogs
Thoughtworks
 
Cloud-first for fast innovation
Thoughtworks
 
More impact with flexible teams
Thoughtworks
 
Culture of Innovation
Thoughtworks
 
Dual-Track Agile
Thoughtworks
 
Developer Experience
Thoughtworks
 
When we design together
Thoughtworks
 
Hardware is hard(er)
Thoughtworks
 
Customer-centric innovation enabled by cloud
Thoughtworks
 
Amazon's Culture of Innovation
Thoughtworks
 
When in doubt, go live
Thoughtworks
 
Don't cross the Rubicon
Thoughtworks
 
Error handling
Thoughtworks
 
Your test coverage is a lie!
Thoughtworks
 
Docker container security
Thoughtworks
 
Redefining the unit
Thoughtworks
 
Technology Radar Webinar UK - Vol. 22
Thoughtworks
 
A Tribute to Turing
Thoughtworks
 
Rsa maths worked out
Thoughtworks
 
Ad

Recently uploaded (20)

PPTX
Tartificialntelligence_presentation.pptx
ry7r52mzb4
 
PDF
Univ-Connecticut-ChatGPT-Presentaion.pdf
ry7r52mzb4
 
PDF
Enhancing emotion recognition model for a student engagement use case through...
IAESIJAI
 
PDF
From MVP to Full-Scale Product A Startup’s Software Journey.pdf
KodekX
 
PDF
Getting Started with Data Integration: FME Form 101
Safe Software
 
PDF
Hybrid model detection and classification of lung cancer
IAESIJAI
 
PDF
Microsoft Solutions Partner Drive Digital Transformation with D365.pdf
Microsoft Dynamics
 
PDF
WOOl fibre morphology and structure.pdf for textiles
Rajendrakumar868651
 
PPTX
OMC Textile Division Presentation 2021.pptx
JahangirAlam816069
 
PPTX
Group 1 Presentation -Planning and Decision Making .pptx
MatthewLewis227954
 
PDF
Zenith AI: Advanced Artificial Intelligence
Biz Preneurs
 
PDF
Building Integrated photovoltaic BIPV_UPV.pdf
SandeepSingh286037
 
PDF
Mushroom cultivation and it's methods.pdf
mailmeonrishi
 
PDF
1 - Historical Antecedents, Social Consideration.pdf
tuazon2030627
 
PDF
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
PPTX
A Presentation on Artificial Intelligence
memembruh336
 
PDF
Encapsulation theory and applications.pdf
gurumoop
 
PDF
A comparative study of natural language inference in Swahili using monolingua...
IAESIJAI
 
PDF
ENT215_Completing-a-large-scale-migration-and-modernization-with-AWS.pdf
ssuser28425f
 
PDF
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 
Tartificialntelligence_presentation.pptx
ry7r52mzb4
 
Univ-Connecticut-ChatGPT-Presentaion.pdf
ry7r52mzb4
 
Enhancing emotion recognition model for a student engagement use case through...
IAESIJAI
 
From MVP to Full-Scale Product A Startup’s Software Journey.pdf
KodekX
 
Getting Started with Data Integration: FME Form 101
Safe Software
 
Hybrid model detection and classification of lung cancer
IAESIJAI
 
Microsoft Solutions Partner Drive Digital Transformation with D365.pdf
Microsoft Dynamics
 
WOOl fibre morphology and structure.pdf for textiles
Rajendrakumar868651
 
OMC Textile Division Presentation 2021.pptx
JahangirAlam816069
 
Group 1 Presentation -Planning and Decision Making .pptx
MatthewLewis227954
 
Zenith AI: Advanced Artificial Intelligence
Biz Preneurs
 
Building Integrated photovoltaic BIPV_UPV.pdf
SandeepSingh286037
 
Mushroom cultivation and it's methods.pdf
mailmeonrishi
 
1 - Historical Antecedents, Social Consideration.pdf
tuazon2030627
 
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
A Presentation on Artificial Intelligence
memembruh336
 
Encapsulation theory and applications.pdf
gurumoop
 
A comparative study of natural language inference in Swahili using monolingua...
IAESIJAI
 
ENT215_Completing-a-large-scale-migration-and-modernization-with-AWS.pdf
ssuser28425f
 
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 

TDD for the Win

  • 1. TDD FOR THE WIN Basics to Test Driven Development May 2014 Minh Ngoc Dang
  • 2. Senior Developer at ThoughtWorks ThoughtWorks University Trainer Minh Ngoc Dang
  • 4. WHY TESTING? Lots of reasons! Here are a select few Verify functionality of application Catch bugs and prevent them from coming back Serve as documentation for maintainability purposes
  • 5. BUT WHAT ABOUT…? ? How do we make sure we have full test coverage? ? How can we be confident all cases are covered? ? How can we prevent bugs from happening?
  • 10. TEST DRIVING MEANS Writing tests before writing code Write the minimum amount of code necessary to make tests pass Rinse and repeat
  • 12. WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
  • 14. TEST COVERAGE Tests written before code Ensure all code covered by tests
  • 15. TEST COVERAGE Tests written before code Ensure all code covered by tests High test coverage
  • 16. WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
  • 17. TEST CASES Test cases reflect exactly what code does
  • 18. TEST CASES Test cases reflect exactly what code does Visible list of functionality
  • 19. TEST CASES Test cases reflect exactly what code does Visible list of functionality Easy to see which cases are missing
  • 20. WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
  • 21. BUG PREVENTION Mental shift in thinking up test case before code
  • 22. BUG PREVENTION Mental shift in thinking up test case before code Encourage edge case testing
  • 23. BUG PREVENTION Mental shift in thinking up test case before code Encourage edge case testing Help prevent bugs in edge cases
  • 24. WHY TDD? Back to previously posed questions Test Coverage? Cases Covered? Bug Prevention?
  • 26. TIME SAVER Ease in debugging Confidence in refactoring
  • 27. DRIVING DESIGN Help define usage – How should the code be used? Only write necessary code – YAGNI!
  • 28. SO HOW CAN I TDD?
  • 29. RED – GREEN - REFACTOR New Test New Test New Test Red GreenRefactor Red GreenRefactor Red GreenRefactor
  • 30. EXAMPLE You are given strings of different lengths. If the number of vowels are more than 30% of the string length then insert ‘mommy’ for each continuous set of vowels.  his → hmommys  hear → hmommyr ✗ hear → hmommymommyr
  • 31. TEST CASES “” → “” // empty string “str” → “str” // no vowels “a” → “mommy” // single vowel “blah” → “blah” // < 30% length “bla” → “blmommy” // > 30% length “blaa” → “blmommy” // continuous vowels “blaaha” → “blmommyhmommy” // multi sets of vowels “blA” → “blmommy” // capital letters Null → raise exception // null checks
  • 32. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
  • 33. SOURCE public class Mommifier { public String mommify(String word) { return null; } }
  • 34. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
  • 35. SOURCE public class Mommifier { public String mommify(String word) { return ""; } }
  • 36. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() { String word = ""; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("", mommifiedWord); } }
  • 37. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
  • 38. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
  • 39. SOURCE public class Mommifier { public String mommify(String word) { return word; } }
  • 40. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() { String word = "str"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("str", mommifiedWord); } }
  • 41. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
  • 42. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
  • 43. SOURCE public class Mommifier { public String mommify(String word) { for (char character : word.toCharArray()) { if (character == 'a' || character == 'e' || character == 'i' || character == 'o' || character == 'u'){ return "mommy"; } } return word; } }
  • 44. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
  • 45. SOURCE public class Mommifier { public String mommify(String word) { for (char character : word.toCharArray()) { if (character == 'a' || character == 'e' || character == 'i' || character == 'o' || character == 'u'){ return "mommy"; } } return word; } }
  • 46. SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; public String mommify(String word) { for (Character character : word.toCharArray()) { if (isAVowel(character)) { return REPLACEMENT_WORD; } } return word; } private boolean isAVowel(Character character) { return VOWELS.contains(character.toString()); } }
  • 47. TEST import org.junit.Test; import static org.junit.Assert.assertEquals; public class MommifierTest { @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() { String word = "a"; Mommifier mommifier = new Mommifier(); String mommifiedWord = mommifier.mommify(word); assertEquals("mommy", mommifiedWord); } }
  • 48. TEST private Mommifier mommifier; @Before public void setUp() { mommifier = new Mommifier(); } @Test public void shouldNotMommifyEmptyString() { assertEquals("", mommifier.mommify("")); } @Test public void shouldNotMommifyWordsWithNoVowels() { assertEquals("str", mommifier.mommify("str")); } @Test public void shouldMommifyVowel() { assertEquals("mommy", mommifier.mommify("a")); }
  • 49. TEST private Mommifier mommifier; @Before public void setUp() { mommifier = new Mommifier(); } @Test public void shouldNotMommifyEmptyString() { assertEquals("", mommifier.mommify("")); } @Test public void shouldNotMommifyWordsWithNoVowels() { assertEquals("str", mommifier.mommify("str")); } @Test public void shouldMommifyVowel() { assertEquals("mommy", mommifier.mommify("a")); }
  • 50. TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
  • 51. TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
  • 52. SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; public String mommify(String word) { String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (isAVowel(character)) { mommifiedWord += REPLACEMENT_WORD; } else { mommifiedWord += character; } } return mommifiedWord; } private boolean isAVowel(Character character) { return VOWELS.contains(character.toString()); } }
  • 53. TEST import ...; public class MommifierTest { private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() { assertEquals("blmommy", mommifier.mommify("bla")); } }
  • 54. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
  • 55. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
  • 56. SOURCE ... private static final double THRESHOLD = 0.3; public String mommify(String word) { int vowelCount = 0; String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (isAVowel(character)) { mommifiedWord += REPLACEMENT_WORD; vowelCount++; } else { mommifiedWord += character; } } if((double)vowelCount/word.toCharArray().length < THRESHOLD){ return word; } return mommifiedWord; } ...
  • 57. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
  • 58. SOURCE public String mommify(String word) { if(vowelCountLessThanThreshold(word)){ return word; } return replaceVowels(word); } private boolean vowelCountLessThanThreshold(String word){...} private String replaceVowels(String word) {...} private boolean isAVowel(Character character) {...}
  • 59. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() { assertEquals("blah", mommifier.mommify("blah")); }
  • 60. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
  • 61. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
  • 62. SOURCE ... public String mommify(String word) {...} private String replaceVowels(String word) { String mommifiedWord = ""; for (Character character : word.toCharArray()) { if (!isVowel(character)) { mommifiedWord += character; } else if(!mommifiedWord.endsWith(REPLACEMENT_WORD)){ mommifiedWord += REPLACEMENT_WORD; } } return mommifiedWord; } private boolean vowelCountLessThanThreshold(String word){...} private boolean isVowel(Character character) {...} ...
  • 63. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() { assertEquals("blmommyh”, mommifier.mommify("blaah")); }
  • 64. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() { assertEquals("blmommyhmommy”, mommifier.mommify("blaha")); }
  • 65. TEST private Mommifier mommifier; @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() { assertEquals("blmommyhmommy”, mommifier.mommify("blaha")); }
  • 66. TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
  • 67. TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
  • 68. SOURCE public class Mommifier { private static final String VOWELS = "aeiou"; private static final String REPLACEMENT_WORD = "mommy"; private static final double THRESHOLD = 0.3; public String mommify(String word) {...} private String replaceVowels(String word) {...} private boolean vowelCountLessThanThreshold(String word){...} private boolean isVowel(Character character) { Character lowerCase = Character.toLowerCase(character); return VOWELS.contains(lowerCase.toString()); } }
  • 69. TEST @Before public void setUp() {...} @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() { assertEquals("BLmommy", mommifier.mommify("BLA")); }
  • 70. TEST @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() {...} @Test(expected = NullPointerException.class) public void shouldErrorOnNull() { mommifier.mommify(null); }
  • 71. TEST @Test public void shouldNotMommifyEmptyString() {...} @Test public void shouldNotMommifyWordsWithNoVowels() {...} @Test public void shouldMommifyVowel() {...} @Test public void shouldMommifyConsonantsAndSingleVowel() {...} @Test public void shouldNotMommifyLessThan30PercentVowels() {...} @Test public void shouldMommifyContinuousVowelsOnlyOnce() {...} @Test public void shouldMommifyMultipleSetsOfVowels() {...} @Test public void shouldMommifyCapitalVowels() {...} @Test(expected = NullPointerException.class) public void shouldErrorOnNull() { mommifier.mommify(null); }
  • 72. TEST CASES “” → “” “str” → “str” “a” → “mommy” “blah” → “blah” “bla” → “blmommy” “blaa” → “blmommy” “blaaha” → “blmommyhmommy” “blA” → “blmommy” Null → raise exception
  • 73. TEST CASES public void shouldNotMommifyEmptyString public void shouldNotMommifyWordsWithNoVowels public void shouldMommifyVowel public void shouldMommifyConsonantsAndSingleVowel public void shouldNotMommifyLessThan30PercentVowels public void shouldMommifyContinuousVowelsOnlyOnce public void shouldMommifyMultipleSetsOfVowels public void shouldMommifyCapitalVowels public void shouldErrorOnNull
  • 76. THANK YOU Gabriel Gavasso Anand Iyengar Thao Dang Hung Dang Mommifier Dojo by TWU team

Editor's Notes

  • #2: This talk will be mainly about what benefits Test Driven Development brings and includes a practical example.
  • #4: Before we start on TDD, let’s quickly look at testing
  • #5: Why do we test? For a number of reasons! Testing allows us to verify the behaviour of software and ensures these are not changed unintentionally. It allows us to track bugs. Call out the possible ones and having a test in place prevents it from coming back. It also serves as documentation for the current state of the software.
  • #6: But if we add tests after we have completed a functionality… How do we make sure we have full test coverage? How can we be confident all cases are covered? How can we prevent bugs from happening in the first place?
  • #7: This is where TDD comes in!
  • #8: … or Test Driven Development!
  • #9: But wait…
  • #10: … what exactly does TDD even mean?
  • #11: Test driving means… We write the tests before implementing the code. And then we write the minimum amount of code possible to make this single test pass – baby steps. Then we write another test and the process repeats.
  • #12: But why test first?
  • #13: Let’s go back to the questions we asked previously for writing tests after: How can we be more confident about: Test coverage Test cases covered Preventing bugs
  • #14: Tests written before implementing code
  • #15: Means that all the code you write should be covered by a test. Writing minimum amount of code to make tests pass means that you won’t have untested code.
  • #16: This will result in higher test coverage
  • #17: So yay. What about test cases?
  • #18: Writing tests first and having high code coverage means the tests reflect exactly what the code does.
  • #19: Having a very visible list of the current functionality of the software…
  • #20: …allows you to see which cases are tested and which are missing
  • #21: Finally bug prevention
  • #22: TDD creates a mental shift in having more focus on test cases
  • #23: When we can see all currently tested cases and try and think about which cases are missing it encourages people to think about the edge cases where the software is likely to fail
  • #24: And what we expect to happen in these cases.
  • #25: TDD helps address all these questions…
  • #26: But that’s not all
  • #27: Having a high level of test coverage means that it is much easier to debug. Just need to go to the test case you want and debug that. This also ensures that we are not breaking functionality when refactoring. Allowing people to be more confident to make bolder and more risky refactorings.
  • #28: TDD also helps drive out the design of the software. When you write tests first, you think about the usage of the code before writing it, making it more usable. Writing only a minimum necessary amount of code means there are no unnecessary functionality that needs support. You ain’t gonna need it!
  • #29: Now that we’ve been through why.. Let’s talk about the how
  • #30: Red – Green – Refactor. Write the test, see your code fail for the right reasons to make sure you’re testing the right thing (red) Make the test pass (green) Only refactor while the tests are green Write a new test and repeat the process
  • #31: Let’s go through a coding example of TDD
  • #32: Thinking up different possible test cases
  • #33: Let’s start with a test. Since the implementation does not exist, it will not compile.
  • #34: Make the code compile
  • #35: Now the test fails for the right reason
  • #36: Minimum step necessary to make it pass.
  • #37: And it passes
  • #38: Now we need another test case to force us to add more functionality to the code
  • #39: It fails for the right reason
  • #40: Again minimum amount of code to make it pass – remembering to keep the old tests passing too.
  • #41: And they pass
  • #42: Adding actual replacement of vowels.
  • #43: It fails for the right reason
  • #44: And the logic for vowel replacement is added
  • #45: Tests all pass
  • #46: Now that tests pass we can go ahead and refactor
  • #47: Notice the logic has changed. It’s a step for us to improve our design.
  • #48: Tests still pass
  • #49: Since tests are also code we can refactor this too
  • #50: And they still pass
  • #51: Adding new tests for actual replace mixed vowels and consonants
  • #52: It fails for the right reason
  • #53: And we modify the code to make it pass.
  • #54: And all tests including old ones still work
  • #55: Now for the logic of not replacing vowels if it’s less than 30%
  • #56: It fails for the right reason
  • #57: we modify the code to make the tests pass
  • #58: It does
  • #59: We can then go and refactor the code to make it more readable and maintainable
  • #60: Making sure our tests still pass
  • #61: Continuous vowels
  • #62: Fails for the right reason
  • #63: Adding logic
  • #64: Tests pass
  • #65: How about multiple sets of vowels in a word?
  • #66: It passes since our code already works with this scenario. Sometimes people like to change the code to see it fail just to make sure it’s passing for the right reason and not because of some coincidence.
  • #67: How about capital letters?
  • #68: It fails.
  • #69: Again making it pass
  • #70: And it does
  • #71: Null checks?
  • #72: It already passes because runtime exceptions.
  • #73: And we’re done! Let’s look at all the test cases we came up before.
  • #74: The tests now serve as documentations of these functionality.
  • #75: In terms of writing different types of tests, I personally prefer to Test Drive from ‘Top down” This means starting out writing higher level tests such as functional tests or integration tests and then using this to drive out your unit tests. And having your unit tests then drive out the implementation.
  • #76: Here are some books if you’re interested in reading more about TDD: Test Driven Development by example by Kent Beck Refactoring by Martin Fowler
  • #77: Special thanks – any questions?