Java Cucumber Maven Test Automation Framework: A Comprehensive Guide to RESTful API Testing
Tags: testing, automation, restassured, java
Published: 2023-01-30 14:46:56

What is the tech stack used for this?
-------------------------------------

The Java Cucumber Maven Test Automation Framework is a comprehensive solution for testing RESTful APIs. It makes use of the power of Java and Maven as a build tool, along with the simplicity of Cucumber, to provide a flexible and reliable testing framework. The framework has been designed to make test automation as straightforward and as hassle-free as possible.

Key Features
------------

One of the key features of this framework is that it maintains the test context between steps, allowing for easy sharing of test data between steps. The framework uses REST-Assured for API testing, which provides a powerful and flexible API testing library. The framework also generates Cucumber reports for test results, providing a clear and concise view of the test results. The implementation of the BDD methodology provides a clear and understandable way to write tests, making it easy for stakeholders to understand the tests. In this framework, Lombok is utilized to reduce boilerplate code, such as getters and setters, and improve the overall maintainability of the code. With Lombok, you can annotate your class with just a few annotations, and it will generate the necessary code for you at compile time.
Finally, the framework allows for easy environment switching using dynamic config keys, making it easy to switch between different environments, such as *DEV*, *QA*, or *UAT*. This is achieved with the help of *org.aeonbits.owner* package.

```java
package org.framework.bdd.utils;

import org.aeonbits.owner.Config;

@Config.LoadPolicy(Config.LoadType.MERGE)
@Config.Sources({"file:${user.dir}/src/main/resources/config.properties"})
public interface FrameworkConfiguration extends Config {
    @Key("${environment}.base-uri")
    String baseUri();

    @Key("reports")
    String reportPath();
}
```

```properties
environment = qa
reports = target/cucumber-reports/report.html
############## DEV ###################
dev.base-uri = https://api.restful-api.dev


############## QA #####################
qa.base-uri = https://api.restful-api.dev

```

Getting Started
---------------

Getting started with this framework is simple. You can clone the repository from <https://github.com/pritesh-ranjan/java-cucumber-framework> and open the project in IntelliJ IDEA or Eclipse. Then, run the command "*mvn clean test*" in the root directory of the project. The tests will automatically run, and the results will be generated in the *target/cucumber-reports* directory.

Framework Structure
-------------------

The framework is structured into several key components:

*src/main/java*: contains abstract classes, test context, utilities, models, constants, and config reader

*src/main/resources*: contains the feature files and test data

*src/test/java*: contains the step definitions and test runners

*pom.xml*: contains the dependencies and build configuration

Test Context
------------

Test context is an important aspect of any cucumber framework.

It is implemented using the Enum-based singleton pattern. The TestContext enum allows us to share test data in-between cucumber bdd steps in a thread-safe manner. In this case, we are using it to share payload, requests, and response objects. Credits to the test context : https://medium.com/@bcarunmail/sharing-state-between-cucumber-step-definitions-using-java-and-spring-972bc31117af

The test context class is located in the *src/main/java* directory.

API Testing
-----------

API testing is done using the REST-Assured library. The REST-Assured library provides a powerful and flexible API testing library that is used to make HTTP requests and verify the responses. We use the *RequestSpecification* class of rest assured for a one-time setup of the content headers, and other common items used while making a new request.

Behavior Driven Development
---------------------------

The framework uses Cucumber to implement BDD. The feature files are located in the *src/test/resources* directory and the step definitions are located in the *src/test/java* directory. BDD provides a clear and understandable way to write tests, making it easy for stakeholders to understand the tests.

```gherkin
Feature: Gadgets API tests

  Background: reset the test context
    Given test context is reset

  Scenario Outline: Get object by id
    Given a get request is made for fetching details for object with "<id>"
    When response has status 200
    Then response has valid schema
    And response contains the following "<name>"

    Examples:
    | id | name |
    | 2  | Apple iPhone 12 Mini, 256GB, Blue |
    | 7  | HP Pavilion Plus |
```

This framework also demonstrates the use of Hooks like @*Before* and @*After*.

```java
package org.framework.bdd.steps;

import io.cucumber.java.After;
import io.cucumber.java.Before;

public class Hooks {
    @Before
    public void beforeScenario() {
        System.out.print("starting");
    }

    @After
    public void afterScenario() {
        System.out.print("ending");
    }
}

```

Apart from hooks, the background steps are implemented with the *Background* keyword in the feature file.

While Background is a way to specify steps common to all scenarios in a feature file, hooks provide a way to run specific steps before or after each scenario or the entire feature. The Background steps are executed before each scenario in a feature file, whereas hooks are executed before or after each scenario or the entire feature, depending on where they are placed in the code. This allows you to perform specific actions, such as setting up test data or cleaning up after each scenario, in an efficient and organized manner. The use of hooks and Background can significantly improve the readability and maintainability of your test code.

Reporting
---------

Cucumber reporting is integrated with the framework. After running the tests, the report can be found in the *target/cucumber-reports* directory. The report provides a clear and concise view of the test results. Currently, we are using cucumber HTML reports, but extent reporting can be added as per requirements.

Extensibility
-------------

The framework is built to be easily extensible and can be integrated with other testing libraries and frameworks. This makes it easy to add new functionality to the framework as needed, allowing for growth and expansion as your testing needs change. The *AbstractSteps* class store all common methods and variables. The *FrameworkException* class is a base exception class for all custom-defined exceptions.

Conclusion
==========

The framework provides a powerful and flexible platform for test automation. With its combination of Java, Cucumber, and Maven, this framework provides a robust and maintainable solution for testing RESTful APIs using BDD methodology. Whether you are just getting started with test automation or looking for a more robust solution, this type of framework design is a great choice for your testing needs.