learn test driven development in java

Test Driven Developmentin Java

Wednesday, 14 November 12

About me!

Matthew Todd [email protected]

@matthew_todd

Working with developers, continuously improving agile practice


mailto:[email protected]

mailto:[email protected]

What is TDD?


Testing timeline

1989: First tests on punchcards

1994: Kent Beck creates SUnit test framework

1995: TDD Demo

1999: Extreme programming explained published

2000: JUnit.org launched


Manifesto for Agile Software DevelopmentWe are uncovering better ways of developingsoftware by doing it and helping others do it.Through this work we have come to value:

Individuals and interactions over processes and tools

Working software over comprehensive documentationCustomer collaboration over contract negotiation

Responding to change over following a planThat is, while there is value in the items on

the right, we value the items on the left more


Test spectrum

Single function test

Full system test

Automated integration/acceptance

Unit test

Testing in concert

Component test


1. Write test


2. Test fails!

1. Write test


2. Test fails!

1. Write test

3. Write code


2. Test fails!

1. Write test

3. Write code

4. Test passes!


2. Test fails!

1. Write test

3. Write code

4. Test passes!

5. Refactor


Why TDD?


Proactive VS Reactive

Seek out problems early on

Validate requirements

Validate code

Test late

Only respond to defects

Focused on debugging


Unit test Live system

Time

Cost

Relative cost of change


RequirementsDrive out requirements issues early


Rapid feedbackMany small changes VS One Big Change™


CollaborationEnables developers to work together


Values refactoringRefactor often to lower impact and risk


Design to testTesting driving good design practice


Tests as informationDocumenting decisions and assumptions


Sounds great!So show me


So, let’s get started


Reverse polish calculator3 4 +


Calculator walkthrough


Reverse polish calculatorDeveloped using a test driven approach


“sounds simple, but what about real applications?”


SOLID


Single responsibilityOLID


SOpen/ClosedLID


SOLiskov SubstitutionID


SOLInterface segregationD


SOLIDependency inversion


Isolating dependencies

Test target

Dependency

Test double

x

Test


Test DoublesFakes MocksStubs


Providing state-based verificationStubs


FakesProviding simplified replacements


MocksProviding behaviour based verification


Stubs Assertions made directly in test methodFakes

Mocks Assertions made by mock object


Test double demonstration


Mock frameworks


Test balanceConsider mock frameworks where appropriate


Dealing with the legacy


Dealing with the legacySomeone else’s code? No interfaces?

Code we cannot change


So, now we can test it!


So, now we can test it!What makes a good test?


Test principles


FIRST


FastIRST


FIndependentRST


FIRepeatableST


FIRSelf-validatingT


FIRSTimely


TDD Anti-patterns


Anti-pattern: the singleton


Anti-pattern: the singleton

Who uses this singleton?

Who owns this singleton?

What behaviours does it provide?


Anti-pattern: create the world

@Before public void initialiseTests() { loadBalancer = createMockLoadBalancingService(); server1 = createMockServer(); server2 = createMockServer(); loadBalancer.addServer(server1); loadBalancer.addServer(server2); dbEngine = new DBEngine(); dbEngine.addTable("users"); dbEngine.addTable("profiles"); dbEngine.addTable("posts"); userProfileService = new Mock<UserProfileServer>(); adminUser = new User("admin",true); user1 = new User("alice",false); user2 = new User("bob",false); userProfileService.register(user1); userProfileService.register(user2); user1.connectWith(user2); ...


Anti-pattern: create the world

Test burden increases over time

Test complexity increases

Often a sign of application complexity


Anti-pattern: completely mocked

@Test public void testingNothing() { MockServiceFactory factory = new MockServiceFactory(); Mock<UserService> userService = new Mock<UserService>(); factory.add(userService); User user = new User("bob"); userService.add(user); assertEquals("bob",userService.getUsers()[0].name()); }


Test boundariesClass(es) under test Out of test scope


Anti-pattern: exceptional test

@Test public void testUserCreation() { userService.createUser("bob"); }


Anti-pattern: exceptional test

Good coverage, but poor validation

@Test public void testUserCreation() { userService.createUser("bob"); }


Anti-pattern: usually passes

com.example.UncertainTest






Anti-pattern: usually passes

We need to be able to trust our tests

Control threading and access to resources


Anti-pattern: one big test

@Test public void testEverything() { userService.createUser("alice"); assertEquals(1,userService.getUserCount()); userService.createUser("alice"); assertEquals(1,userService.getUserCount()); userService.createUser("bob"); assertEquals(2,userService.getUserCount()); userService.dropUser("alice"); assertEquals(1,userService.getUserCount()); User bob = userService.getUser("bob"); assertNotNull(bob); ...


Anti-pattern: one big test

testEverything

testUserCreation

testCreatingDuplicateUser

testDroppingUser


Anti-pattern: the slow test


Anti-pattern: the slow test

Should be quick to pass

Should be quick to fail

Run frequently


Anti-pattern: second-class test

@Test public void whoKnowsWhatThisTests() { createTestObjects(); testUser.setName("alice"); setupTestDependencies(); User user2 = new User("user2"); setupUser(user2); testManager.add(testUser); ... test(user2); }


Applying TDD


When not to use TDD!


TDD

BDDIntegration testing

Design

Continuous delivery

Manual testing

User stories


Practice practice practice


TDD Kata


TDD Kata roman numerals1 - convert text from normal numerals ->

Roman numerals

2 - convert in the other direction too


TDD Kata FizzBuzz

printing numbers from 1 to 100

..but multiples of 3 should print Fizzmultiples of 5 should print Buzzmultiples of 3 and 5 print FizzBuzz

1 2 Fizz 4 Buzz Fizz 7 ...


TDD Kata roman calculatorcalculator only accepting roman numerals as

input and output

I + III = IV


TDD Kata tennisimplement simple tennis game

http://en.wikipedia.org/wiki/Tennis#Scoring


Thank you!


learn test driven development in java

Technology

test passes

test spectrum

test driven development

test driven approachwednesday

sunit test framework1999

real applications

agile software development

agile practicewednesday