It’s an apparent truth for anybody who’s been utilizing Cucumber for Java in take a look at automation that steps have to be outlined inside a category. Passing take a look at state from one step definition to a different might be simply achieved utilizing occasion variables, however that solely works for elementary and small tasks. In any state of affairs the place writing cucumber situations is a part of a non-trivial software program supply endeavor, Dependency Injection (DI) is the popular (and normally obligatory!) answer. After studying the article under, you’ll be taught why that’s the case and learn how to implement DI in your Cucumber-JVM exams shortly.
Preface
Let’s take a look on the following state of affairs written in Gherkin:
If we assume that it’s a part of a small take a look at suite, then its implementation utilizing step definitions throughout the Cucumber-JVM framework may appear like this:
Within the instance above, the information is handed between step definitions (strategies) by occasion variables. This works as a result of the strategies are in the identical class – PurchaseProcess, since occasion variables are usually accessible solely inside the identical class that declares them.
Downside
The variety of step definitions grows when the variety of Cucumber situations grows. Ultimately, this forces us to separate our steps into a number of courses – to take care of code readability and maintainability, amongst different causes. Making use of this truism to the earlier instance may lead to one thing like this:
However now we face an issue: the checkPriceInHistory technique moved into the newly created PurchaseHistory class can’t freely entry knowledge saved in occasion variables of its unique PurchaseProcess class.
Resolution
So how will we go about fixing this pickle? The reply is Dependency Injection (DI) – the beneficial manner of sharing the state between steps in Cucumber-JVM.
If you happen to’re unfamiliar with this idea, then go by Wikipedia’s definition:
“In software engineering, dependency injection is a design pattern through which an object or function receives different objects or features that it depends upon. A type of inversion of control, dependency injection goals to separate the concerns of establishing and utilizing objects, resulting in loosely coupled packages.[1][2][3] The sample ensures that an object or perform which needs to make use of a given service shouldn’t need to know learn how to assemble these companies. As an alternative, the receiving ‘client‘ (object or perform) is supplied with its dependencies by exterior code (an ‘injector’), which it’s not conscious of.” [1]
Within the context of Cucumber, to make use of dependency injection is to “inject a typical object in every class with steps. An object that’s recreated each time a brand new state of affairs is executed.” [2]
Thus Comes PicoContainer
JVM implementation of Cucumber helps a number of DI modules: PicoContainer, Spring, Guice, OpenEJB, Weld, and Needle. PicoContainer is beneficial in case your software doesn’t already use one other one. [3]
The primary advantages of utilizing PicoContainer over different DI modules steam from it being tiny and easy:
- It doesn’t require any configuration
- It doesn’t require your courses to make use of any APIs
- It solely has a single function – it instantiates objects [4]
Implementation
To make use of PicoContainer with Maven, add the next dependency to your pom.xml:
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-picocontainer</artifactId>
<model>7.8.1</model>
<scope>take a look at</scope>
</dependency>
If utilizing Gradle, add:
compile group: 'io.cucumber', identify: 'cucumber-picocontainer', model: ‚7.8.1’
To your construct.gradle file.
Now let’s return to our instance code. The implementation of DI utilizing PicoContainer is fairly simple. First, we’ve to create a container class that may maintain the widespread knowledge:
Then we have to add a constructor injection to implement the PurchaseProcess and PurchaseHistory courses. This boils all the way down to the next:
- making a reference variable of the Container class within the present step courses
- initializing the reference variable by a constructor
As soon as the adjustments above are utilized, the instance ought to appear like this:
Conclusion
PicoContainer is light-weight and straightforward to implement. It additionally requires minimal adjustments to your present code, serving to to maintain it lean and readable. These qualities make it an ideal match for any Cucumber-JVM venture since sharing take a look at context between courses is a query of ‘when’ and never ‘if’ in primarily any take a look at suite that may develop past a number of situations.
