Cucumber and Spock Primer

Cucumber and Spock Primer
BDD Masterclass
Building software that makes a difference, and building it well
@wakaleo
www.johnfergusonsmart.com
reachme@johnfergusonsmart.com

Writing Acceptance Criteria 
in Gherkin

Overview
Overview
Basic Gherkin
Feature: Earning Frequent Flyer points through flights
Scenario: Economy flights earn points by distance
Given the distance from London to Paris is 344 km
When I fly from London to Paris in Economy
Then I should earn 344 points
A feature represents a
deliverable piece of functionality
Each feature should
have a title
A feature contains one
or more scenarios
Features and Scenarios

Overview
Overview
Basic Gherkin
In order to encourage repeat business
As an Airline Sales Manager
I want customers to be able to cumulate points when they
fly with us
Economy class earns 1 point per kilometre
Free-text description  
(great for living documentation)
You can also put a description
for a Scenario
Free text descriptions

Overview
Overview
Basic Gherkin
Economy class earns 1 point per kilometre
GIVEN: Preconditions
WHEN: Action to illustrate
THEN: Expected outcome
Scenarios

Overview
Overview
Basic Gherkin
Scenario: Economy flights over several legs
And the distance from Paris to Krakow is 1500 km
When I fly from London to Krakow via Paris in Economy
And I should earn 18 status points
Multiple preconditions
Scenarios
Multiple outcomes

Overview
Overview
Basic Gherkin
Given steps
✓ Defines preconditions and context
✓ Typically something that happened in the past
✓ Can interact with the system
✓ Should not perform any actions being tested by the
scenario
Given a user registers on the site
And the user logs in
When the home page appears
Then the user’s name should be visible
Given a user has registered on the site
When the user logs in
Then the user’s name should be visible on
the home page
What are we testing here?

Overview
Overview
Basic Gherkin
When steps
✓ The action under test
✓ Avoid chaining too many clauses
Given a user has registered on the site
When the user enters 'Scott' in the user name
And the user enters 'Tiger' in the password
And the user selects 'UK' as the country
And the user clicks on the Login button
And the user validates the Cookies alert
Then the user’s name should be visible on the home page
Too much detail
To implementation-specific

Overview
Overview
Basic Gherkin
Then steps
✓ The expected outcome
✓ Can query the system
✓ Should not perform actions on the system
Given a batch file needs to be processed
When the user uploads the batch file
Then the result should be visible
And a notification message should be sent to the user

Overview
Overview
Basic Gherkin
Background steps
✓ Common steps for all the scenarios in a feature file
✓ Avoid duplication
✓ More focused scenarios
I want customers to be able to cumulate points when
they fly with us
Background:
And the distance from Paris to Krakow is 1500km
Scenario: Economy flights over several legs
When I fly from London to Krakow via Paris in Economy

Overview
Overview
Basic Gherkin
Scenario Outlines
✓ Use a table to simplify duplicated but similar scenarios
Background:
And the distance from London to Budapest is 1600km
Scenario: Economy flights to Krakow
When I fly from London to Krakow in Economy
Scenario: Economy flights to Budapest
When I fly from London to Budapest in Economy

Overview
Overview
Basic Gherkin
Multi-line string parameters
✓ Pass in multi-line strings as parameters
Given a travel provides feedback about the flight
"""
It was OK
The food was rubbish but the staff were nice
The flight was delayed by 15 minutes
"""

Step Definitions
in Java with
Cucumber and
Serenity BDD
The Cucumber Test Runner
import cucumber.api.CucumberOptions;
import net.serenitybdd.cucumber.CucumberWithSerenity;
import org.junit.runner.RunWith;
@RunWith(CucumberWithSerenity.class)
@CucumberOptions(features = "src/test/resources/features/deposit_funds",
glue = "com.bddinaction.serenitybank")
public class DepositFunds {}
A Cucumber test runner
Which feature files to run
Where to find the step definition classes

Step Definitions
in Java with
Cucumber and
Serenity BDD
Step Deﬁnitions
@Given("^the distance from (.*) to (.*) is (d+) km$")
public void pointsEarnedBetweenCities(String departure,
String destination,
int distance)
throws Throwable {
}
@Given, @When, or @Then annotation
Matching regular expression
Matched expressions are passed in as parameters

Step Definitions
in Java with
Cucumber and
Serenity BDD
Matching Lists
Given the following possible destinations: London, Paris, Amsterdam
@Given("^the following possible destinations: (.*)$")
public void theFollowingPossibleDestinations(List<String> destinations) {
}
Declare a list of Strings
Given the following possible destinations:
| London |
| Paris |
| Amsterdam |
alternative notation

Step Definitions
in Java with
Cucumber and
Serenity BDD
Matching enums
public enum City {
London, Paris, Amsterdam
}
public enum CabinClass {
Economy, Business, First
}
@When("^I fly from (.*) to (.*) in (.*)$")
public void iFly(City departure, City destination, CabinClass cabinClass){
}
Enums are matched automatically

Step Definitions
in Java with
Cucumber and
Serenity BDD
Matching tables
Given the following flight routes:
| departure | destination | distance |
| London | Paris | 344 |
| Paris | Krakow | 1500 |
| London | Budapest | 1600 |
public void flightRoutes(Map<String, String> flightRoutes) {}
Tables can be passed as a map of Strings

Step Definitions
in Java with
Cucumber and
Serenity BDD
Transformers
When I fly from San Francisco to Paris in Economy
public enum City {
London("London"),
Paris("Paris"),
SanFrancisco("San Francisco"),
SaintPetersbuug("St Petersburg");
public final String name;
City(String name) { this.name = name; }
}
@When("^I fly from (.*) to (.*) in (.*)$")
public void iFly(@Transform(CityConverter.class) City departure,
@Transform(CityConverter.class) City destination,
CabinClass cabinClass) {}
public class CityConverter extends Transformer<City> {
@Override
public City transform(String cityName) {
return Arrays.stream(City.values())
.filter(city -> city.name.equalsIgnoreCase(cityName))
.findFirst()
.orElseThrow(() -> new UnknownCityException(cityName));
}
}

Overview
Overview
Introduction
to Spock
http://spockframework.org/
import spock.lang.Specification
class WhenManagingAnAccount extends Specification {
def "depositing a sum into the account should update the balance"() {
given:
def currentAccount = new BankAccount("123456", AccountType.Current)
when:
currentAccount.deposit(1000)
then:
currentAccount.balance == 1000
}
}
All Spock tests extend Speciﬁcation
Plain English test names
Arrange
Act
Assert
Acts as an assertion

Overview
Overview
Using Fields
class WhenWithdrawingFunds extends Specification {
def accountService = new AccountService();
def "withdrawing funds from a current account"() {
given:
def accountNumber = accountService.createNewAccount(Current, 100.00)
when:
accountService.makeWithdrawal(accountNumber, 50.00, LocalDate.now())
then:
accountService.getBalance(accountNumber) == 50.00
}
def "withdrawing funds from a savings account"() {
given:
def accountNumber = accountService.createNewAccount(BigSaver, 1000.00)
when:
then:
thrown(MinimumBalanceRequiredException)
and:
}
}
Instantiated once before each test

Overview
Overview
Using Fields
@Shared def accountService = new AccountService()
given:
when:
then:
}
given:
when:
then:
and:
}
}
Instantiated once and shared between the tests

Overview
Overview
Using Fields
def accountService
def setup() {
accountService = new AccountService()
}
given:
when:
then:
}
given:
when:
then:
and:
}
}
Runs before each test

Overview
Overview
Using Fields
def setupSpec() {
accountService = new AccountService()
}
given:
when:
then:
}
given:
when:
then:
and:
}
}
Runs once at the start of the Specification
See also cleanup() and cleanupSpec()

Overview
Overview
Exceptions
given:
when:
accountService.makeWithdrawal(accountNumber, 50.00,
LocalDate.now())
then:
and:
}
}
Expect this exception to be thrown
Also, the balance should be unchanged

Overview
Overview
Exceptions
given:
when:
then:
MinimumBalanceRequiredException exception = thrown()
and:
exception.message == "Minimum balance for this account is €1000.00"
and:
}
Expect this exception to be thrown
Check exception attributes

Overview
Overview
Data-Driven
Specifications
class WhenCalculatingDepositFees extends Specification {
def “correct deposit should be calculated"() {
expect:
DepositFee.forAccountType(accountType).apply(amount) == expectedDepositFee
where:
accountType | amount | expectedDepositFee
Current | 1000.0 | 0.0
BasicSavings | 100.00 | 0.50
BigSaver | 10.00 | 0.50
BigSaver | 100.01 | 0.75
BigSaver | 1000.01 | 1.25
}
}
Use these variables in the test

Overview
Overview
Data-Driven
Specifications
class WhenCalculatingDepositFees extends Specification {
@Unroll
def “A deposit of #amount in an #accountType account"() {
expect:
DepositFee.forAccountType(accountType).apply(amount) == expectedDepositFee
where:
accountType | amount | expectedDepositFee
Current | 1000.0 | 0.0
BasicSavings | 100.00 | 0.50
BigSaver | 10.00 | 0.50
BigSaver | 100.01 | 0.75
BigSaver | 1000.01 | 1.25
}
}
Table variables can be placed in the test title
Report a separate test for each row of data

Overview
Overview
Test Doubles
✓ Test Doubles
✓ Stand-ins for dependencies
✓ Transparently replace objects used by  
the class under test
✓ Make tests faster and easier to write

Overview
Overview
Test Doubles
✓ Test Doubles stand in for objects that are
✓ Unavailable or unfinished
✓ Slow
✓ Needs something that is unavailable
✓ Hard to instantiate

Overview
Overview
Test Doubles A complex remote service

Overview
Overview
Test Doubles def "should apply correct discount for a valid discount code"() {
given:
PriceService priceService = ???
OrderProcessor processor = new OrderProcessor(priceService);
and:
def mouse = new Product("Wireless Mouse", 20.00);
def tenPercentOffPrice = 18.00;
when:
def order = ProductOrder.discountedOrder(mouse, “MINUS_10_PERCENT");
def discountedPrice = processor.calculateTotalPriceFor(order)
then:
discountedPrice == tenPercentOffPrice;
}
How do we get a PriceService?

Overview
Overview
Test Doubles class PriceServiceTestDouble extends PriceService {
private final double discount;
TestPriceService(double discount) {
this.discount = discount;
}
@Override
public double percentageDiscountForCode(String discountCode) {
return discount;
}
}
A test double

Overview
Overview
Test Doubles def "should apply correct discount for a valid discount code"() {
given:
PriceService priceService = new PriceServiceTestDouble(0.20)
OrderProcessor processor = new OrderProcessor(priceService);
and:
def mouse = new Product("Wireless Mouse", 20.00);
def tenPercentOffPrice = 18.00;
when:
def order = ProductOrder.discountedOrder(mouse, “MINUS_10_PERCENT");
def discountedPrice = processor.calculateTotalPriceFor(order)
then:
discountedPrice == tenPercentOffPrice;
}
Now use the test double

Overview
Overview
Test Doubles
✓ There are several types of Test Doubles
✓ Stubs
✓ Fakes
✓ Mocks

Overview
Overview
Test Doubles
✓ Stubs
✓ Minimal implementation
✓ Returns hard-coded values
✓ State-based testing
class PriceServiceTestDouble extends PriceService {
@Override
public double percentageDiscountForCode(String discountCode) {
return 10;
}
}

Overview
Overview
Test Doubles
✓ Fakes
✓ Smarter stubs
✓ Some simple behaviour
✓ State-based testing
public class MockEnvironmentVariables implements EnvironmentVariables {
private Properties properties = new Properties();
public String getProperty(String name) {
return properties.getProperty(name);
}
public String getProperty(String name, String defaultValue) {
return properties.getProperty(name, defaultValue);
}
public void setProperty(String name, String value) {
properties.setProperty(name, value);
}
public void setValue(String name, String value) {
values.setProperty(name, value);
}
}

Overview
Overview
Test Doubles
✓ Mocks
✓ Sophisticated stubs
✓ Record and verify interactions
✓ Need a mocking framework

Overview
Overview
Test Doubles
✓ Mocks
✓ Only mock what you own
✓ Verify specification, not implementation
✓ Specify as little as possible in a test
✓ Only mock your immediate neighbours
✓ Don’t mock boundary objects
✓ Don’t mock domain objects
✓ Keep it simple

Overview
Overview
Test Doubles
in Spock
def vatService = Mock(VATService)
def seller = new Seller(vatService);
def “VAT should apply on ordinary articles"() {
given: "the VAT rate for shirts is 20%"
seller = new Seller(vatService);
vatService.getRateFor("shirt") >> 0.2
and: "we are selling a shirt"
def sale = seller.sells(1, "shirt").forANetPriceOf(10.00)
when: "we calculate the price including VAT"
def totalPrice = sale.totalPrice
then: "the price should include GST of 20%"
totalPrice == 12.00
}
The seller thinks he is using a real VATService
Create a mocked version of the VATService class
Stubbed return value for the getRateFor() method

Overview
Overview
Test Doubles
in Spock
…
VATService vatService = Mock()
You can create a mock object in two ways
(This way is more IDE-friendly)
…
VATService vatService = Mock()
Creating Mocks

Overview
Overview
Test Doubles
in Spock
def vatService = Stub(VATService)
…
VATService vatService = Stub()
A Stub returns empty or “dummy” responses for all method calls
(This way is more IDE-friendly)
Creating Stubs

Overview
Overview
Test Doubles
in Spock
Mock the result of a particular method call
Return different values on successive calls
vatService.getRateFor("shirt") >>> [0.2, 0.1]
vatService.getRateFor("shirt") >>
{ throw new UnknownProductException()}
Do something in a closure
Mocking interactions
VATService vatService = Mock() {
getRateFor("shirt") >> 0.2
getRateFor("banana") >> 0.1
}
Mock the interactions at creation time

Overview
Overview
Test Doubles
in Spock
def "The VAT Service should be used to obtain VAT values"() {
given: "the GST rate for shirts is 10%"
seller = new Seller(vatService);
when: "we sell a shirt"
seller.sells(1, "shirt").forANetPriceOf(10.00)
then: "the VAT service should be used to determine the GST rate"
1 * vatService.getRateFor("shirt")
}
This method should be called exactly once
Checking interactions

Overview
Overview
Interactions in
Spock
1 * vatService.getRateFor("shirt") // Exactly once with this parameter
(1.._) * vatService.getRateFor("shirt") // At least once
(_..2) * vatService.getRateFor("shirt") // No more than twice
vatService.getRateFor(_) // Called with any parameter
vatService.getRateFor({it != "banana"}) // Custom constraint
Checking interactions

Overview
Overview
Documentation
given: "a current account with €100"
when: "we withdraw €50"
then: "the balance should be €50"
}
Descriptive texts go after the labels

Thank You!
AUTHOR OF ‘BDD IN ACTION’
@wakaleo
www.johnfergusonsmart.com
reachme@johnfergusonsmart.com

Cucumber and Spock Primer

More Related Content

What's hot (20)

Similar to Cucumber and Spock Primer (20)

More from John Ferguson Smart Limited (20)

Recently uploaded (20)

Cucumber and Spock Primer