Cucumber-Jvm with Cucumber-Java + Cucumber-JUnit Example

In this post I will show you how to add Cucumber-Jvm to your project, how to write a scenarios and step definitions using JUnit 4, and of course how to execute those scenarios, all that using the Java language. No more Ruby dependency, .

I have created a simple Banking application using Eclipse IDE to demonstrate writing and executing scenarios. Well, the application hasn’t been built, at this point I have just a blank Maven project. I’ll be employing Behaviour Driven Development (BDD) to write the tests and then the implementation, using outside-in development to ensure that the only code I write is code that is needed to meet the acceptance criteria.

After creating a blank Maven project, you need to add the following dependencies to your project’s pom.xml file:

        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-java</artifactId>
            <version>1.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-junit</artifactId>
            <version>1.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

A standard Maven project directory structure will have a source folder src/test/resources, this is the directory where you should create your .feature files. So let’s create a feature for depositing money in to a Users bank account.

Create a file called deposit.feature in src/test/resources. You can of course create packages in this source folder to organize your feature files.

Let’s write our first simple scenario. We want to test that when an amount has been deposited in to a User’s account that the User’s current balance has been updated by that amount.

src/test/resources/com/c0deattack/cucumberjvmtutorial/deposit.feature

Feature: Depositing money in to a User account

Scenario: Depositing money in to User's account should add money to the User's current balance
Given a User has no money in their account
When £100 is deposited in to the account
Then the balance should be £100

This first scenario describes the steps that will have to be executed successfully for the Scenario to pass. At this point you might be wondering how to execute that scenario?

You run the .feature using a JUnit Runner, which we already have from the Cucumber-Junit Library. So all we need to do is create a blank test class, and annotate it with JUnit’s @RunWith annotation as follows:

src/test/java/com/c0deattack/cucumberjvmtutorial/RunTests.java

package com.c0deattack.cucumberjvmtutorial;

import org.junit.runner.RunWith;
import cucumber.junit.Cucumber;

@RunWith(Cucumber.class)
@Cucumber.Options(format={"pretty", "html:target/cucumber"})
public class RunTests {
}

You can now run RunTests.java like you would any other JUnit test. Take a look at the JUnit Tab in your Eclipse IDE. You’ll see that the test appears to have passed – how can this be if we never created a User, or an Account or a method to deposit money?
Take a closer look, the scenario steps were actually skipped, they were not executed because no step definitions were found. Take a look at the output in the Console Tab in Eclipse. You’ll see some very helpful information about the scenario that was executed and the steps which were skipped.
The output also has shown you default implementations for the step definitions, how awesome is that!

Let’s create a class for the step definitions.
src/test/java/com/c0deattack/cucumberjvmtutorial/DepositStepDefinitions.java

package com.c0deattack.cucumberjvmtutorial;

import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.runtime.PendingException;

public class DepositStepDefinitions {

    @Given("^a User has no money in their account$")
    public void a_User_has_no_money_in_their_current_account() {
        // Express the Regexp above with the code you wish you had
        throw new PendingException();
    }

    @When("^£(\\d+) is deposited in to the account$")
    public void £_is_deposited_in_to_the_account(int arg1) {
        // Express the Regexp above with the code you wish you had
        throw new PendingException();
    }

    @Then("^the balance should be £(\\d+)$")
    public void the_balance_should_be_£(int arg1) {
        // Express the Regexp above with the code you wish you had
        throw new PendingException();
    }
}

At this point we’re ready to implement the step definitions. Let’s start with the Given step; Given a User has no money in their current account. The step hints at us to create a User entity and an Account entity. Let’s create these locally in DepositStepDefinitions.java, we will refactor our code later on.

src/test/java/com/c0deattack/cucumberjvmtutorial/DepositStepDefinitions.java

package com.c0deattack.cucumberjvmtutorial;

import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.runtime.PendingException;

public class DepositStepDefinitions {

	@Given("^a User has no money in their account$")
	public void a_User_has_no_money_in_their_current_account() {
	    User user = new User();
	    Account account = new Account();
	    user.setAccount(account);
	}

	@When("^£(\\d+) is deposited in to the account$")
	public void £_is_deposited_in_to_the_account(int arg1) {
	    // Express the Regexp above with the code you wish you had
	    throw new PendingException();
	}

	@Then("^the balance should be £(\\d+)$")
	public void the_balance_should_be_£(int arg1) {
	    // Express the Regexp above with the code you wish you had
	    throw new PendingException();
	}

	private class User {
		private Account account;

		public void setAccount(Account account) {
			this.account = account;
		}
	}

	private class Account {
	}
}

This isn’t quite right, the Given step is saying that the balance should be zero, but all we’re doing in the step definition is creating a User and an Account. So let’s also add an assert statement to ensure the balance is zero.

src/test/java/com/c0deattack/cucumberjvmtutorial/DepositStepDefinitions.java

@Given("^a User has no money in their account$")
public void a_User_has_no_money_in_their_current_account() {
	User user = new User();
	Account account = new Account();
	user.setAccount(account);
    assertTrue("The balance is not zero.", account.getBalance() == 0);
}

Adding the assertion at Line 6 also guided us to create a balance in the Account.

Try running RunTests.java now and you’ll see we have to now implement the When step; When £100 is deposited in to the account. Let’s do that now. We need to take the amount, which is passed to our step definition as a method argument, and deposit it in to the account which was created in the previous step. So we need access to the account which we created. Let’s refactor the code so that we can access the account, like this:

src/test/java/com/c0deattack/cucumberjvmtutorial/DepositStepDefinitions.java

package com.c0deattack.cucumberjvmtutorial;

import static org.junit.Assert.assertTrue;
import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.runtime.PendingException;

public class DepositStepDefinitions {

	private Account account;

	@Given("^a User has no money in their account$")
	public void a_User_has_no_money_in_their_current_account() {
	    User user = new User();
	    account = new Account();
	    user.setAccount(account);

	    assertTrue("The balance is not zero.", account.getBalance() == 0L);
	}

	@When("^£(\\d+) is deposited in to the account$")
	public void £_is_deposited_in_to_the_account(int amount) {
	    account.deposit(amount);
	}

	@Then("^the balance should be £(\\d+)$")
	public void the_balance_should_be_£(int arg1) {
	    // Express the Regexp above with the code you wish you had
	    throw new PendingException();
	}

	private class User {
		private Account account;

		public void setAccount(Account account) {
			this.account = account;
		}
	}

	private class Account {
		private int balance;

		public Account() {
			this.balance = 0;
		}

		public int getBalance() {
			return balance;
		}

		public void deposit(int amount) {
			this.balance += amount;
		}
	}

}

Here we have made an Account a class member. It is initialized in the Given step, and in the When step we deposit an amount. The step has guided us to create an account.deposit(amount) method. After adding the When step definition implementation we execute the Feature again and we’re told that we still need to properly implement the final Then step; Then the balance should be £100;

    @Then("^the balance should be £(\\d+)$")
    public void the_balance_should_be_£(int expectedBalance) {
	int currentBalance = account.getBalance();
        assertTrue("The expected balance was £100, but actually was: " + currentBalance, currentBalance == expectedBalance);
    }

That’s it! You’ve now written your first Feature file, with your first Scenario and implemented your first step definitions which execute the Scenario. What’s next? Refactor! Clearly we have plenty of opportunity to refactor our DepositStepDefinitons.java class, for instance we don’t want to leave those private classes in there. And we don’t really want to leave the Account class member like that either. We want our steps to be reusable across many scenarios. But at the moment the When step cannot be reused without first ensuring an account exists (ie. is not null).

In my next post we will refactor this class to address those issues. But hey, why wait for me, give it a go yourself!

About these ads