Learn Test Driven Development in Java

Test Driven Development
in Java

Wednesday, 14 November 12

About me!

Matthew Todd matthew.todd@ﬂuentsoftware.co.uk
@matthew_todd

Working with developers,
continuously improving agile practice


What is TDD?


Testing timeline

1994: Kent Beck creates SUnit test framework
1999: Extreme programming explained published

1989: First tests on punchcards 1995: TDD Demo 2000: JUnit.org launched


Manifesto for Agile Software Development
We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:
Individuals and interactions over processes and tool s

Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan
That is, while there is value in the items on
the right, we value the items on the left more


Test spectrum Full system test
Automated integration/acceptance

Testing in concert

Component test

Unit test

Single function test


1. Write test


1. Write test

2. Test fails!


1. Write test

2. Test fails!

3. Write code


1. Write test

2. Test fails!

3. Write code

4. Test passes!


1. Write test

2. Test fails!

3. Write code

4. Test passes!

5. Refactor


Why TDD?


Proactive VS Reactive

Seek out problems early on Test late

Validate requirements Only respond to defects

Validate code Focused on debugging


Relative cost of change

Cost

Unit test Live system

Time


Requirements
Drive out requirements issues early


Rapid feedback
Many small changes VS One Big Change™


Collaboration
Enables developers to work together


Values refactoring
Refactor often to lower impact and risk


Design to test
Testing driving good design practice


Tests as information
Documenting decisions and assumptions


Sounds great!
So show me


So, let’s get started


Reverse polish calculator
34+


Calculator walkthrough


Reverse polish calculator
Developed 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

Dependency

Test target x
Test double
Test


Test Doubles
Stubs Fakes Mocks


Stubs
Providing state-based veriﬁcation


Fakes
Providing simpliﬁed replacements


Mocks
Providing behaviour based veriﬁcation


Stubs Assertions made
Fakes directly in test method

Mocks Assertions made by
mock object


Test double demonstration


Mock frameworks


app ropr iate
ks w here
amewor
r mock fr
Conside Test balance


Dealing with the legacy


Code we cannot change
Dealing with the legacy
Someone else’s code? No interfaces?


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 boundaries
Class(es) under test Out of test scope


Anti-pattern: exceptional test
@Test
public void testUserCreation() {
userService.createUser("bob");
}


Anti-pattern: exceptional test
@Test
public void testUserCreation() {
}

Good coverage,
but poor validation


Anti-pattern: usually passes
com.example.UncertainTest






Anti-pattern: usually passes

Control threading and access
to resources

We need to be able to trust our tests


Anti-pattern: one big test
@Test
public void testEverything() {
userService.createUser("alice");
assertEquals(1,userService.getUserCount());
userService.createUser("alice");
userService.dropUser("alice");
User bob = userService.getUser("bob");
assertNotNull(bob);
...


Anti-pattern: one big test

testUserCreation

testEverything 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!


Continuous delivery

Integration testing
BDD

TDD
Design Manual testing
User stories


Practice practice practice


TDD Kata


TDD Kata roman numerals
1 - 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 Fizz
multiples of 5 should print Buzz
multiples of 3 and 5 print FizzBuzz

1 2 Fizz 4 Buzz Fizz 7 ...


TDD Kata roman calculator
calculator only accepting roman numerals as
input and output
I + III = IV


TDD Kata tennis
implement simple tennis game
http://en.wikipedia.org/wiki/Tennis#Scoring


Thank you!


Learn Test Driven Development in Java

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (6)

Último

Último (20)

Learn Test Driven Development in Java