Automating REST APIs with Selenium and Postman

API testing has become an integral part of software quality assurance. Automating REST APIs ensures the robustness and reliability of web applications by validating backend functionality. In this blog, we will explore how Selenium and Postman can be used to automate REST APIs, providing both flexibility and scalability in your testing processes.

Why Automate REST APIs?

Automating REST APIs brings several benefits, including:

• Speed: Automated tests execute faster compared to manual testing.

• Accuracy: Minimizes human error in repetitive tasks.

• Efficiency: Allows simultaneous testing of multiple endpoints.

• Integration: Fits seamlessly into CI/CD pipelines.

Key Concepts in REST API Automation

Before diving into automation, let’s understand some key concepts:

• API Endpoint: A URL that specifies where an API resource is located.

• HTTP Methods: Common methods include GET, POST, PUT, DELETE.

• Status Codes: Responses like 200 (OK), 404 (Not Found), 500 (Server Error).

• Request Payload: The data sent with a request, often in JSON format.

• Response: Data received from the server, including status and body.

Tools Overview: Selenium and Postman

• Selenium: Best suited for UI testing but can complement API testing by validating front-end integration with APIs.

• Postman: A powerful API testing tool that supports request creation, test scripting, and automation through Newman CLI.

Practical Applications of API Testing

1. Authentication: Validating login and token-based authentication mechanisms.

2. Data Integrity: Ensuring the correctness of data returned by APIs.

3. Error Handling: Checking proper error messages and status codes.

4. Load Testing: Simulating multiple users accessing APIs simultaneously.

Setting Up Selenium and Postman for API Automation

1. Installing Selenium

Ensure you have Java and Maven installed. Add Selenium dependencies to your pom.xml:

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>4.10.0</version>

</dependency>2. Installing Postman

Download Postman from Postman’s official website. For automation, install Newman:

npm install -g newman

Coding Examples: Automating REST APIs with Selenium and Postman

Example 1: Sending API Requests Using Java (RestAssured Library)

import io.restassured.RestAssured;
import io.restassured.response.Response;

public class ApiTest {
    public static void main(String[] args) {
        RestAssured.baseURI = "https://jsonplaceholder.typicode.com";

        // GET Request
        Response response = RestAssured.given().get("/posts/1");
        System.out.println("Status Code: " + response.getStatusCode());
        System.out.println("Response Body: " + response.getBody().asString());

        // Assert Status Code
        assert response.getStatusCode() == 200;
    }
}
Example 2: Running Postman Collections via Newman
Export your Postman collection as a JSON file.
Use Newman CLI to execute the collection:

newman run my-collection.json
Example 3: Integrating Selenium with API Responses

This example demonstrates how to combine API testing with UI testing by validating that the data returned from an API call is correctly displayed on a web application's UI. Here’s a breakdown of the code:
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import io.restassured.RestAssured;

public class SeleniumApiIntegration {
    public static void main(String[] args) {
        // API Call
        RestAssured.baseURI = "https://api.example.com";
        String apiData = RestAssured.given().get("/data").getBody().asString();

        // Selenium Test
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");

        WebElement element = driver.findElement(By.id("apiDataField"));
        assert element.getText().equals(apiData);

        driver.quit();
    }
}
1. API Call with RestAssured
The first step involves using RestAssured to interact with the API. A base URL is set, and a GET request is sent to a specific endpoint. The response body is retrieved as a string, which will later be compared with the data displayed on the web page.
2. Selenium Test
The Selenium WebDriver is initialized to open the browser and navigate to the target URL. This ensures that the web page containing the UI element to be validated is loaded and ready for interaction.
3. Finding the Web Element
A specific element on the web page is located using a unique identifier (like an ID attribute). This UI element is expected to display the same data that was fetched from the API.
4. Validating the Data
The text content of the located UI element is retrieved and compared with the API response. If the values match, the test passes, indicating consistency between the API and UI. If they don't match, it signals a potential bug or data discrepancy.
5. Closing the Browser
Finally, the browser session is terminated to ensure no resources are left open after the test execution.
Use Case
This approach is used to verify the consistency of data between the backend (API response) and the frontend (UI). For example:
Validating that product details provided by an API, such as name or price, are displayed accurately on a webpage.
Benefits
End-to-End Testing: Ensures seamless integration between the backend and frontend.
Early Bug Detection: Detects mismatches between API and UI during testing phases.
Reusable: Can be extended to validate multiple API endpoints and corresponding UI elements.
Step-by-Step Guide to Automate API Testing
Understand API Requirements: Review API documentation to understand endpoints, methods, and payloads.
Create Test Cases: Identify scenarios such as response validation, status codes, and data formats.
Use Postman for Initial Testing: Verify API responses manually.
Automate with Java: Use RestAssured or HttpClient libraries for scripting.
Integrate with Selenium: Combine API data validation with UI testing.
Leverage CI/CD: Incorporate automated tests into Jenkins or GitHub Actions.
Conclusion
By integrating Selenium and Postman, you can create a comprehensive automation suite that tests APIs and ensures seamless integration between backend and frontend systems. API testing not only improves the reliability of web applications but also accelerates the development cycle, allowing teams to deliver high-quality products efficiently.
CTA: Have questions about API testing with Selenium and Postman? Share them in the comments below!
Source: Read More