Unit Testing, TDD and ATDD

© Arnon Axelrod, E4D Solutions Ltd.

UNIT TESTING, TDD & ATDD

Arnon Axelrod, E4D Solutions



About me

Arnon Axelrod

TDD and Agile Quality ExpertE4D Solutions



About you

• Position: Dev, Test, Product, Management, other?

• TDD/Unit testing experience



Why Learn TDD Today?

Adoption (% of martket)

time

Today

ATDD

TDD

Agile

Object-Oriented



TDD?!

Photo by: Stuart Miles



Learning TDD is like learning to ride a bicycle


Quality

Testing

Unit Tests

TDD

ATDD


Quality throughout the project lifecycle

What is quality? Why it is important?

Quality



Quality

No bugs

Stability

TestingDesign

Happy, Loyal customersUser eXperience

Clean code

Maintainability

Customer feedback



The Productivity Misconception

Productivity

Features

Happy customers

MaintainabilityPressure

Legend:Positive relationship

Negative relationship

Increased

Decreased

Productivity

Features

Happy customers

Stability

Clean code

Testing



The Productivity Misconception

Productivity

Features

Happy customers

MaintainabilityPressure

Legend:Positive relationship

Negative relationship

Increased

Decreased

Stability

Clean code

Testing


Quality

Testing

Unit Tests

TDD

ATDD


TestingTesting



Types of Tests

ExploratoryPlanned

ManualAutomated

White box Black box



Types of Tests

End-to-End

UIView ModelClient Logic

Server Proxy

Service LayerBusiness Logic

DAL

ORM

DB



Types of TestsUI

View ModelClient Logic

Server Proxy


DAL

ORM

DB

Usability, UX



Types of TestsUI


Server Proxy


DAL

ORM

DB

Integration



Types of TestsUI


Server Proxy


DAL

ORM

DB

Functional

Mock

Mock

Mock



Types of TestsUI


Server Proxy

Service Layer

DAL

ORM

DB

Unit tests

Business Logic



Types of tests

• Other:

– Performance

– Load (scalability)

– Install (deployment)

– Monkey testing


Quality

Testing

Unit Tests

TDD

ATDD


Unit tests basicsUnit Tests



What’s a unit test?

• What’s a unit?

– Smallest testable functionality

– any testable functionality (BDD)

• Automatic

• Gray box



Benefits of Unit Tests

• Fast

• Easy to write and maintain

• Code coverage

• When fail, provide insight into the problem



Unit tests should:• Be Isolated– Re-runnable

• No side effects• Cleanup

– Environment agnostic– Order doesn’t matter

• Verify functionality, not implementation

• Be straight-forward– No conditionals, loops etc

Photo by: tongdang



Unit tests should:

• Read like a story

• Verify only one thing

• Have meaningful names

• Be fast!



Inventory class+int GetAvailablePieces (Item item)

+void Reduce(Item item, int count)

- DbConnectionProvider

Doubles (mocks)

Order class+Items

+bool CheckAvailability (IInventory inventory)

+void Supply (IInventory inventory)



Doubles (mocks)

Order class+Items

+bool CheckAvailability (IInventory inventory)

+void Supply (IInventory inventory)

IInventory interface+int GetAvailablePieces (Item item)


InventoryDouble+int GetAvailablePieces (Item item)


Inventory class+int GetAvailablePieces (Item item)


- DbConnectionProvider



Doubles...

Double

Fake

Dummy MockStub

Detour



Unit test structureArrange

Act

Assert

Given

When

Then



Test suiteSuite Initialize

Test Initialize

Test Method 1

Test Cleanup

Suite Cleanup

Test Method 2 Test Method 3


Quality

Testing

Unit Tests

TDD

ATDD


TDD

TDD



What TDD is all about?

Testing?!

Design!



Why it is important to test First?• Looking at the problem space

– vs. the solution (implementation) space

• Building decoupled code from base

• Psychological effect

• Testing the test first!



Testing the Test First!

• What are the inputs?• What are the outputs?

[TestMethod]public void TestFibonacciFunction(){ // arrange ... // Act: var result = Fibonacci(...); // Assert: Assert ...}

The test we want to test



Testing the Test First!public bool TestFibonacciFunction(Func<…> fibonacci){ // arrange ... // Act: var result = fibonacci(...); // Assert: return ...}

The test we want to test

public void TestTheTest(){ var invalidImpl = … var goodImpl = Fibonacci; Assert.IsFalse(TestFibonacciFunction(invalidImpl)); Assert.IsTrue(TestFibonacciFunction(goodImpl));}

Testing the test



The way TDD works:

Write a failing test

Write the code to

make this test pass

Refactor



Write a test

New Test

Old Tests

Write production

codeAll

Tests

Refactor

All Tests



TDD and Refactoring

Photo by: Chaiwat



TDD and Refactoringpublic class SomeClass { public SomeClass() { //... } public void Foo(int someParam) { // use someParam... }}

Initial state



TDD and Refactoringpublic class SomeClass { private int _someParam; public SomeClass(int someParam) { //... _someParam = someParam; } public void Foo() { // use _someParam... }}

Final (desired) state



TDD and Refactoringpublic class SomeClass { public SomeClass() { //... } public void Foo(int someParam) { // use someParam... }}

Initial state



TDD and Refactoringpublic class SomeClass{ public SomeClass() { //... } private int _someParam; public SomeClass(int someParam) : this() { _someParam = someParam; } public void Foo(int someParam) { //use someParam... }}

Step1 – Add constructor

overload



TDD and Refactoringpublic class SomeClass{ private int _someParam; public SomeClass(int someParam) { //... _someParam = someParam; } public void Foo(int someParam) { //use someParam... }}

Step2 – Remove old constructor

overload



TDD and Refactoringpublic class SomeClass{ private int _someParam; public SomeClass(int someParam) { //... _someParam = someParam; } public void Foo(int someParam) { //use someParam... } public void Foo() { //use _someParam... }}

Step3 – Add new overload of

Foo



TDD and Refactoringpublic class SomeClass{ private int _someParam; public SomeClass(int someParam) { //... _someParam = someParam; } public void Foo() { //use _someParam... }}

Step4 (final) – Remove old

overload of Foo



TDD and Legacy Code


TDD and Legacy Code

Legacy code TDD (loosely-coupled)



Limits of TDD• UI

• Multi-threading

• Integration with peripheral systems, including:– Hardware (I/O)– Operating System– Database– 3rd party applications and components


Quality

Testing

Unit Tests

TDD

ATDD


ATDD

ATDD



ATDD



ATDD

Stands for:

Accepance-Test Driven Development



ATDD

TDD is about writing the CODE RIGHT

ATDD is about writing the RIGHT CODE



ATDD

ATDD is about Communication

Mainly between Product, Dev and Test



ATDD is AKA:

• Agile Acceptance Testing• Specification by Example• Example Driven Development• Executable Specifications• ~= BDD (Behavior Driven Development)



Problems with Waterfall Specification

Photo by: Michal Marcol



Problems with Agile Specification



How ATDD works?

Specification by

ExamplesScenarios Acceptance

tests


Quality

Testing

Unit Tests

TDD

ATDD


FitNesse Demo

ATDD



Benefits of ATDD for the Business Analyst• Developers will actually read the specifications that you write• You will be sure that developers and testers understand the

specifications correctly• You will be sure that they do not skip parts of the specification• You can track development progress easily• You can easily identify conflicts in business rules and

requirements caused by later change requests• You’ll save time on acceptance and smoke testing

Source: Gojko Adzic – Bridging the Communication Gap



Benefits of ATDD for the Developer

• Most functional gaps and inconsistencies in the requirements and specifications will be flushed out before the development starts

• You will be sure that business analysts actually understand special cases that you want to discuss with them




Benefits of ATDD for the Developer

• You will have automated tests as targets to help you focus the development.

• It will be easier to share, hand over and take over code

• You’ll have a safety net for refactoring, making your code cleaner [Arnon A.]




Benefits of ATDD for the Tester• You can influence the development process and stop

developers from making the same mistakes over and over• You will have a much better understanding of the domain• You’ll delegate a lot of dull work to developers, who will

collaborate with you on automating the verifications




Benefits of ATDD for the Tester• You can build in quality from the start by raising concerns

about possible problems before the development starts• You’ll be able to verify business rules with a touch of a button• You will be able to build better relationships with developers

and business people and get their respect• You’ll spend less time doing dull work, and more time

exploring “real” bugs and testing non-functional aspects (e.g. performance, usability, etc). [Arnon A.]



Quality

Testing

Unit Tests

TDD

ATDD


Questions?


Quality

Testing

Unit Tests

TDD

ATDD


Thank you!

Software

Unit Testing, TDD and ATDD