CSC/ECE 517 Fall 2014/ch1b 29 ry

Behavior-driven development using JBehave

JBehave is an open-source, Java-based Behavior-driven development (BDD) framework. It was originally developed by Dan North in 2003 to improve upon the underlying principles of Test-driven development.<ref>http://www.slideshare.net/shadrik/bdd-with-java-8323915</ref>

Background: BDD as an evolution of TDD

Behavior-Driven Development was conceived as an improvement to the thought processes behind Test-Driven Development (TDD) and Acceptance Test-Driven Planning.<ref>http://behaviour-driven.org/</ref>

TDD

The Test-driven development software development cycle

Test-driven development, which is often associated with Extreme Programming, is a software development technique which combines test-first development and Refactoring. TDD can be described at a high level as a process that iteratively follows the steps below:

1. Add a test that tests for a required functionality.
2. Get the test to fail.
3. Write just enough code for the test to pass.
4. Refactor the code to acceptable standards.

At each step along the process for TDD, the developer has to ensure that the new code which has been added does not affect previously written functionality, i.e. all tests written up to that point have to be re-run to ensure that everything is working as expected. TDD offers benefits such as: <ref>http://www.base36.com/2012/07/benefits-of-test-driven-development/</ref>

• Maintainable, flexible and easily extensible code.
• Unparalleled test coverage and a streamlined code-base.
• A cleaner interface, since the APIs produced are written from an API-User perspective.
• Better code quality through the emphasis on Refactoring.
• Executable documentation in the form of tests.

BDD and JBehave

Behavior-Driven Development is a development paradigm first proposed by Dan North, which aims to make development practices more accessible and intuitive to newcomers and experts alike by shifting the vocabulary from being test-based to behavior-based. It emphasizes communication and automation as equal goals.<ref>http://jbehave.org/introduction.html</ref> In essence, BDD Tests focus more on the features, as opposed to the actual results of the tests. Consequently, BDD helps to design the software, not just test it.<ref>https://joshldavis.com/2013/05/27/difference-between-tdd-and-bdd/</ref>

BDD aims to bridge the gap between the differing views of computer systems held by business users and technologists by using terminology focused on the behavioral aspects of the system rather than testing. Its focus is on minimizing the hurdles between specification, design, implementation and confirmation of the behavior of a system, thus enabling the incremental delivery of business systems, and in particular in allowing teams new to agile development to quickly get up to speed using extremely productive techniques.<ref>http://behaviour-driven.org/Introduction</ref>

In the words of Dan North, the creator of BDD and JBehave:<ref>http://dannorth.net/introducing-bdd/</ref>

I had a problem. While using and teaching agile practices like test-driven development (TDD) on projects in different environments, I kept coming across the same confusion and misunderstandings. Programmers wanted to know where to start, what to test and what not to test, how much to test in one go, what to call their tests, and how to understand why a test fails.

The deeper I got into TDD, the more I felt that my own journey had been less of a wax-on, wax-off process of gradual mastery than a series of blind alleys. I remember thinking “If only someone had told me that!” far more often than I thought “Wow, a door has opened.” I decided it must be possible to present TDD in a way that gets straight to the good stuff and avoids all the pitfalls.

My response is behavior-driven development (BDD). It has evolved out of established agile practices and is designed to make them more accessible and effective for teams new to agile software delivery. Over time, BDD has grown to encompass the wider picture of agile analysis and automated acceptance testing.

Towards the end of 2003, North, who had begun promoting BDD as a software development methodology, starting working on a Java framework called JBehave. He designed JBehave as a replacement for JUnit, removing all references to testing and replacing them with a vocabulary built around verifying behavior.<ref>http://dannorth.net/introducing-bdd/</ref> Since then, the framework has undergone several updates and revisions, with the current stable release at version 3.9.4. Tools such as Cspec, CppSpec, NBehave, PHPSpec, behave and RSpec now exist to support behavior-driven development in several popular languages.

Stories and Scenarios

BDD (and JBehave) revolves around the concept of a Story, which represents an automatically executable description of a requirement and its business benefit.<ref>http://jbehave.org/reference/stable/concepts.html</ref><ref>http://dannorth.net/whats-in-a-story/</ref> At its core a Story comprises of one or more Scenarios, each of which represents a concrete example of the behavior of the system. Each Scenario comprises of a number of executable steps. These Steps can be of three types:

• Given - Provides the context (precondition) to an event
• When - Represents the occurrence of the event
• Then - Occurrence of the event

These are known as BDD Keywords. Another keyword 'And' can also be used; it can be thought of as merely a substitution for the previously used keyword. A scenario can contain any number of steps, and steps of the same type can follow each other. The following example demonstrates the concept of a story:

Story: User login
  As a user
  I want to use my username and password to login
  So that I can view my home page

  Scenario: User uses an incorrect password
    Given a username 'direwolf'
    And a password 'lannister'
    When the user logs in with username and password
    Then the login page should be displayed

  Scenario: User uses a correct password
    Given a username 'direwolf'
    And a password 'stark'
    When the user logs in with username and password
    Then the home page should be displayed

As shown in the example, BDD tests use a verbose style so that they can almost be read as sentences. The ability to read a test like a sentence represents a cognitive shift in how developers can think about their tests. Reading their tests fluidly can enable them to naturally write better and more comprehensive tests that actually model and help shape the behavior of a system.<ref>https://joshldavis.com/2013/05/27/difference-between-tdd-and-bdd/</ref>

JBehave

JBehave comprises of two components:

• JBehave Core - The main Java framework
• JBehave Web - An extension of JBehave Core providing web-related functionalities

JBehave takes full advantage of all the Java Virtual Machine and the numerous libraries available for Java.<ref>https://blog.codecentric.de/en/2012/06/jbehave-configuration-tutorial/</ref> It uses annotations, which use Regex patterns as values, to map user stories to Java methods. It also uses a piece of code called the Embedder which provides an entry point into all of JBehave's functionality such as - where to look for the story files, how to handle failures, which reports to output and so on.<ref>http://edgblog.wordpress.com/2013/07/08/an-introduction-to-jbehave/</ref>

JBehave is primarily a Java API but it also has been expanded to include an Eclipse plugin as well as a Maven plugin. Which in the background uses Selenium to do behavioral test cases against a web site.

Features

• Pure java implementation
• JUnit integration
• Maven integration - allows automation of JBehave tasks at build time
• Ant integration
• Text based user stories can be written in: JBehave syntax, Gherkin syntax, or Groovy
• Selenium Integration - allows automation of web based UI test cases
• Dependency Injection support allowing both configuration and Steps instances composed via your favorite container (Guice, Needle, PicoContainer, Spring, Weld)<ref>http://jbehave.org/reference/stable/features.html</ref>
• Web Runner - a simple web-based non-technical interface that allows non-technical team members (Execs, BAs, QAs etc... ) to make contributions by generating stories. Run as a simple Jetty Web Service application from maven.
• Eclipse IDE Integration<ref>http://jbehave.org/eclipse-integration.html</ref>

*Syntax highlighting
*Step hyperlink detection and link to corresponding Java method
*Step auto-completion
*Step validation, detecting both unimplemented steps and ambiguous steps, i.e. matching multiple methods

Figure 1. JBehave Plugin for Eclipse IDE

Usage Details

There are five basic steps to using JBehave:

1. Setup a configuration file, called a “textual story” with all of your english verbiage in it. This textual story is very similar to Cucumber test cases.
2. Next, write a plain old java object (POJO) and add annotations to it that match the actions in your “textual story”.
3. (only once) Write a simple configuration file that defines the relationship between your textual story file and your POJO, for instance, one-to-one.
4. Run your test case.
5. Go over the outputted review files.

Begin by writing a “textual story” that tells a narrative:

Given a cholesterol calculator
When a patient has a total cholesterol of 201 (mg/dL) and a HDL of 74 and triglycerides of 44 
Then the patient has LDL of 118.2. 

[Note: for reference the calculation in use: LDL = total cholesterol – HDL – (triglycerides/5)]

Next compose a POJO class that has annotations that match the first (bolded above) words from the textual story. These bolded terms will actually become the annotations in the POJO and will become the action steps taken by JBehave to run the test case. JBehave will actually use these key-words in the annotation and the story to look up the next action from the POJO to run.

public class CalculateLDLTest {
	private LDLCalculator ldlCalculator;
	private float result;
	
	@Given (“a cholesterol calculator”)
	public void init(){
		ldlCalculator = new LDLCalculator();
        }

        @When (“a patient has a total cholesterol of $total and a HDL of $hdl and triglycerides of $tri”)
        public void populateValues(float total, float hdl, float tri){
	        result = ldlCalculator.calculate(total, hdl, tri);
        }

        @Then (“the patient has LDL of $ldl”)
        public void checkResult(float ldl){
	        assert.assertEquals(ldl, result, “Did not get the expected BMI”);
        }
}

Additionally, the story and pojo need to be wired together. This is done with a simple configuration POJO, that tells JBehave about the nature of the relationship between the story and the annotated POJO. // Specify the mapping between the story and the pojo

public class RunCholesterol extends JUnitStory {

    @Override
    public Configuration configuration() {
        return new MostUsefulConfiguration()
            .useStoryLoader(new LoadFromClasspath(this.getClass()))  
            .useStoryReporterBuilder(new StoryReporterBuilder().withDefaultFormats().withFormats(Format.CONSOLE, Format.TXT)); 
    }
 
    // Here we specify the CalculateLDLTest classes
    @Override
    public InjectableStepsFactory stepsFactory() {        
        return new InstanceStepsFactory(configuration(), new CalculateLDLTest());
    }
}

Run the tests using the Eclipse JUnit plugin or Maven > mvn clean install

Review the output for the results

JBehave Web

JBehave Web is an extension of JBehave Core, providing support for web-related access and functionality. The two main components of JBehave are:

Web Runner

Web Runner is an application developed using Java Standard Edition (SE) that allows non-technical business resources to contribute user stories concurrently. The system is run from a web application server such as Jetty or Tomcat. It can be easily started via running the Maven target, “mvn jetty:run-war -Djbehave.webrunner.version=4.6” from inside the jbehave-web/web-runner folder inside the git repository. See Figure 2: Web Runner application to see a running example of Web Runner, where users can submit, run, or view stories from the simple web interface.

Figure 2. WebRunner
[1]

Selenium Integration module

This module provides integration of JBehave's BDD with Selenium, an open-source suite of tools for automated web testing across various platforms. The module supports implementations in both the APIs provided by Selenium - the Selenium IDE and the Selenium Webdriver.<ref>http://jbehave.org/reference/web/stable/using-selenium.html</ref> One would expect the step classes (which implement user story steps) to get cluttered with Selenium calls, as each step would typically require interactions with multiple web pages. However, JBehave uses elements called Page Objects that allow users to easily access the objects for each page by abstracting Selenium's behavior behind pages. These page objects can then be injected into JBehave Step classes, as shown in the following example:

Given user is on Home page
When user clicks on Logout
Then Login page is shown

public class LogoutSteps {
 
    private final Pages pages;
 
    public LogoutSteps(Pages pages) {
        this.pages = pages;
    }
 
    @Given("user is on Home page")
    public void userIsOnHomePage(){       
        pages.home().open();       
    }
 
    @When("user clicks on Logout")
    public void userClicksOnLogout(){       
        pages.home().click(logout);
    }
 
    @Then("Login page is shown")
    public void loginPageIsShown(){
        pages.login().pageIsShown();
    }
}

Once the step classes are defined, the integration of JBehave with Selenium can be done in one of several ways (such as having an embeddable runnable class). To automate Selenium tests, a web application server is required along with the Selenium server.

Further Reading

1. BDD by example
2. JBehave configuration tutorial

References

<references/>