Serenity Reports are living documentation that contains the meaningful report for each Test. It illustrated narrative reports that document and describe what your application does and how it works.
Serenity Report
How to embed Custom Data in Serenity Report
Serenity Reports are living documentation that contains meaningful report for each Test. It illustrated, narrative reports that document and describe what your application does and how it works.
This report can be organized by using features, stories, steps, scenarios/tests. Serenity Report shows the count of passed, failed, compromised, skipped, pending, broken, ignored, pending and manual test cases count and percentage. Serenity shows Over All Test Result, Requirements, Test Specifications & Test Result. It shows the details and overall time taken by each test step of a test case. It shows the details and overall timing took by each on all test case execution.
All the above features of Serenity Report make it a great Report. But sometimes, we want to embed data from a JSON or XML file in the Serenity Report.
Let me explain this with the help of an example. Data Driven tests are created in Serenity. We have test data mentioned in a .csv file and the test is reading the data from this file. When the report is generated, it does not show what all data are used by the Test. To overcome this situation, Serenity provides a feature which uses recordReportData(). and this can be used like this:
Path credentialsFile = Paths.get("src/test/resources/testdata/credentials.csv");
Serenity.recordReportData().withTitle(" User Credentials with Error Message")
.fromFile(credentialsFile);
If you have the contents of the report as a String, you can pass the String directly like this:
String testData = "...";
Serenity.recordReportData().withTitle("User")
.andContent(testData);
Let me explain this with the help of an example. Here, I have created a Data Driven Test which is using .csv file as an input file.
@RunWith(SerenityParameterizedRunner.class)
@UseTestDataFrom(value = "testdata/credentials.csv")
public class ParameterizedTestsUsingCSV {
private String userName;
private String passWord;
private String errorMessage;
@Managed(options = "--headless")
WebDriver driver;
@Steps
NavigateActions navigate;
@Steps
StepLoginPage loginPage;
@TestData(columnNames = "Username, Password, ErrorMessage")
@Test
@Title("Login to application with invalid credential generates error message")
public void unsuccessfulLogin() throws IOException {
// Given
navigate.toTheHomePage();
// When
loginPage.inputUserName(userName);
loginPage.inputPassword(passWord);
loginPage.clickLogin();
// Then
Serenity.reportThat("Passing invalid credentials generates error message",
() -> assertThat(loginPage.loginPageErrorMessage()).isEqualToIgnoringCase(errorMessage));
Path credentialsFile = Paths.get("src/test/resources/testdata/credentials.csv");
Serenity.recordReportData().withTitle(" User Credentials with Error Message").fromFile(credentialsFile);
}
}
Here, I have used recordReportData().withTitle() to provide a name to the button created and the data is retried using fromFile().
To locate the path of the file (credentials.csv), we have used – Path and Paths which are imported from:
import java.nio.file.Path;
import java.nio.file.Paths;
To get the complete detail about this code, refer this tutorial Data Driven Tests using CSV file in Serenity.
To generate Serenity Report, use the command like this:
mvn clean verify
The Serenity Reports are generated under target/site/serenity/Index.html.
Go to the Detailed Step Description part in Serenity Report. A button with the label “User Credentials with Error Message” will appear next to the step where you called this method:
If you click on this button, you will see your data:
Keep this in mind that this feature of Serenity is available from 1.9.16 onwards only.
Congratulation!! We have learnt a wonderful feature present in Serenity.
Serenity Emailable Report in Gradle
In this tutorial, I will generate an emailable Serenity Report for Gradle project. In the previous tutorial, I have explained the Generation of Serenity Emailable Report in Maven Project.
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 create Serenity Emailable Report
To setup a Gradle project for the testing of web application using Cucumber and JUnit4, please refer this tutorial (Step 1 to 3)
Update buildscript section of build.gradle file.
buildscript {
repositories {
mavenLocal()
jcenter()
}
dependencies {
classpath("net.serenity-bdd:serenity-gradle-plugin:2.4.24")
classpath("net.serenity-bdd:serenity-single-page-report:2.4.24")
}
}
Add serenity section in build.gradle.
serenity {
reports = ["single-page-html"]
}
The complete build.gradle for the project will look like as shown below
defaultTasks 'clean', 'test', 'aggregate'
repositories {
mavenLocal()
jcenter()
}
buildscript {
repositories {
mavenLocal()
jcenter()
}
dependencies {
classpath("net.serenity-bdd:serenity-gradle-plugin:2.4.24")
classpath("net.serenity-bdd:serenity-single-page-report:2.4.24")
}
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'net.serenity-bdd.aggregator'
sourceCompatibility = 11
targetCompatibility = 11
serenity {
reports = ["single-page-html"]
}
dependencies {
testImplementation 'net.serenity-bdd:serenity-core:2.6.0'
testImplementation 'net.serenity-bdd:serenity-cucumber6:2.6.0'
testImplementation 'net.serenity-bdd:serenity-screenplay:2.6.0'
testImplementation 'net.serenity-bdd:serenity-screenplay-webdriver:2.6.0'
testImplementation 'junit:junit:4.13.1'
}
test {
testLogging.showStandardStreams = true
systemProperties System.getProperties()
}
gradle.startParameter.continueOnFailure = true
test.finalizedBy(aggregate)
Execute the test suite by using the below command.
gradle test
This will generate only index.html not serenity-summary.html (emailable) report.
To generate single page html report, we need to invoke the report task.
gradle reports
Below is the image of serenity-summary.html report.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
How to manage screenshots in Serenity Report
Serenity provides a wide range of options to manage screenshots in the report. By default, Serenity has set option serenity.take.screenshots=BEFORE_AND_AFTER_EACH_STEP, which means the screenshot is saved before and after each step as shown in the below image. Before this tutorial, refer to the previous tutorial on How to generate Serenity Report.
However, recording many screenshots can slow down test execution. So, maybe we like to record the screenshot of failed steps in the scenario. To achieve this flexibility, configure serenity.take.screenshots property in serenity.properties file.
There are various other types of options for managing screenshots in Serenity Report. This property can take the following values:
- FOR_EACH_ACTION: Saves a screenshot at every web element action (like click(), typeAndEnter(), type(), typeAndTab() etc.).
- BEFORE_AND_AFTER_EACH_STEP: Saves a screenshot before and after every step.
- AFTER_EACH_STEP: Saves a screenshot after every step
- FOR_FAILURES: Saves screenshots only for failing steps.
- DISABLED: Doesn’t save screenshots for any steps.
In the below option, I have used FOR_FAILURES option in the serenity.properties file.
serenity.project.name = Serenity and Cucumber Report Demo
current.target.version = sprint-1
serenity.take.screenshots = FOR_FAILURES
Below is the screenshot of the passed test case. We can see that there is no screenshot attached to any of the test steps.
Below is the screenshot of the failed test case. We can see that there is a screenshot attached to the failed test step only, not all the test steps. In below example, it is a scenario outline with four different test data. Out of four, only one set of test data has failed. So, the screenshot is generated for the failed step of that particular test data.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
How to attach Test Evidence to Manual Tests in Serenity Report
In the previous tutorial, I explained how to mention Manual Test Cases in Serenity Report. In this tutorial, I will explain how to attach test evidence to manual tests. Before this tutorial, I suggest you to refer the tutorial which explain How to generate Serenity Report.
It is always advisable to attach screenshots or other files to our manual test reports as additional evidence, specially for failed scenarios. The @manual-test-evidence tag allows you to do just this. You can either include a link to an external site, as shown here:
@manual
@manual-result:failed
@manual-last-tested:sprint-1
@manual-test-evidence:https://database/demo.png
Mentioning the path of evidence in the test is not a very good way to attach test evidence to the manual tests. An alternative approach and favorable one is to place the image in the src/test/resources/assets folder and include a relative link to this file (starting with “assets/“):
@manual
@manual-result:failed
@manual-last-tested:sprint-1
@manual-test-evidence:assets/DB1.PNG
Scenario: Verify different credentials are provided to Admin, Dev and QA to access Master Database
Given User is connected to Master Database
Then Different credentials are provided to Admin, Business, Dev and QA to access Master Database
Test Evidence is only displayed if the @manual-last-tested annotation is defined in serenity.properties.
serenity.project.name = Serenity and Cucumber Report Demo
current.target.version = sprint-1
Execute the test suite by using the below command
mvn clean verify
As we the the Serenity Reports (index.html and serenity-summary.html) are generated under target/site/serenity.
Below is the sample index.html report which has test evidence attached to the manual test.
You can see that there is a new tag with name – Test Evidence. This is the screenshot I have placed under assets folder.
Click on the link and a new page with the screesnhot placed under assets folder opens.
Congratulations. You are able to attach the test evidence to manual tests in Serenity Report. Hope you enjoyed this tutorial. Cheers!!
How to report Manual Tests in Serenity Report
Cucumber is primarily and traditionally used for automating executable specifications. But with Serenity BDD, you can add special tags to indicate that a scenario represents a manual test case.
You can flag any Cucumber scenario as manual simply by using the @manual tag. In the below example, I have tagged a scenario as “@manual”. The last scenario is tagged as “manual”. By default, @manual scenarios are marked as pending in the Serenity reports.
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 |
@ForgetPassword
Scenario: Verify Forget Password Functionality
Given User is on Home page
When User clicks on Forgot your password link
Then User should be able to see new page which contains Reset Password button
@manual
Scenario: Verify credentials present in Master Database not older than 30 days
Given User is connected to Master Database
Then Username "Admin" and password "admin123" are present in Master Database not older than 30 days
Execute the test suite using below command
mvn clean verify
The scenario marked with @manual tag will now appear as a Manual test case in the Serenity report (Index.html). To know how to create Serenity Report, click here.
We can indicate a different result by adding the @manual-result tag as shown here:
A passing test: @manual-result:passed
A failing test: @manual-result:failed
A compromised test: @manual-result:compromised
If we want to record the result of a manual test, we should include both the @manual and the @manual-result tags.
@manual
@manual-result:passed
Scenario: Verify credentials present in Master Database not older than 30 days
Given User is connected to Master Database
Then Username "Admin" and password "admin123" are present in Master Database not older than 30 days
@manual
@manual-result:failed
Scenario: Verify different credentials are provided to Admin, Dev and QA to access Master Database
Given User is connected to Master Database
Then Different credentials are provided to Admin, Business, Dev and QA to access Master Database
This image shows that there are 2 manual tests. I have marked one manual test as passed and another one as failed which is clearly shown in this image.
How to update Manul Test Results
In the below example, we are considering that the team is working on Sprint-1. We have executed the manual tests and marked the status in the feature file as shown below.
@manual
@manual-result:passed
@manual-last-tested:sprint-1
Scenario: Verify credentials present in Master Database not older than 30 days
Given User is connected to Master Database
Then Username "Admin" and password "admin123" are present in Master Database not older than 30 days
@manual
@manual-result:failed
@manual-last-tested:sprint-1
Scenario: Verify different credentials are provided to Admin, Dev and QA to access Master Database
Given User is connected to Master Database
Then Different credentials are provided to Admin, Business, Dev and QA to access Master Database
In the Serenity properties , the team also records the current version (or sprint number):
serenity.project.name = Serenity and Cucumber Report Demo
current.target.version = sprint-1
Now, execute the feature file. This is how the report look like.
Now, we are in next sprint. Update the value of current.target.version in serenity.properties file.
serenity.project.name = Serenity and Cucumber Report Demo
current.target.version = sprint-2
Now, when the manual scenario is processed, it will be marked as pending, with a note indicating that a new manual test is required:
Both the maual tests which were marked as pass and fail are now pending tests as shown in the image.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
Serenity Emailable HTML Report
In the previous tutorial, I have explained the Generation of Serenity Report (index.html) using Cucumber6 and JUnit. Index.html report that act both as test report and living documentation for the product. It has various views like Overall Test Status, Requirement View, Capabilities View and Features View.
Sometimes it is useful to be able to send a short summary of the test outcomes via email. Serenity allows us to generate a single-page, self-contained HTML summary report, containing an overview of the test results, and a configurable breakdown of the status of different areas of the application.
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
- Serenity Cucumber6 – 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, Serenity Cucumber and JUnit dependencies to POM.xml
- Update Build Section of pom.xml
- Create source folder – src/test/resources and features folder within src/test/resources to create test scenarios in Feature file
- 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 through commandline which generates Serenity Report
To know about Step 1 to 3, please refer here. These steps are same for Index.html report and emailable report.
Now, add the below mentioned plugin. These reports are configured in the Serenity Maven plugin, where you need to do two things. First, you need to add a dependency for the serenity-emailer module in the plugin configuration. Then, you need to tell Serenity to generate the email report when it performs the aggregation task.
<plugin>
<groupId>net.serenity-bdd.maven.plugins</groupId>
<artifactId>serenity-maven-plugin</artifactId>
<version>${serenity.version}</version>
<dependencies>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-single-page-report</artifactId>
<version>${serenity.version}</version>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-navigator-report</artifactId>
<version>${serenity.version}</version>
</dependency>
</dependencies>
<configuration>
<tags>${tags}</tags>
<reports>single-page-html,navigator</reports>
</configuration>
<executions>
<execution>
<id>serenity-reports</id>
<phase>post-integration-test</phase>
<goals>
<goal>aggregate</goal>
</goals>
</execution>
</executions>
</plugin>
Step 10 – 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 verify -Dwebdriver.gecko.driver="C:\\Users\\Vibha\\Software\\geckodriver-v0.26.0-win64\\geckodriver.exe"
I have provided the location of firefoxdriver through commandline. I believe this is the best way to run the test. We can hard-code the path in the test code or in serenity.conf file. In that case, you don’t need to provide location of firefoxdriver through command line. You can use below command.
mvn verify
This image show that two different type of reports are generated by Serenity – Full Report (index.html) and Single Page HTML Summary ( serenity-summary.html ).
This emailable report is called serenity-summary.html. This is generated under site/serenity/ serenity-summary.html
You can see a sample of such a report here:
As you can see in the above execution status, out of six tests, one test is failed. The same information is displayed in the report.
This report provides summary of the test execution.
The Functional Coverage section lets us highlight key areas of your application. By default, this section will list test results for each Feature. But we can configure the report to group results by other tags as well.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
Serenity Report for Web Application with Cucumber6 and Junit
In the previous tutorial, I explained the Testing of Web Application using Serenity BDD with Cucumber5 and JUnit4. In this tutorial, I’ll explain how to generate a Serenity Report for a web application using Serenity BDD with Cucumber6 and JUnit4.
Serenity BDD produces great test reports which act as Living Documentation for the product.
Prerequisite
- 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
- Serenity Cucumber6 – 2.6.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 Cucumber, and JUnit dependencies to POM.xml
- Update Build Section of pom.xml
- Create source folder – src/test/resources and features folder within src/test/resources to create test scenarios in the Feature file
- Create the Step Definition class or Glue Code
- Create a Serenity-Cucumber Runner class
- Create serenity.conf file under src/test/resources
- Create a serenity.properties file at the root of the project
- Run the tests through command line which generates Serenity Report
Step 1 – Update the Properties section in Maven pom.xml
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<serenity.version>2.6.0</serenity.version>
<serenity.maven.version>2.6.0</serenity.maven.version>
<serenity.cucumber.version>2.6.0</serenity.cucumber.version>
<junit.version>4.13.2</junit.version>
<maven.surefire.plugin.version>3.0.0-M5</maven.surefire.plugin.version>
<maven.failsafe.plugin.version>3.0.0-M5</maven.failsafe.plugin.version>
<maven.compiler.plugin.version>3.8.1</maven.compiler.plugin.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<encoding>UTF-8</encoding>
<tags></tags>
<parallel.tests>4</parallel.tests>
<webdriver.base.url></webdriver.base.url>
</properties>
Step 2 – Add repositories and pluginRepository to Maven pom.xml
<repositories>
<repository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>bintray</name>
<url>https://jcenter.bintray.com</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>bintray-plugins</name>
<url>https://jcenter.bintray.com</url>
</pluginRepository>
</pluginRepositories>
Step 3 – Add Serenity, Serenity Cucumber, and JUnit dependencies to POM.xml
<dependencies>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-core</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-junit</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-rest-assured</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-screenplay</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-cucumber6</artifactId>
<version>${serenity.cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-screenplay-webdriver</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
Step 4 – Update the Build Section of pom.xml
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${maven.surefire.plugin.version}</version>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<artifactId>maven-failsafe-plugin</artifactId>
<version>${maven.failsafe.plugin.version}</version>
<configuration>
<includes>
<include>**/*.java</include>
</includes>
<parallel>methods</parallel>
<useUnlimitedThreads>true</useUnlimitedThreads>
</configuration>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven.compiler.plugin.version}</version>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
</configuration>
</plugin>
<plugin>
<groupId>net.serenity-bdd.maven.plugins</groupId>
<artifactId>serenity-maven-plugin</artifactId>
<version>${serenity.maven.version}</version>
<configuration>
<tags>${tags}</tags>
</configuration>
<dependencies>
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-core</artifactId>
<version>${serenity.version}</version>
</dependency>
</dependencies>
<executions>
<execution>
<id>serenity-reports</id>
<phase>post-integration-test</phase>
<goals>
<goal>aggregate</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Step 5 – Create a Feature file
Feature file should be saved as an extension of .feature. Add the test scenarios in this feature file. I have added sample test scenarios. The test scenarios are written in Gherkins language. A feature file is created under src/test/resources.
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 cannot be empty |
@ForgetPassword
Scenario: Verify Forget Password Functionality
Given User is on Home page
When User clicks on Forgot your password link
Then User should be able to see new page which contains Reset Password button
Step 6 – Create the Step Definition class or Glue Code
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();
}
@Then("User should be able to see error message {string}")
public void unsucessfulLogin(String expectedErrorMessage) throws InterruptedException {
String actualErrorMessage = loginPage.errorMessage()
Assert.assertEquals(expectedErrorMessage, actualErrorMessage);
}
@When("User clicks on Forgot your password link")
public void clickForgetPasswordLink() {
loginPage.clickForgetPasswordLink();
}
@Then("User should be able to see new page which contains Reset Password button")
public void verifyForgetPasswordPage() {
Assert.assertTrue(forgetpasswordPage.ForgetPasswordPage());
}
}
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, is annotated with the @Step annotation. Other methods, such as loginVerify(), query the state of the application and are used in assert statements.
Here, I have created 3 StepClasses – StepLoginPage, StepDashboardPage, and StepForgetPasswordPage
StepLoginPage
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();
}
@Step("Error Message on unsuccessful login")
public String errorMessage() {
String actualErrorMessage = $(By.id("spanMessage")).getText();
return actualErrorMessage;
}
@Step("Click Forget Password Link")
public void clickForgetPasswordLink() {
$(By.linkText("Forgot your password?")).click();
}
}
StepDashboardPage
public class StepDashboardPage extends PageObject {
@Step("Successful login")
public void loginVerify() {
String dashboardTitle = $(By.id("welcome")).getText();
assertThat(dashboardTitle, containsString("Welcome"));
}
}
StepForgetPasswordPage
public class StepForgetPasswordPage extends PageObject {
@Step("Verify Forget Password Page ")
public boolean ForgetPasswordPage() {
Boolean resetPasswordButton = $(By.id("btnSearchValues")).isDisplayed();
return resetPasswordButton;
}
}
Step 7 – Create a Serenity-Cucumber Runner class
We cannot run a Feature file on its own in a cucumber-based framework. We need to create a Java class, which will run the Feature File. It is the starting point for JUnit to start executing the tests. TestRunner class creates under src/ test/java. When you run the tests with serenity, you use the CucumberWithSerenity test runner. If the feature files are not in the same package as the test runner class, you also need to use the @CucumberOptions class to provide the root directory where the feature files are 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/Login/LoginPage.feature", glue = "com.example.SerenityReportDemo.definitions")
public class CucumberRunnerTest {
}
Step 8 – Create serenity.conf file under src/test/resources
Serenity.conf file is used to specify various features like the type of webdriver used, various test environments, run test in headless mode, and many more options.
webdriver.driver. – This tells Serenity which browser to use for the test execution. You can configure this in several locations – serenity.properties or serenity.conf. Here, I have provided this information in serenity.conf
We can also configure the webdriver.base.url property for different environments in the serenity.conf configuration file, in the src/test/resources directory. Below is an example of the same.
webdriver {
driver = firefox
}
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"
}
}
Once the environment section is present in your serenity.conf file, you can use the environment system property to use the properties for a given environment. For example, the following would cause the staging URLs to be used:
mvn verify -Denvironment=staging
The default environment will be used if no other value is provided. In our example, I will not provide any environment, so it will pick the default environment.
Step 9 – Create serenity.properties file at the root of the project
serenity.project.name = Serenity and Cucumber Report Demo
Step 10 – Run the tests through the command line which generates Serenity Report
Open the command line and go to the location where pom.xml of the project is present and type the below command.
mvn verify -Dwebdriver.gecko.driver="C:\\Users\\Vibha\\Software\\geckodriver-v0.26.0-win64\\geckodriver.exe"
I have provided the location of the firefox driver through the command line. I believe this is the best way to run the test. We can hard-code the path in the test code or in serenity.conf file. If you don’t want to pass the location of webdriver through the command line, then mention the details of webdriver in serenity.conf and just use the below command for execution.
mvn clean verify
Below is the image of the execution status.
This also provides the location of the serenity report as highlighted in the above image.
Serenity Report
Requirement View
In Serenity, requirements are organized in a hierarchy. We can get an idea of the full directory structure (in src/test/features directory) for the project.
The Test Results tab (shown below) tells you about the acceptance tests that were executed for this set of requirements.
The Functional Coverage section shows the test results broken down by functional area.
Test Results
At the bottom of the Test Results tab, you will find the actual test results – the list of all the tests, automated and manual, that were executed for this requirement.
Capability
Feature
This provides the detail of all the Test Scenarios present in a Feature File.
Below is an example of a Scenario Outline in the Report. It shows all the examples mentioned in the feature file.
This screen shows the test steps and screenshots of each step.
We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!
QA Automation Expert 