Mock Objects from Concept to Code

Mock Objects:
From Concept to Code
Rob Myers
for
Agile Development Practices
East
07 Nov 2012

7 November 2012 © Agile Institute 2012 1

difficult to set up

A database.
A complex object graph.

Stock
Fund
Account Stock
Stock
Investor
Stock

Account Fund Stock

Stock


expensive to test against*

The production database.
Your personal credit card.
A “password changed” confirmation
sent to the CEO of a large
investment firm.

* Each of these “Career-Limiting Moves” was actually witnessed by me
during the “dot-COM” era.


chaotic

The database.
A randomizer.
The weather.


…slow…

The database.
The network.
The filesystem.
Interplanetary radio signals?!


Fast!
Reliable!


from Martin Fowler et al

• Fakes provide reasonable facsimiles of the real
thing, but are not quite robust enough for
production (e.g., an in-memory database).

• Stubs provide scripted responses to calls. They
may also record information about calls made
during the test.

• Mocks are programmed by tests, creating
expectations for potentially the entire
specification of a call, including arguments.


classicists v. mockists

Hand-Crafted Mocks (“Stubs”)
+ Simple & familiar.
+ Black-box.
+ Can do something clever (e.g., throw exception for
a special argument), or hold state (e.g., collect a
buffered result for an assertion).
- Can get too complex if reused everywhere.

Dynamic Mocking Tools (“Mocks”)
+ Great for interactions/protocols.
+ Can be used in numerous variations or scenarios.
- White-box: Can be too explicit about
implementation.


never an absolutist


Investments
Earthbound


Write StockQuote class
Create a StockQuote for the current price
of a LunEx stock.

Quote total should reflect our 2%
commission on all LunEx transactions, plus
the flat LunEx communication surcharge of
$10.

Be sure we invoke LunEx once per quote,
as they charge $0.05 per invocation!


DATABASE

StockQuote LunExServices

+ double total() + double currentPrice(
String symbol
)


Testing with a Mock

StockQuote LunExServices

+ double total() + double currentPrice(
String symbol
)

MockLunExServices
StockQuoteTests
+ double currentPrice(
+ totalWorksRight() String symbol
defines
)


Write StockQuote class
Create a StockQuote for the current price
of a LunEx stock.

Quote total should reflect our 2%
commission on all LunEx transactions, plus
the flat LunEx communication surcharge of
$10.

Be sure we invoke LunEx once per quote,
as they charge $0.05 per invocation!


a test

@Test
public void totalCalculatesCorrectly() {
// given
LunExServices myService =
Mockito.mock(LunExServices.class);
Mockito.when(myService.currentPrice("HE3"))
.thenReturn(12.00);

StockQuote quote = new StockQuote("HE3", 100, myService);

// when
double total = quote.total();
// then
Assert.assertEquals(1234.00, total, 0.00001);
}


just enough to compile & fail

package earthboundInvestments;

import lunEx.LunExServices;

public class StockQuote {
public StockQuote(String symbol,
int numberOfShares,
LunExServices service) {
}

public double total() {
return 0;
}
}


“Obvious Implementation”

public class StockQuote {
private final double total;
public StockQuote(String symbol,
int numberOfShares,
LunExServices service) {
total = service.currentPrice(symbol) * numberOfShares
* 1.02 + 10.00;
}

public double total() {
return total;
}
}


what else?
@Test
public void totalCalculatesCorrectly() {
// given
LunExServices myService =
Mockito.mock(LunExServices.class);
Mockito.when(myService.currentPrice("HE3"))
.thenReturn(12.00);


// when
// then
Mockito.verify(myService, Mockito.times(1))
.currentPrice("HE3");
}

test using hand-crafted mock
@Test
public void totalCalculatesCorrectly_usingHandCraftedMock() {
// given
MockLunExServices myService = new MockLunExServices(12.00);


// when

// then
Assert.assertTrue(myService.wasCalledOnceAndOnlyOnce());
}


hand-crafted mock
public class MockLunExServices extends LunExServices {
private double valueToReturn;
private int callCount = 0;

public MockLunExServices(double valueToReturn) {
this.valueToReturn = valueToReturn;
}
@Override
public double currentPrice(String symbol) {
callCount++;
return valueToReturn;
}

public boolean wasCalledOnceAndOnlyOnce() {
return callCount == 1;
}
}

Summary:

1. Agile: Good!
2. “Agilist’s Dilemma”: Very bad.
3. TDD: Great!
4. Slow, non-deterministic tests: Bad.
5. Mocks: Good.
6. “Never an Absolutist!”


Rob.Myers@agileInstitute.com

http://PowersOfTwo.agileInstitute.com/

@agilecoach


Mock Objects from Concept to Code

More Related Content

Similar to Mock Objects from Concept to Code

More from Rob Myers

Mock Objects from Concept to Code

Editor's Notes