CSC/ECE 517 Fall 2014/ch1b 29 ry: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
(JBehave/Selenium content added)
(Hyperlinks and references)
Line 1: Line 1:
==Behavior-driven development using JBehave==
==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] [1].  
JBehave is an [http://en.wikipedia.org/wiki/Open_source open-source], Java-based [http://behaviour-driven.org/ Behavior-driven development] (BDD) framework. It was originally developed by Dan North in 2003 to improve upon the underlying principles of [http://agiledata.org/essays/tdd.html Test-driven development].<ref>http://www.slideshare.net/shadrik/bdd-with-java-8323915</ref>




Line 8: Line 8:
==Background: BDD as an evolution of TDD==
==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 [1]].[2].
Behavior-Driven Development was conceived as an improvement to the thought processes behind Test-Driven Development (TDD) and [http://testdrivendeveloper.com/2008/04/02/AcceptanceTestDrivenDevelopmentExplained.aspx Acceptance Test-Driven Planning].<ref>http://behaviour-driven.org/</ref>


===TDD===
===TDD===
[[File:TestDrivenDevelopment.png|frame|300px|The Test-driven development software development cycle]]
[[File:TestDrivenDevelopment.png|frame|300px|The Test-driven development software development cycle]]
Test-driven development, which is often associated with [ExtremeProgramming], 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:
Test-driven development, which is often associated with [http://www.extremeprogramming.org/ Extreme Programming], is a software development technique which combines [http://tutorials.jenkov.com/java-unit-testing/test-first-development.html test-first development] and [http://c2.com/cgi/wiki?WhatIsRefactoring Refactoring]. TDD can be described at a high level as a process that iteratively follows the steps below:




Line 21: Line 21:




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: [3]
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.
*Maintainable, flexible and easily extensible code.
*Unparalleled test coverage and a streamlined code-base.
*Unparalleled test coverage and a streamlined code-base.
*A cleaner interface, since the [API]s produced are written from an API-User perspective.
*A cleaner interface, since the [http://en.wikipedia.org/wiki/Application_programming_interface APIs] produced are written from an API-User perspective.
*Better code quality through the emphasis on Refactoring.
*Better code quality through the emphasis on Refactoring.
*Executable documentation in the form of tests.
*Executable documentation in the form of tests.
Line 33: Line 33:
===BDD and JBehave===
===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[4]. 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.[5]
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.[6]
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:[7]
In the words of Dan North, the creator of BDD and JBehave:<ref>http://dannorth.net/introducing-bdd/</ref>




Line 46: Line 46:
</p>
</p>
<p>
<p>
''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.
''My response is behavior-driven development (BDD). It has evolved out of established [http://agilemethodology.org/ 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.
</p>
</p>
</blockquote>
</blockquote>




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[7]. 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], [Cuke4Duke], [PHPSpec], [behave] and [RSpec] now exist to support behavior-driven development in several popular languages.  
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 [http://junit.org/ 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 [https://github.com/arnaudbrejeon/cspec/wiki Cspec], [https://github.com/tpuronen/cppspec CppSpec], [http://nbehave.org/ NBehave], [http://phpspec.net/ PHPSpec], [http://pythonhosted.org/behave/ behave] and [http://rspec.info/ RSpec] now exist to support behavior-driven development in several popular languages.  




====Stories and Scenarios====
====Stories and Scenarios====
BDD (and JBehave) revolves around the concept of a <b>Story</b>, which represents an automatically executable description of a requirement and its business benefit [8][9]. At its core a Story comprises of one or more <b>Scenarios</b>, 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:
BDD (and JBehave) revolves around the concept of a <b>Story</b>, 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 <b>Scenarios</b>, 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
*'''Given''' - Provides the context (precondition) to an event
Line 78: Line 78:
     '''Then''' the home page should be displayed
     '''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.[5]
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>




Line 88: Line 88:
*JBehave Web - An extension of JBehave Core providing web-related functionalities
*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.[10] 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.[11]
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 [http://jbehave.org/reference/stable/annotations.html annotations], which use [http://en.wikipedia.org/wiki/Regular_expression Regex] patterns as values, to map user stories to Java methods. It also uses a piece of code called the [http://jbehave.org/reference/stable/javadoc/core/org/jbehave/core/embedder/Embedder.html 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.
JBehave is primarily a Java API but it also has been expanded to include an [http://en.wikipedia.org/wiki/Eclipse_%28software%29 Eclipse] plugin as well as a [http://maven.apache.org/ Maven] plugin. Which in the background uses [http://www.seleniumhq.org/ Selenium] to do behavioral test cases against a web site.




Line 96: Line 96:
<div style="padding-left:2em;">
<div style="padding-left:2em;">
*Pure java implementation
*Pure java implementation
*Junit integration
*JUnit integration
*Maven integration - allows automation of JBehave tasks at build time  
*Maven integration - allows automation of JBehave tasks at build time  
*Ant integration  
*Ant integration  
*Text based user stories can be written in: JBehave syntax, Gherkin syntax, or Groovy (Rob/Yogesh: Can we find examples of these?)
*Text based user stories can be written in: JBehave syntax, Gherkin syntax, or Groovy (Rob/Yogesh: Can we find examples of these?)
*Selenium Integration - allows automation of web based UI test cases
*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) [4]
*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.  
*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 [2]
*Eclipse IDE Integration<ref>http://jbehave.org/eclipse-integration.html</ref>
*Syntax highlighting
*Syntax highlighting
*Step hyperlink detection and link to corresponding Java method
*Step hyperlink detection and link to corresponding Java method
Line 116: Line 116:
   
   
There are five basic steps to using JBehave:  
There are five basic steps to using JBehave:  
#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.
#Setup a configuration file, called a “textual story” with all of your english verbiage in it. This textual story is very similar to [http://cukes.info/ Cucumber] test cases.
#Next, write a [plain old java object] (POJO) and add annotations to it that match the actions in your “textual story”.
#Next, write a [http://en.wikipedia.org/wiki/Plain_Old_Java_Object plain old java object] (POJO) and add annotations to it that match the actions in your “textual story”.
#(only once) Write a simple configuration file that defines the relationship between your textual story file and your POJO, for instance, one-to-one.
#(only once) Write a simple configuration file that defines the relationship between your textual story file and your POJO, for instance, one-to-one.
#Run your test case.
#Run your test case.
Line 130: Line 130:
[''Note: for reference the calculation in use: LDL = total cholesterol – HDL – (triglycerides/5)'']
[''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.  
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.  
<pre>
<pre>
public class CalculateLDLTest {
public class CalculateLDLTest {
Line 152: Line 152:
}
}
</pre>
</pre>
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.
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
// Specify the mapping between the story and the pojo
<pre>
<pre>
Line 172: Line 172:
</pre>
</pre>


Run the tests using the Eclipse JUnit plugin or maven
Run the tests using the Eclipse JUnit plugin or Maven
> mvn clean install
> mvn clean install
[ Rob: put output here ]
[ Rob: put output here ]
Line 182: Line 182:
===Web Runner===
===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 repo. 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.
Web Runner is an application developed using [http://www.oracle.com/technetwork/java/javase/overview/index.html 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 [http://www.eclipse.org/jetty/ Jetty] or [http://tomcat.apache.org/ 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.




===Selenium Integration module===
===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].[12] 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 behaviour behind pages. These page objects can then be injected into JBehave Step classes, as shown in the following example:
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 [http://docs.seleniumhq.org/docs/02_selenium_ide.jsp Selenium IDE] and the [http://docs.seleniumhq.org/docs/03_webdriver.jsp 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 [http://jbehave.org/reference/web/stable/page-objects.html 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
  '''Given''' user is on Home page
Line 220: Line 219:
</pre>
</pre>


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[http://jbehave.org/reference/stable/javadoc/core/org/jbehave/core/class-use/Embeddable.html]). To automate Selenium tests, a [web application server] is required along with the Selenium server.
Once the step classes are defined, the integration of JBehave with Selenium can be done in one of several ways (such as having an [http://jbehave.org/reference/stable/javadoc/core/org/jbehave/core/class-use/Embeddable.html embeddable runnable class]). To automate Selenium tests, a [http://en.wikipedia.org/wiki/Application_server web application server] is required along with the Selenium server.




==Further Reading==
==Further Reading==
BDD by example [http://www.ryangreenhall.com/articles/bdd-by-example.html]
#[http://www.ryangreenhall.com/articles/bdd-by-example.html BDD by example ]
Configuration tutorial - https://blog.codecentric.de/en/2012/06/jbehave-configuration-tutorial/
#[https://blog.codecentric.de/en/2012/06/jbehave-configuration-tutorial/ JBehave configuration tutorial]




==References==
==References==
 
<references/>
[1]http://www.slideshare.net/shadrik/bdd-with-java-8323915
[2]http://jbehave.org/eclipse-integration.html
[3]http://jbehave.org/reference/web/stable/using-web-runner.html
[4]http://jbehave.org/reference/stable/features.html
 
[1]http://testdrivendeveloper.com/2008/04/02/AcceptanceTestDrivenDevelopmentExplained.aspx
[2]http://behaviour-driven.org/
[3]http://www.base36.com/2012/07/benefits-of-test-driven-development/
[4]http://jbehave.org/introduction.html
[5]https://joshldavis.com/2013/05/27/difference-between-tdd-and-bdd/
[6]http://behaviour-driven.org/Introduction
[7]http://dannorth.net/introducing-bdd/
[8]http://jbehave.org/reference/stable/concepts.html
[9]http://dannorth.net/whats-in-a-story/
[10]https://blog.codecentric.de/en/2012/06/jbehave-configuration-tutorial/
[11]http://edgblog.wordpress.com/2013/07/08/an-introduction-to-jbehave/
[12]http://jbehave.org/reference/web/stable/using-selenium.html

Revision as of 10:14, 5 October 2014

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 (Rob/Yogesh: Can we find examples of these?)
  • 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 [ Rob: put output here ] 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.


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/>