In the previous tutorial, I have explained the Data Driven Tests in Serenity where test data are defined in Tests. In this tutorial, I will explain the Data Driven tests in Serenity where we will get the test data from CSV file.
Serenity lets us perform data-driven testing using test data in a CSV file. We store our test data in a CSV file (by default with columns separated by commas), with the first column acting as a header.
We need to create a test class containing properties that match the columns in the test data, as you did for the data-driven test in the previous example. The test class will typically contain one or more tests that use these properties as parameters to the test step or Page Object methods.
Here, we need to keep in mind that as the tests are parameterized , we need to use the Parameterized test runner to perform data-driven tests.
@UseTestDataFrom annotation is used to indicate where to find the CSV file (this can either be a file on the classpath or a relative or absolute file path – putting the data set on the class path (e.g. in src/test/resources) makes the tests more portable).
Now, create the Test Class which contains the tests, SerenityRunner as well as the path to the CSV test data file.
As you can see, I have mentioned 3 variables in CSV file – USERNAME, PASSWORD and ERRORMESSAGE. I have declared 3 private variable – username , password and errorMessage that match the columns in the test data file.
The test runner creates a new instance of this class for each row of data in the CSV file, assigning the properties with corresponding values in the test data
@RunWith(SerenityParameterizedRunner.class)
@UseTestDataFrom(value = "testdata/credentials.csv")
public class LoginTests {
private String username;
private String password;
private String errorMessage;
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
@Managed
WebDriver driver;
@Steps
StepLoginPage loginPage;
@Test
@Title("Login to application should be unsuccessful with error message")
public void unsucessfulLogin() throws InterruptedException {
// Given
loginPage.open();
// When
loginPage.inputUserName(username);
loginPage.inputPassword(password);
loginPage.clickLogin();
// Then
String actualErrorMessage = loginPage.errorMessage();
Assert.assertEquals(errorMessage, actualErrorMessage);
}
}
This test can be executed by JUnit as well as from command line
JUnit – Right click on the Test, select Run As and then select JUnit Test.
The Test status can be seen as shown below
To run the tests using command line, use the below command
mvn clean verify
This will execute the tests and will generate the Test Execution Report as shown below.
The reports are generated as shown in below image.
Index.html
Serenity Summary Report
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
In the previous tutorial, I have explained the Integration of Serenity with JUnit4. In this tutorial, I will explain Data Driven Tests in Serenity with JUnit. Serenity provides features to support Data Driven tests. Refer this tutorial to know how to setup a Serenity project with JUnit4.
There is a parameterized Test Runner to perform data driven tests in JUnit4.
@RunWith(SerenityParameterizedRunner.class)
This runner is very similar to the JUnit Parameterized test runner. Here, @TestData annotation is used to provide test data to the test, and you can use all of the other Serenity annotations like (@Managed, @Steps, @Title and so on). This test runner will also generate proper serenity reports for the executed tests.
Below is an example of data-driven serenity test. In this test, I have created a Test Class (LoginTests) and Step Class (StepLoginPage). I am passing a set of incorrect credentails to the Login page and will verify the error message.
Here is the code for LoginPageDefinitions.
@RunWith(SerenityParameterizedRunner.class)
public class LoginTests {
@TestData
public static Collection<Object[]> testData() {
return Arrays.asList(new Object[][] {
{ "Admin12", "admin123" },
{ "abc", "abc12" },
{ "_Admin1", "admin123_" },
{ " ", " " }
});
}
private String userName = "";
private String passWord = "";
public LoginPageDefinitions(String userName, String passWord) {
this.userName = userName;
this.passWord = passWord;
}
@Managed
WebDriver driver;
@Steps
StepLoginPage loginPage;
@Test
@Title("Login to application should be unsuccessful with error message")
public void unsucessfulLogin() throws InterruptedException {
// Given
loginPage.open();
// When
loginPage.inputUserName(userName);
loginPage.inputPassword(passWord);
loginPage.clickLogin();
// Then
String actualErrorMessage = loginPage.errorMessage();
Assert.assertEquals("Invalid credentials", actualErrorMessage);
}
}
@TestData is the annotation for a method which provides parameters to be injected into the test class constructor by Parameterized. testData() method returns an array list of objects as shown above.
The test data is injected into member variables – userName and passWord. These values are represented as instance variables in the test class, and instantiated via the constructor. These member variables are used in the test.
@Managed is annotated as a WebDriver field that is managed by the Test Runner. The Serenity Test Runner will instantiate this WebDriver before the tests start, and close it once they have all finished.
In the previous tutorial, I have explained the generation of Serenity Report. In this tutorial, I will explain how to generate the Serenity Report in Customized path.
You can see that the reports are generated at the above specified path.
Another way is to add outputDirectory detail in serenity.properties file.
serenity.project.name = Serenity and Cucumber Report Demo
serenity.outputDirectory=C:\\Users\\Reports\\SerenityReports\\SummaryReport
How to create a Serenity Report for specified tests?
Suppose we want to run a set of tests, not complete test suite and we want to get the report containing the details of only executed tests,in short a very specific report. This can be achieved by using @tags.
Suppose you mark each test suite with a tag @E2E. So to run only the tests for the @E2E, you could run the following:
mvn clean verify -Dtags="E2E"
You will also need to configure the serenity-maven-plugin to use the tags you provide at the command line:
In this tutorial, I will explain the Integration of Serenity BDD with Rest Assured for the testing of RestFul API.
What is Serenity BDD?
Serenity BDD is an open source library that aims to make the idea of living documentation a reality.
What is Rest Assured?
Rest Assured is one of the most powerful libraries for testing RESTful API using Java language. Rest-Assured is a Java-based library that is used to test RESTful Web Services. This library behaves like a headless Client to access REST web services. Rest-Assured library also provides the ability to validate the HTTP Responses received from the server.
Pre-Requisite
Java 11 installed
Maven installed
Eclipse or IntelliJ installed
This framework consists of:
Java 11
Maven – 3.8.1
Serenity – 2.6.0
Serenity Rest Assured – 2.6.0
Rest Assured – 4.4.0
JUnit – 4.13.2
Maven Surefire Plugin – 3.0.0-M5
Maven Failsafe Plugin – 3.0.0-M5
Maven Compiler Plugin – 3.8.1
Implementation Steps
Update Properties section in Maven pom.xml
Add repositories and pluginRepository to Maven pom.xml
Add Serenity, Serenity Rest Assured and JUnit dependencies to POM.xml
Update Build Section of pom.xml
Create the Test Code under src/java/test
Create serenity.properties file in the root of the project
Run the tests through commandline which generates Serenity Reports.
Project Structure
Step 1 – Update Properties section in Maven pom.xml
There are 2 ways to create the same test. One approach is to have a Definition file which contains all the test code as shown below.
@Test
public void verifyValidUser() {
response = SerenityRest.given()
.contentType("application/json")
.header("Content-Type", "application/json")
.when()
.get(URL + 1);
SerenityRest.restAssuredThat(response -> response.statusCode(200)
.body("data.id", equalTo(1))
.body("data.employee_salary", equalTo(320800))
.body("data.employee_name", equalTo("Tiger Nixon"))
.body("data.employee_age", equalTo(61)).and()
.body("message", equalTo("Successfully! Record has been fetched.")));
}
@Test
public void verifyInvalidUser() {
response = SerenityRest.given()
.contentType("application/json")
.header("Content-Type", "application/json")
.when()
.get(URL + 99999);
SerenityRest.restAssuredThat(response -> response.statusCode(200)
.body("status", equalTo("success"))
.body("message", equalTo("Successfully! Record has been fetched.")));
}
Another approach is that all tests are split into reusable blocks called “steps”. The main principle of the BDD approach is that we are trying to keep complexity to a high level human readable level. First of all, let’s create a separate package to keep our steps. It is always better to keep them separate as it shows which classes contain reusable components. It is better to make steps smaller. So let’s make separate reusable steps from our tests:
public class EmployeeSteps {
private static final String URL = "http://dummy.restapiexample.com/api/v1/employee/";
public Response response;
@Step
public void sendValidUser(int id) {
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json")
.when().get(URL + id);
}
@Step
public void verifyStatusCode(int expectedStatusCode) {
SerenityRest.restAssuredThat(response -> response.statusCode(expectedStatusCode));
}
@Step
public void verifyId(int expectedId) {
SerenityRest.restAssuredThat(response -> response.body("data.id", equalTo(expectedId)));
}
@Step
public void verifyName(String expectedName) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_name", equalTo(expectedName)));
}
@Step
public void verifySalary(int expectedSalary) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_salary", equalTo(expectedSalary)));
}
@Step
public void verifyAge(int expectedAge) {
SerenityRest.restAssuredThat(response -> response.body("data.employee_age", equalTo(expectedAge)));
}
@Step
public void verifyMessage(String expectedMessage) {
SerenityRest.restAssuredThat(response -> response.body("message", equalTo(expectedMessage)));
}
@Step
public void verifyBodyStatus(String expectedStatus) {
SerenityRest.restAssuredThat(response -> response.body("status", equalTo(expectedStatus)));
}
}
Now our steps are ready. Let’s refactor the main class with our tests:
@RunWith(SerenityRunner.class)
public class EmployeesTest {
private static final String URL = "http://dummy.restapiexample.com/api/v1/employee/";
public Response response;
@Steps
EmployeeSteps employeeSteps;
@Test
public void verifyValidUser() {
employeeSteps.sendValidUser(1);
employeeSteps.verifyStatusCode(200);
employeeSteps.verifyId(1);
employeeSteps.verifyName("Tiger Nixon");
employeeSteps.verifyAge(61);
employeeSteps.verifySalary(320800);
employeeSteps.verifyMessage("Successfully! Record has been fetched.");
}
@Test
public void verifyInvalidUser() {
employeeSteps.sendValidUser(9999);
employeeSteps.verifyStatusCode(200);
employeeSteps.verifyBodyStatus("success");
employeeSteps.verifyMessage("Successfully! Record has been fetched.");
}
}
One more important thing we added is the “@RunWith(SerenityRunner.class)” annotation on top of the class. As we have now organized our structure to meet some basic Serenity principles, we are ready to run the test using Serenity. This time (after we added the mentioned annotation) these tests will be run using the “SerenityRunner”. For that we can use exactly the same command to run our tests:
mvn clean verify
In the console you should find printed messages for tests start. At the same time under target directory you can find the HTML generated report we were talking about before:
You can open the report in any browser:
If you click on any test you should see a detailed description of the test steps:
One of the most important features of the Serenity and REST Assured integration is that by using detailed reporting, you can easily validate all requests and response details even if you are not adding any logs inside tests. Like the example above, for each executed REST request you can click the button “REST Query” and get a detailed request and response description:
There is another very useful Serenity Report – Serenity Symmary.html
As you can see, Serenity and REST Assured provide you with a wonderful combination. REST Assured keeps API testing clean and easy to maintain, while Serenity gives you outstanding test reporting and flexibility in running and grouping your tests inside a test suite.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
In this tutorial, I will explain about Manual Tests in Serenity JUnit5.
You can annotate @Test not @Steps as @Manual.
In contrast to Junit4 a test method annotated with @Manual will actually be executed. This allows to further specify the example using @Step methods and show them the report.
Below is an example where tests are annotated with @Manual with description.
@SerenityTest
public class LoginTests {
@Managed
WebDriver driver;
@Steps
StepLoginPage loginPage;
@Steps
StepDashboardPage dashPage;
@Steps
StepForgetPasswordPage forgetpasswordPage;
@Test
@Title("Login to application should be successful")
public void sucessfulLogin() {
// Given
loginPage.open();
// When
loginPage.inputUserName("Admin");
loginPage.inputPassword("admin123");
loginPage.clickLogin();
// Then
dashPage.loginVerify();
}
@Test
@Title("Login to application should be unsuccessful with error message")
public void unsucessfulLogin() throws InterruptedException {
// Given
loginPage.open();
// When
loginPage.inputUserName("abc");
loginPage.inputPassword("abc12");
loginPage.clickLogin();
// Then
String actualErrorMessage = loginPage.errorMessage();
assertEquals("Invalid credentials", actualErrorMessage);
}
@Test
@Manual
void manualDefault() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.SUCCESS)
void manualSuccess() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.COMPROMISED)
void manualCompromised() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.ERROR)
void manualError() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.ERROR, reason = "A reason for the error")
void manualErrorWithReason() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.FAILURE)
void manualFailure() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.IGNORED)
void manualIgnored() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.PENDING)
void manualPending() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.SKIPPED)
void manualSkipped() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.UNDEFINED)
void manualUndefined() {
loginPage.manualStep();
}
@Test
@Manual(result = TestResult.UNSUCCESSFUL)
void manualUnsuccessful() {
loginPage.manualStep();
}
}
StepLoginPage.java
public class StepLoginPage extends PageObject {
@FindBy(name = "txtUsername")
WebElementFacade username;
@FindBy(name = "txtPassword")
WebElementFacade password;
@FindBy(name = "Submit")
WebElementFacade submitButton;
@FindBy(id = "spanMessage")
WebElementFacade errorMessage;
@FindBy(id = "forgotPasswordLink")
WebElementFacade linkText;
@Step("Enter Username")
public void inputUserName(String userName) {
username.sendKeys((userName));
}
@Step("Enter Password")
public void inputPassword(String passWord) {
password.sendKeys((passWord));
}
@Step("Click Submit Button")
public void clickLogin() {
submitButton.click();
}
@Step("Error Message on unsuccessful login")
public String errorMessage() {
String actualErrorMessage = errorMessage.getText();
System.out.println("Actual Error Message :" + actualErrorMessage);
return actualErrorMessage;
}
@Step("Manual Test Step")
public void manualStep() {
System.out.println("Verify various status of manual step");
}
}
StepDashboardPage.java
public class StepDashboardPage extends PageObject {
@FindBy(id = "welcome")
WebElementFacade dashboardText;
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = dashboardText.getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
Execute these tests by using the below command in commandline.
mvn clean verify
There are two automated tests and rest all are Manual tests. We have Manual Test marked as Default, SUCCESS, COMPROMISED, ERROR, FAILURE, IGNORED, PENDING, SKIPPED, UNDEFINED and UNSUCCESSFUL.
The execution status looks like as shown below.
The reports are generated under /target/site/serenity. There are 2 types of Reports are generated – index.html and serenity-summary.html. To know how to generate Serenity Reports, please refer tutorials for index.html and serenity-summary.html.
By default, @manual scenarios are marked as pending in the Serenity reports.
All scenarios highlighted by blue color are Pending ones whereas pink color are Broken ones.
Serenity-Summary.html
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
In the previous tutorial, I have explained about the Integration of Serenity BDD with JUnit4. In this tutorial, I’ll explain the Integration of Serenity BDD with JUnit5.
Pre-Requisite
Java 11 installed
Maven installed
Eclipse or IntelliJ installed
This framework consists of:
Java 11
Maven – 3.8.1
Serenity – 2.6.0
Serenity JUnit5– 1.6.0
JUnit Jupiter – 5.8.0
JUnit Vintage – 5.8.0
Maven Surefire Plugin – 3.0.0-M5
Maven Failsafe Plugin – 3.0.0-M5
Maven Compiler Plugin – 3.8.1
Implementation Steps
Update Properties section in Maven pom.xml
Add repositories and pluginRepository to Maven pom.xml
Add Serenity, Serenity Cucumber and JUnit dependencies to POM.xml
Update Build Section of pom.xml
Create test code under src/test/java folder
Create serenity.conf file under src/test/resources
Create serenity.properties file in the root of the project
Run the tests through commandline which generates Serenity Report
Structure of Project
Step 1 – Update Properties section in Maven pom.xml
Step 5 – Create test code under src/test/java folder
LoginPageDefinitions.java
@SerenityTest
public class LoginPageDefinitions {
@Managed
WebDriver driver;
@Steps
StepLoginPage loginPage;
@Steps
StepDashboardPage dashPage;
@Steps
StepForgetPasswordPage forgetpasswordPage;
@Test
@Title("Login to application should be successful")
public void sucessfulLogin() {
// Given
loginPage.open();
// When
loginPage.inputUserName("Admin");
loginPage.inputPassword("admin123");
loginPage.clickLogin();
// Then
dashPage.loginVerify();
}
@Test
@Ignore
@Title("Login to application should be unsuccessful with error message")
public void unsucessfulLogin() throws InterruptedException {
// Given
loginPage.open();
// When
loginPage.inputUserName("abc");
loginPage.inputPassword("abc12");
loginPage.clickLogin();
// Then
String actualErrorMessage = loginPage.errorMessage();
Assert.assertEquals("Invalid credentials", actualErrorMessage);
}
@Test
@Title("Verify Forgot your password link")
public void clickForgetPasswordLink() {
// Given
loginPage.open();
// When
loginPage.clickForgetPasswordLink();
// Then
Assert.assertTrue(forgetpasswordPage.ForgetPasswordPage());
}
}
To run a JUnit5 test with Serenity BDD, simply add the annotation @net.serenitybdd.junit5.SerenityTest (instead of @org.junit.runner.RunWith(net.serenitybdd.junit.runners.SerenityRunner.class) for JUnit4.
@SerenityTest
@Test is imported from package:-
import org.junit.jupiter.api.Test;
There are multiple ways to identify a web element on web page in Serenity. 2 most common way is to use @FindBy or $(By.)
StepDashboardPage.java
public class StepDashboardPage extends PageObject {
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = $(By.id("welcome")).getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
If the same code as shown above are written with the help of @FindBy, it is shown below.
public class StepDashboardPage extends PageObject {
@FindBy(id = "welcome")
WebElementFacade dashboardText;
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = dashboardText.getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
This is my preferred way of writing the code as I have ass. But you can use any one of it.
StepForgetPasswordPage.java
public class StepForgetPasswordPage extends PageObject {
@FindBy(id = "btnSearchValues")
WebElementFacade resetButton;
@Step("Verify Forget Password Page ")
public boolean ForgetPasswordPage() {
Boolean resetPasswordButton = resetButton.isDisplayed();
return resetPasswordButton;
}
}
The WebElementFacade class contains convenient fluent API for dealing with web elements, providing some commonly-used extra features that are not provided out-of-the-box by the WebDriver API. WebElementFacades are largely interchangeable with WebElements: you just declare a variable of type WebElementFacade instead of type WebElement
The @Steps annotation marks a Serenity step library. Create the test following the Given/When/Then pattern and using step methods from the step library. The @Title annotation lets you provide your own title for this test in the test reports. Serenity @Title is considered for the Serenity report.Consistently with Junit4 the @Title annotation does not influence the name in the Junit report.
The JUnit Serenity integration provides some special support for Serenity Page Objects. In particular, Serenity will automatically instantiate any PageObject fields in your JUnit test.
Junit5 @Disabled annotation can be used on test and step methods(same as @Ignore in JUnit4).
Step 6 – Create serenity.conf file under src/test/resources
Serenity.conf file is used to specify various features like type of webdriver used, various test environments, run test in headless mode and many more options.
In the previous tutorial, I have explained theSerenity BDD with Cucumber for Web Application using Junit4. In this tutorial, I will explain the same Test Framework using Serenity, Cucumber6 and JUnit5. This tutorial gives a clear picture for the initial setup of a BDD Framework .
What is JUnit5?
JUnit 5 is composed of several different modules from three different sub-projects.
The JUnit Platform serves as a foundation for launching testing frameworks on the JVM. It also defines the TestEngine API for developing a testing framework that runs on the platform.
JUnit Jupiter is the combination of the new programming model and extension model for writing tests and extensions in JUnit 5. The Jupiter sub-project provides a TestEngine for running Jupiter based tests on the platform.
JUnit Vintage provides a TestEngine for running JUnit 3 and JUnit 4 based tests on the platform. It requires JUnit 4.12 or later to be present on the class/module path.
JUnit5 is not completely integrated with Serenity with Cucumber. So, it is advisable to use jupiter-vintage-engine for the Cucumber TestRunner classes.
This framework consists of:-
Serenity – 2.6.0
Serenity Cucumber6 – 2.6.0
Serenity Junit5 – 1.6.0
JUnit Jupiter – 5.8.0
JUnit Vintage – 5.8.0
Java 11
Maven – 3.8.1
Selenium – 3.141.59
Maven Compiler Plugin – 3.8.1
Maven Surefire Plugin – 3.0.0-M5
Maven FailSafe Plugin – 3.0.0-M5
Implementation Steps
Download and Install Java on system
Download and setup Eclipse IDE on system
Setup Maven and create a new Maven Project
Update Properties section in Maven pom.xml
Add repositories and pluginRepository to Maven pom.xml
Add Serenity, Serenity Cucumber and JUnit5 dependencies to POM.xml
Update Build Section of pom.xml
Create a feature file under src/test/resources
Create the Step Definition class or Glue Code
Create a Serenity-Cucumber Runner class
Create serenity.conf file under src/test/resources
Create serenity.properties file in the root of the project
Run the tests from Command Line
Serenity Report Generation – Index.html and Serenity-Summary.html
The Eclipse IDE (integrated development environment) provides strong support for Java developer which is needed to write Java code. Click here to know How to install Eclipse.
Step 3 – Setup Maven and create a new Maven Project
Step 8 – Create a feature file under src/test/resources
The purpose of the Feature keyword is to provide a high-level description of a software feature, and to group related scenarios. To know more about Feature file, please refer this tutorial.
Feature: Login to HRM
@ValidCredentials
Scenario: Login with valid credentials
Given User is on Home page
When User enters username as "Admin"
And User enters password as "admin123"
Then User should be able to login successfully
@InValidCredentials
Scenario Outline: Login with invalid credentials
Given User is on Home page
When User enters username as '<username>'
And User enters password as '<password>'
Then User should be able to see error message '<errorMessage>'
Examples:
|username |password |errorMessage |
|admin |admin |Invalid credentials |
| |admin123 |Username cannot be empty |
|Admin | |Password cannot be empty |
| | |Username can be empty |
Step 9 – Create the Step Definition class or Glue Code
A Step Definition is a Java method with an expression that links it to one or more Gherkin steps. When Cucumber executes a Gherkin step in a scenario, it will look for a matching step definition to execute. You can have all of your step definitions in one file, or in multiple files.
LoginPageDefinitions.java
public class LoginPageDefinitions {
@Steps
StepLoginPage loginPage;
@Steps
StepDashboardPage dashPage;
@Steps
StepForgetPasswordPage forgetpasswordPage;
@Given("User is on Home page")
public void openApplication() {
loginPage.open();
}
@When("User enters username as {string}")
public void enterUsername(String userName) {
loginPage.inputUserName(userName);
}
@When("User enters password as {string}")
public void enterPassword(String passWord) {
loginPage.inputPassword(passWord);
loginPage.clickLogin();
}
@Then("User should be able to login successfully")
public void clickOnLoginButton() {
dashPage.loginVerify();
}
@Then("User should be able to see error message {string}")
public void unsucessfulLogin(String expectedErrorMessage) {
String actualErrorMessage = loginPage.errorMessage();
assertEquals(expectedErrorMessage, actualErrorMessage);
}
}
Assertions in JUnit-Vintage Engine are imported from below package:-
import static org.junit.jupiter.api.Assertions.*;
DashboardPageDefinitions.java
public class DashboardPageDefinitions {
@Steps
StepDashboardPage dashPage;
@Step
public void verifyAdminLogin() {
dashPage.loginVerify();
}
}
The corresponding Test Step classes are – StepLoginPage.java and StepDashboardPage.java.
There are multiple ways to identify a web element on the web page – one of the way is to use @FindBy or $(By.).
I prefer to use @FindBy as I need not to find same element multiple times. Using @FindBy , I have identified a web element and define a WebElementFacacde for the same which is reusable.
StepLoginPage.java
public class StepLoginPage extends PageObject {
@FindBy(name = "txtUsername")
WebElementFacade username;
@FindBy(name = "txtPassword")
WebElementFacade password;
@FindBy(name = "Submit")
WebElementFacade submitButton;
@FindBy(id = "spanMessage")
WebElementFacade errorMessage;
@Step("Enter Username")
public void inputUserName(String userName) {
username.sendKeys((userName));
}
@Step("Enter Password")
public void inputPassword(String passWord) {
password.sendKeys((passWord));
}
@Step("Click Submit Button")
public void clickLogin() {
submitButton.click();
}
@Step("Error Message on unsuccessful login")
public String errorMessage() {
String actualErrorMessage = errorMessage.getText();
return actualErrorMessage;
}
}
StepDashboardPage.java
public class StepDashboardPage extends PageObject {
@FindBy(id = "welcome")
WebElementFacade dashboardText;
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = dashboardText.getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
Step 10 – Create a Serenity-Cucumber Runner class
Cucumber runs the feature files via JUnit, and needs a dedicated test runner class to actually run the feature files. When you run the tests with Serenity, you use the CucumberWithSerenity test runner. You also need to use the @CucumberOptions class to provide the root directory where the feature files can be found.
import org.junit.runner.RunWith;
import io.cucumber.junit.CucumberOptions;
import net.serenitybdd.cucumber.CucumberWithSerenity;
@RunWith(CucumberWithSerenity.class)
@CucumberOptions(plugin = {}, features = "src/test/resources/features/LoginPage.feature", glue = "com.example.SerenityCucumberJunit5Demo.definitions")
public class SerenityRunnerTest {
}
Step 11 – Create serenity.conf file under src/test/resources
The serenity configuration file is used to configure the drivers so the test cases can run successfully. This file contains an operating system specific binary. The binary file sits between your test and the browser. It acts as an intermediary, an interface between your tests and the browser you are using.
You can also configure the webdriver.base.url property for different environements in the serenity.conf configuration file.
webdriver {
driver = firefox
}
#
# Define drivers for different platforms. Serenity will automatically pick the correct driver for the current platform
#
environments {
default {
webdriver.base.url = "https://opensource-demo.orangehrmlive.com/"
}
dev {
webdriver.base.url = "https://opensource-demo.orangehrmlive.com/dev"
}
staging {
webdriver.base.url = "https://opensource-demo.orangehrmlive.com/staging"
}
prod {
webdriver.base.url = "https://opensource-demo.orangehrmlive.com/prod"
}
}
Step 11 – Create serenity.properties file in the root of the project
serenity.project.name = Serenity and Cucumber6 and JUnit5 Demo
Step 12 – Run the tests from Command Line
Open commandline and go to the location where pom.xml of the project is present and type the below command.
mvn clean verify
Step 13 – Serenity Report Generation
Above it shows the execution status. There are 5 passed and 1 failed test case.
There are multiple type of reports are generated. We are interested in index.html and serenity-summary.html. To know more about Serenity Reports, please refer tutorials for Index.html and Serenity-Summary.html.
index.html
2. serenity-summary.html
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
In the previous tutorial, I have explained Serenity BDD with Cucumber for Web Application. In this tutorial, I will explain about the Integration of Serenity with JUnit4. This tutorial gives an idea how to setup a new project where we like to use Serenity as BDD Framework and JUnit as Testing framework.
Pre-Requisite
Java 11 installed
Maven installed
Eclipse or IntelliJ installed
This framework consists of:
Java 11
Maven – 3.8.1
Serenity – 2.6.0
Serenity Maven – 2.6.0
JUnit – 4.13.2
Maven Surefire Plugin – 3.0.0-M5
Maven Failsafe Plugin – 3.0.0-M5
Maven Comiler Plugin – 3.8.1
Implementation Steps
Update Properties section in Maven pom.xml
Add repositories and pluginRepository to Maven pom.xml
Add Serenity and JUnit dependencies to POM.xml
Update Build Section of pom.xml
Create test code under src/test/java folder
Create serenity.conf file under src/test/resources
Create serenity.properties file in the root of the project
Run the tests through commandline which generates Serenity Report
Project Structure
Step 1 – Update Properties section in Maven pom.xml
Step 5 – Create test code under src/test/java folder
@RunWith(SerenityRunner.class)
public class LoginPageDefinitions {
@Managed
WebDriver driver;
@Steps
StepLoginPage loginPage;
@Steps
StepDashboardPage dashPage;
@Steps
StepForgetPasswordPage forgetpasswordPage;
@Test
@Title("Login to application should be successful")
public void sucessfulLogin() {
// Given
loginPage.open();
// When
loginPage.inputUserName("Admin");
loginPage.inputPassword("admin123");
loginPage.clickLogin();
// Then
dashPage.loginVerify();
}
@Test
@Title("Login to application should be unsuccessful with error message")
public void unsucessfulLogin() throws InterruptedException {
// Given
loginPage.open();
// When
loginPage.inputUserName("abc");
loginPage.inputPassword("abc12");
loginPage.clickLogin();
// Then
String actualErrorMessage = loginPage.errorMessage();
Assert.assertEquals("Invalid credentials", actualErrorMessage);
}
@Test
@Title("Verify Forgot your password link")
public void clickForgetPasswordLink() {
// Given
loginPage.open();
// When
loginPage.clickForgetPasswordLink();
// Then
Assert.assertTrue(forgetpasswordPage.ForgetPasswordPage());
}
}
The JUnit test can be run using the Serenity test runner.
The @Steps annotation marks a Serenity step library.
Create the test following the Given/When/Then pattern and using step methods from the step library.
The @Title annotation lets you provide your own title for this test in the test reports.
public class StepLoginPage extends PageObject {
@FindBy(name = "txtUsername")
WebElementFacade username;
@FindBy(name = "txtPassword")
WebElementFacade password;
@FindBy(name = "Submit")
WebElementFacade submitButton;
@FindBy(id = "spanMessage")
WebElementFacade errorMessage;
@FindBy(id = "forgotPasswordLink")
WebElementFacade linkText;
@Step("Enter Username")
public void inputUserName(String userName) {
$(By.name("txtUsername")).sendKeys((userName));
}
@Step("Enter Username")
public void inputUserName(String userName) {
username.sendKeys((userName));
}
@Step("Enter Password")
public void inputPassword(String passWord) {
password.sendKeys((passWord));
}
@Step("Click Submit Button")
public void clickLogin() {
submitButton.click();
}
@Step("Error Message on unsuccessful login")
public String errorMessage() {
String actualErrorMessage = errorMessage.getText();
return actualErrorMessage;
}
@Step("Click Forget Password Link")
public void clickForgetPasswordLink() {
linkText.click();
System.out.println("Clicked on Forgot Password Link");
}
}
StepDashBoardPage.java
public class StepDashboardPage extends PageObject {
@FindBy(id = "welcome")
WebElementFacade dashboardText;
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = dashboardText.getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
StepForgetPasswordPage.java
public class StepForgetPasswordPage extends PageObject {
@FindBy(id = "forgotPasswordLink")
WebElementFacade forgetLink;
@Step("Verify Forget Password Page ")
public boolean ForgetPasswordPage() {
Boolean resetPasswordButton = forgetLink.isDisplayed();
return resetPasswordButton;
}
}
The JUnit Serenity integration provides some special support for Serenity Page Objects. In particular, Serenity will automatically instantiate any PageObject fields in your JUnit test. When you declare a field of type StepLoginPage in the test, Serenity will instantiate it for you. The page is automatically instantiated and ready to be used.
@Managed
WebDriver driver;
@Managed declares a WebDriver instance that will be managed by Serenity. The WebDriver instance will be initialized automatically.
The driver parameter lets you define what WebDriver driver you want to run these tests in. Possible values include firefox, chrome, iexplorer, phantomjs, appium, safari, edge and htmlunit . Default value of driver is Firefox.
@Managed(driver="chrome")
Step 6 – Create serenity.conf file under src/test/resources
Serenity.conf file is used to specify various features like type of webdriver used, various test environments, run test in headless mode and many more options.
Step 7 – Create serenity.properties file in the root of the project
serenity.project.name = Serenity and Junit Demo
Step 8 – Run the tests through commandline which generates Serenity Report
Open commandline and go to the location where pom.xml of the project is present and type the below command.
mvn clean verify
Below is the execution status.
There are 2 type of reports are generated.
Index.html
2. Emailable Report (Serenity-Summary.html)
These reports are present under /target/site/serenity.
Skipping the tests
In Serenity, you use the @Pending annotation, either for a test or for a @Step-annotated method, to indicate that the scenario is still being implemented and that the results are not available yet. These tests appear as ‘Pending’ (shown in blue) in the test reports.
@Test
@Pending
@Title("Verify Forgot your password link")
public void clickForgetPasswordLink() {
// Given
loginPage.open();
// When
loginPage.clickForgetPasswordLink();
// Then
Assert.assertTrue(forgetpasswordPage.ForgetPasswordPage());
}
Tests marked with @Ignore will appear as ‘Ignored’ (from JUnit) appears as grey in the test reports.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
The Eclipse IDE (integrated development environment) provides strong support for Java developers. Click here to know How to install Eclipse.
Step 3 – Setup Gradle
To build a test framework, we need to add several dependencies to the project. This can be achieved by any build Tool. I have used Gradle Build Tool. Click here to know How to install Gradle. Click here to know How to create a Gradle Java project. Below is the structure of Gradle project.
Step 4 – Update repositories, plugin and dependencies to the Gradle project
Step 5 – Create a feature file under src/test/resources
A Feature File is an entry point to the Cucumber tests. This is a file where you will describe your tests in Descriptive language (Like English). A feature file can contain a scenario or can contain many scenarios in a single feature file. Feature file Below is an example of Feature file.
Feature: Employee Details
@GetValidUserDetails
Scenario Outline: Send a Request to get valid user details
Given I send a request to the URL <id> to get user details
Then the response will return statuscode <status> and id <id> and salary <employee_salary> and name '<employee_name>' and age <employee_age> and message '<message>'
Examples:
|id |status |employee_salary|employee_name |employee_age |message |
|1 |200 |320800 |Tiger Nixon |61 |Successfully! Record has been fetched. |
@GetInvalidUserDetails
Scenario Outline: Send a Request to get invalid user details
Given I send a request to the URL <id> to get user details
Then the response will return statuscode <statusCode> and status '<statusMessage>' and and message '<message>'
Examples:
|id |statusCode |statusMessage |message |
|9999 |200 |success |Successfully! Record has been fetched. |
Step 6 – Create the Step Definition class or Glue Code for the Test Scenario
Steps definition file stores the mapping between each step of the test scenario defined in the feature file with a code of function to be executed. So, now when Cucumber executes a step of the scenario mentioned in the feature file, it scans the step definition file and figures out which function is to be called.
public class EmployeeDefinitions {
private static final String URL = "http://dummy.restapiexample.com/api/v1/employee/";
public Response response;
@Given("I send a request to the URL {int} to get user details")
public void sendRequest(int id) {
response = SerenityRest.given().contentType("application/json").header("Content-Type", "application/json")
.when().get(URL + id);
}
@Then("the response will return statuscode {int} and id {int} and salary {int} and name {string} and age {int} and message {string}")
public void verifyValidUser(int statusCode, int id, int salary, String name, int age, String message) {
SerenityRest.restAssuredThat(response -> response.statusCode(statusCode).and().body("data.id", equalTo(id))
.and().body("data.employee_salary", equalTo(salary)).and().body("data.employee_name", equalTo(name))
.and().body("data.employee_age", equalTo(age)).and().body("message", equalTo(message)));
}
@Then("the response will return statuscode {int} and status {string} and and message {string}")
public void verifyInalidUser(int statusCode, String statusMessage, String message) {
SerenityRest.restAssuredThat(response -> response.statusCode(statusCode).and()
.body("status", equalTo(statusMessage)).and().body("message", equalTo(message)));
}
}
Step 7 – Create a Serenity Cucumber Runner class
Cucumber runs the feature files via JUnit, and needs a dedicated test runner class to actually run the feature files. When you run the tests with Serenity, you use the CucumberWithSerenity test runner. You also need to use the @CucumberOptions class to provide the root directory where the feature files can be found.
import org.junit.runner.RunWith;
import io.cucumber.junit.CucumberOptions;
import net.serenitybdd.cucumber.CucumberWithSerenity;
@RunWith(CucumberWithSerenity.class)
@CucumberOptions(plugin = { "pretty" }, features = "lib/src/test/resources/features/Employee.feature", glue = {
"serenitygradlerestautomation.definitions" })
public class SerenityRunnerTest {
}
Step 8 – Create serenity.properties file in the root of the project
serenity.project.name = Serenity and Gradle Rest Assured Demo
Step 9 – Run the tests through commandline which generates Serenity Report
Open commandline and go to the location where gradle.build of the project is present and type the below command.
gradle test
The Serenity report is generated under /lib/target/site/serenity.
Index.html
Overall Test Results Section provide the details about all the Test Scenario, like time taken by each test step, status of each test step and soon.
In this report, you can see the request as well as response details in the report.
Step 10 – Generate Single Page HTML Report
As we have already mentioned the dependencies about single-page-report in build.gradle, we can generate an emailable serenity report which contains the summary of test execution.
gradle reports
Serenity Summary Report (single-page-report.html) is placed under lib\target\site\serenity.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
In this tutorial, I will explain creating a framework for the testing of Web Application in Cucumber BDD.
Pre-Requisite
Java 11 installed
Gradle installed
Eclipse or IntelliJ installed
This framework consists of:
Serenity – 2.6.0
Serenity Cucumber – 2.6.0
Java 11
JUnit – 4.13.2
Gradle – 7.2
Steps to setup Gradle Java Project for Web Application using Serenity , Cucumber6 and JUnit4
Download and Install Java on the system
Download and setup Eclipse IDE on the system
Setup Gradle on System and create a new Gradle Project
Update repositories, plugin and dependencies to the Gradle project
Create a feature file under src/test/resources
Create the Step Definition class or Glue Code for the Test Scenario
Create a Serenity Cucumber Runner class
Create serenity.conf file under src/test/resources
Create serenity.properties file in the root of the project
Run the tests through commandline which generates Serenity Report
Step 1- Download and Install Java
Cucumber and Rest-Assured need Java to be installed on the system to run the tests. Click here to know How to install Java.
Step 2 – Download and setup Eclipse IDE on system
The Eclipse IDE (integrated development environment) provides strong support for Java developers. Click here to know How to install Eclipse.
Step 3 – Setup Gradle
To build a test framework, we need to add several dependencies to the project. This can be achieved by any build Tool. I have used Gradle Build Tool. Click here to know How to install Gradle. Click here to know How to create a Gradle Java project. Below is the structure of Gradle project.
Step 4 – Update repositories, plugin and dependencies to the Gradle project
Step 5 – Create a feature file under src/test/resources
A Feature File is an entry point to the Cucumber tests. This is a file where you will describe your tests in Descriptive language (Like English). A feature file can contain a scenario or can contain many scenarios in a single feature file. Below is an example of Feature file.
Feature: Login to HRM
@ValidCredentials
Scenario: Login with valid credentials
Given User is on Home page
When User enters username as "Admin"
And User enters password as "admin123"
Then User should be able to login successfully
Step 6 – Create the Step Definition class or Glue Code for the Test Scenario
Steps definition file stores the mapping between each step of the test scenario defined in the feature file with a code of function to be executed. So, now when Cucumber executes a step of the scenario mentioned in the feature file, it scans the step definition file and figures out which function is to be called.
Create a StepDefinition class for LoginPage.feature
public class LoginPageDefinitions {
@Steps
StepLoginPage loginPage;
@Steps
StepDashboardPage dashPage;
@Steps
StepForgetPasswordPage forgetpasswordPage;
@Given("User is on Home page")
public void openApplication() {
loginPage.open();
System.out.println("Page is opened");
}
@When("User enters username as {string}")
public void enterUsername(String userName) {
System.out.println("Enter Username");
loginPage.inputUserName(userName);
}
@When("User enters password as {string}")
public void enterPassword(String passWord) {
loginPage.inputPassword(passWord);
loginPage.clickLogin();
}
@Then("User should be able to login successfully")
public void clickOnLoginButton() {
dashPage.loginVerify();
}
}
Serenity Step Libraries integrate smoothly into Cucumber Step Definition files; all you need to do is to annotate a step library variable with the @Steps annotation. Methods that represent a business task or action (inputUserName()), and that will appear in the reports as a separate step, are annotated with the @Step annotation. Here, I have created two StepClasses – StepLoginPage and StepDashboardPage
public class StepLoginPage extends PageObject {
@Step("Enter Username")
public void inputUserName(String userName) {
$(By.name("txtUsername")).sendKeys((userName));
}
@Step("Enter Password")
public void inputPassword(String passWord) {
$(By.name("txtPassword")).sendKeys((passWord));
}
@Step("Click Submit Button")
public void clickLogin() {
$(By.name("Submit")).click();
}
}
StepDashboardPage
public class StepDashboardPage extends PageObject {
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = $(By.id("welcome")).getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
Step 7 – Create a Serenity Cucumber Runner class
import org.junit.runner.RunWith;
import io.cucumber.junit.CucumberOptions;
import net.serenitybdd.cucumber.CucumberWithSerenity;
@RunWith(CucumberWithSerenity.class)
@CucumberOptions(plugin = {}, features = "lib/src/test/resources/features", glue = "serenitygradleautomation.definitions")
public class CucumberTestSuite {
}
Step 8 – Create serenity.conf file under src/test/resources
Serenity.conf file is used to specify various features like type of webdriver used, various test environments, run test in headless mode and many more options.
