Unit Testing, TDD and ATDD

©ArnonAxelrod,E4DSolutionsLtd.
UNIT TESTING, TDD
& ATDD
Arnon Axelrod, E4D Solutions

©ArnonAxelrod,E4DSolutionsLtd.©ArnonAxelrod,E4DSolutionsLtd.
About me

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
Testing
Design
Happy, Loyal customers
User 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
Testing
Testing

Types of Tests
Exploratory
Planned
Manual
Automated
White box Black box

Types of Tests
End-to-End
UI
View Model
Client Logic
Server Proxy
Service Layer
Business Logic
DAL
ORM
DB

Types of Tests
UI
View Model
Client Logic
Server Proxy
Service Layer
Business Logic
DAL
ORM
DB
Usability, UX

Types of Tests
UI
View Model
Client Logic
Server Proxy
Service Layer
Business Logic
DAL
ORM
DB
Integration

Types of Tests
UI
View Model
Client Logic
Server Proxy
Service Layer
Business Logic
DAL
ORM
DB
Functional
Mock
Mock
Mock

Types of Tests
UI
View Model
Client Logic
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 basics
Unit
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
InventoryDouble
Inventory class
- DbConnectionProvider

Doubles...
Double
Fake
Dummy MockStub
Detour

Unit test structure
Arrange Act Assert
Given When Then

Test suite
Suite 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
code
All
Tests
Refactor
All
Tests

TDD and Refactoring
Photo by: Chaiwat

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

TDD and Refactoring
{
private int _someParam;
public SomeClass(int someParam)
{
//...
_someParam = someParam;
}
public void Foo()
{
// use _someParam...
}
}
Final (desired)
state

TDD and Refactoring
{
public SomeClass()
{
//...
}
public SomeClass(int someParam) : this()
{
}
{
//use someParam...
}
}
Step1 – Add
constructor
overload

TDD and Refactoring
{
{
//...
}
{
//use someParam...
}
}
Step2 –
Remove old
constructor
overload

TDD and Refactoring
{
{
//...
}
{
//use someParam...
}
public void Foo()
{
//use _someParam...
}
}
Step3 – Add
new overload of
Foo

TDD and Refactoring
{
{
//...
}
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 Examples
Scenarios
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!

Unit Testing, TDD and ATDD

More Related Content

What's hot

Viewers also liked

Similar to Unit Testing, TDD and ATDD

More from Arnon Axelrod

Recently uploaded

Unit Testing, TDD and ATDD

Editor's Notes