Test API using POJO Class in Playwright


1. What is a POJO Class?

  • POJO stands for Plain Old Java Object.
  • It is a simple Java class that does not extend or implement any special framework classes.
  • It is mainly used to define structured data in Java with fields, constructors, getters, and setters.
  • In the context of APIs, POJOs are used to map request and response payloads (usually JSON or XML) into Java objects, making it easier to handle data.
  • Playwright Java supports HTTP requests using the APIRequest module. You can serialize a POJO (Plain Old Java Object) to JSON and send it in the POST request body.

2. Why Use POJO in API Testing?
  • Readable & Maintainable → Instead of writing raw JSON strings, you can work with objects.
  • Reusability → The same POJO class can be used across multiple tests for request/response validation.
  • Serialization/Deserialization → Libraries like Jackson or Gson can automatically convert POJOs to JSON (for requests) and JSON back to POJOs (for responses).
  • Strong Typing → You get compile-time type safety when accessing response fields.


3. How to Test an API with POJO in Playwright Java

Although Playwright is primarily for browser automation, it provides API testing support through its APIRequestContext. Here’s how POJOs fit in:

(1) Define POJO Class

  • Create a POJO representing the request body structure (for POST/PUT).
  • Create another POJO representing the response body structure (for parsing).

(2) Serialize Request POJO to JSON

  • Use Jackson or Gson to convert the Java object (POJO) into JSON format.
  • Pass this JSON as the request body when making API calls with Playwright’s API request methods.

(3) Send API Request with Playwright

  • Use Playwright’s APIRequestContext to send GET, POST, PUT, or DELETE requests.
  • Attach headers, authentication, and the serialized JSON request if needed.

(4) De serialize Response into POJO

  • Playwright will return the response body as JSON.
  • Convert (de serialize) that JSON into a POJO class using Jackson or Gson.

(5) Assertions Using POJO

  • Instead of manually parsing JSON, directly access response fields from the POJO.
  • Example: check if responsePojo.getStatus() equals "success".

4. Advantages of Testing API with POJOs in Playwright Java
  • Cleaner test code → Work with objects, not raw JSON strings.
  • Reusable Models → Same POJO can be used across multiple test cases.
  • Consistency → Ensures request and response structures are strongly validated.
  • Scalability → Easier to expand test coverage as API complexity grows.




















Steps

  • Create POJO class to represent your request payload.
  • Initialize Playwright and APIRequestContext.
  • Send POST request using .post() with the serialized POJO.
  • Validate the response.


Example:

Suppose you're testing an API endpoint:

POST https://reqres.in/api/users
Payload: { "name": "Himanshu", "job": "QA Engineer" }


















Maven Dependencies:

<dependencies>
    <dependency>
        <groupId>com.microsoft.playwright</groupId>
        <artifactId>playwright</artifactId>
        <version>1.44.0</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version>
    </dependency>
</dependencies>



1. Create POJO Class

Below is the POJO class consists of two attributes name and job and their getter and setter methods.

public class User {
    private String name;
    private String job;

    public User(String name, String job) {
        this.name = name;
        this.job = job;
    }

    // Getters and setters (optional)
    public String getName() { return name; }
    public String getJob() { return job; }
    public void setName(String name) { this.name = name; }
    public void setJob(String job) { this.job = job; }
}



2. Main Test Code Using Playwright

import com.microsoft.playwright.*;
import com.google.gson.Gson;
import com.microsoft.playwright.options.*;

public class PostApiTest {
    public static void main(String[] args) {
        try (Playwright playwright = Playwright.create()) {
            APIRequestContext request = playwright.request().newContext();

            // Create POJO object
            User user = new User("Himanshu", "QA Engineer");

            // Convert POJO to JSON
            Gson gson = new Gson();
            String jsonBody = gson.toJson(user);

            // Send POST request
            APIResponse response = request.post("https://reqres.in/api/users",
                RequestOptions.create()
                    .setHeader("Content-Type", "application/json")
                    .setData(jsonBody)
            );

            // Validate response
            System.out.println("Status: " + response.status());
            System.out.println("Response Body: " + response.text());

            if (response.status() == 201) {
                System.out.println("POST request successful!");
            } else {
                System.out.println("POST request failed!");
            }
        }
    }
}



Code explanation:

(a) Create Playwright Object and APIRequestContext object
(b) Create Pojo class object
(c) Convert POJO to JSON
(d)  Send POST request
(e) Validate the resposne



Expected Output

Status: 201
Response Body: {
  "name": "Himanshu",
  "job": "QA Engineer",
  "id": "734",
  "createdAt": "2025-07-28T10:52:45.108Z"
}
POST request successful!

Above is the output of API with status code 201, as this is POST API and response body in the JSON format.


Important Points:

  • Gson is used to serialize the POJO into JSON.
  • RequestOptions.create().setData(jsonBody) sets the request body.
  • This approach is ideal when working with complex request bodies in APIs.


Suggested Posts:

1. Automate GET API in Playwright
2. Automate POST API in Playwright
3. Automate PUT API in Playwright
4. Test Basic Authentication in Playwright
5. Token Bsed Authentication in Playwright

No comments:

How to Test Lombok API by Playwright

 

1. What is Lombok API?

  • Project Lombok is a Java library (API) that helps reduce boilerplate code in Java classes.
  • Instead of writing getters, setters, constructors, toString(), equals(), and hashCode() methods manually, Lombok uses annotations like @Getter, @Setter, @Data, @Builder, etc. to auto-generate them during compilation.
  • Example: A User class with @Data annotation will automatically have getters, setters, and other utility methods without explicitly writing them.
  • Lombok improves code readability and maintainability but still produces bytecode with full methods, so other parts of the application can use it seamlessly.

2. Why Testing Lombok API is Important?
  • Lombok only generates methods at compile time, but we should validate the business logic that depends on these generated methods.
  • Testing ensures that:
         - Getter/Setter methods work as expected.
         - equals() and hashCode() generated methods behave correctly in collections.
         - toString() provides meaningful output.
         - Builder patterns (@Builder) correctly construct objects.


How to Test Lombok APIs with Playwright Java

(1) Setup Playwright Test Environment
  • Configure Playwright Java project.
  • Use Playwright’s API testing capabilities (APIRequestContext) for sending API calls.
(2) Send API Request
  • Perform GET, POST, PUT, or DELETE requests to endpoints built on Lombok-backed models.

(3) Validate Response
  • Check if Lombok-generated methods worked as intended. For example:
         - If you created a user via API (using Lombok’s builder), verify the response                 contains correct details (via getter methods).
         - If you fetch a list, ensure Lombok’s equals() and hashCode() ensure no                     duplicates are mishandled.

(4) Assertions
  • Validate status codes (200, 201, etc.).
  • Validate JSON structure (keys, values).
  • Validate that Lombok-driven serialization matches expected contract.

To test a Lombok-based API using Playwright with Java, you need to understand that Lombok is a Java annotation library used to reduce boilerplate code in Java classes. When we say "Lombok API", we are usually referring to a REST API that uses Lombok in its backend for DTOs or models.

From a test automation perspective using Playwright Java, it doesn’t matter if Lombok is used on the server side. Your focus will be on sending HTTP requests (GET, POST, PUT, DELETE) and validating responses (status codes, response body, etc.).























Steps to Test a Lombok-based API in Playwright Java:

  • Set up Playwright Java Project
  • Use Java’s HttpClient or OkHttp for API calls
  • Send a request to the API
  • Validate the response (status, body, etc.)


Example

Assume we have a Lombok-powered API:

Below is the API request for LOMBOK API

POST http://localhost:8080/api/users
Request Body:
{
  "name": "John Doe",
  "email": "john@example.com"
}



Response:

{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com"
}




Code to Test this API using Playwright Java + HttpClient

import com.microsoft.playwright.*;
import java.net.URI;
import java.net.http.*;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.http.HttpRequest.BodyPublishers;

public class LombokApiTest {
    public static void main(String[] args) throws Exception {
        // Start Playwright (in case you want to verify UI after API test)
        try (Playwright playwright = Playwright.create()) {
            Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(true));
            BrowserContext context = browser.newContext();
            Page page = context.newPage();

            // Send API request using Java HttpClient
            HttpClient client = HttpClient.newHttpClient();

            // Sample JSON payload
            String jsonBody = """
                    {
                      "name": "John Doe",
                      "email": "john@example.com"
                    }
                    """;

            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("http://localhost:8080/api/users"))
                    .header("Content-Type", "application/json")
                    .POST(BodyPublishers.ofString(jsonBody))
                    .build();

            HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

            // Print and assert
            System.out.println("Status Code: " + response.statusCode());
            System.out.println("Response Body: " + response.body());

            if (response.statusCode() == 200 || response.statusCode() == 201) {
                System.out.println("API Test Passed");
            } else {
                System.out.println("API Test Failed");
            }

            // Optionally, use Playwright to navigate to a UI and verify the new user
            // page.navigate("http://localhost:8080/users");
            // page.locator("text=John Doe").waitFor(); // if user is listed
        }
    }
}



Code explanation:

(a) Create Playwright and Page object
(b) Send API request using Java HttpClient
(c) Define input JSON request
(d) Create HttpRequest object and send the request by send()
(e) The response that we got is printed and asserted.


Tools Used

  • Java HttpClient: To test the REST API.
  • Playwright Java: To optionally validate frontend after API call.
  • Lombok: Present in the backend API but irrelevant to test logic.


Maven Dependency for Playwright

<dependency>
  <groupId>com.microsoft.playwright</groupId>
  <artifactId>playwright</artifactId>
  <version>1.43.0</version> <!-- or latest -->
</dependency>


No comments:
Subscribe to: Posts (Atom)