<title> 09/01/25

How to Test DELETE API By Playwright

1. What is a DELETE API?

A DELETE API is an HTTP method used in RESTful web services to remove a resource from the server.
It typically requires an identifier (like id) of the resource to be deleted.
Example: DELETE /users/123 would delete the user with ID 123.
The response usually confirms deletion with a status code:

200 OK or 204 No Content → deletion successful.

404 Not Found → resource doesn’t exist.

401/403 → authentication or authorization issues.

Why test DELETE API?

Testing ensures that:

The resource is actually removed from the server.
The correct HTTP status codes are returned.
Unauthorized or invalid requests are handled properly.
No unintended resources are affected.

How to test a DELETE API with Playwright Java

Playwright’s APIRequestContext allows making direct API calls. Testing a DELETE API would involve:

(1) Setup API Context

Initialize an API request context with the base URL and authentication headers if needed.

(2) Send DELETE Request

Use the DELETE method with the resource endpoint (like /users/{id}).
Attach headers (Authorization, Content-Type) if required.

(3) Validate Response Status

Check if the response status code matches expectations (e.g., 204 for success).

(4) Validate Response Body (if any)

Some APIs return a confirmation message or the deleted resource details.
Validate the message or structure if it exists.

(5) Verify Resource Deletion

Optionally send a GET request for the same resource ID.
Ensure the response is 404 Not Found (confirming the resource is gone).

To test a DELETE API using Playwright in Java, you can use Playwright’s ability to perform raw HTTP requests using the APIRequestContext interface.

Steps to Test DELETE API in Playwright Java

Create Playwright and APIRequestContext instance
Send DELETE request using delete() method
Validate response (status code, body, etc.)
Close the context and playwright

Delete API: https://reqres.in/api/users/2

The API is taken from reqres.in

Maven Dependencies

<dependency>
    <groupId>com.microsoft.playwright</groupId>
    <artifactId>playwright</artifactId>
    <version>1.44.0</version>
</dependency>

Java Code Example to Test DELETE API

import com.microsoft.playwright.*;

import java.util.HashMap;
import java.util.Map;

public class DeleteAPITest {
    public static void main(String[] args) {
        try (Playwright playwright = Playwright.create()) {
            // Set up base URL and headers
            APIRequest.NewContextOptions options = new APIRequest.NewContextOptions()
                .setBaseURL("https://reqres.in") // Example DELETE test API
                .setExtraHTTPHeaders(Map.of(
                    "Content-Type", "application/json"
                ));

            APIRequestContext request = playwright.request().newContext(options);

            // Send DELETE request
            APIResponse response = request.delete("/api/users/2");

            // Print and assert the response
            System.out.println("Status Code: " + response.status());
            System.out.println("Status Text: " + response.statusText());

            if (response.status() == 204) {
                System.out.println("DELETE API test passed");
            } else {
                System.out.println("DELETE API test failed");
            }

            request.close();
        }
    }
}

Code explanation

setBaseURL("https://reqres.in") sets the base URL.
.delete("/api/users/2") sends the DELETE request to delete user with ID 2.
The expected status code is 204 No Content — common for successful DELETEs.
You can also validate the response body, headers, etc., if needed.

How to Test PUT API by Playwright

1. What is PUT API?

A PUT API is an HTTP request method used in RESTful web services to update an existing resource on the server.
Unlike POST, which is used to create new data, PUT is typically used when the client wants to replace or update the entire resource with new data.
Example use case: Updating a user’s profile information (like email, phone number, or address).

Important Characteristics:

Idempotent → Multiple identical PUT requests should result in the same state of the resource.
Requires a complete representation of the resource to be sent in the request body (not just partial changes, unless API supports PATCH).

Testing a PUT API with Playwright Java

Although Playwright is mainly used for UI automation, it also provides powerful API testing capabilities. Using Playwright with Java, you can send PUT requests and validate the responses.

(1) Create a request context

In Playwright, you use a APIRequestContext (or similar request handling object in Java binding) to interact with APIs.
This context acts like a lightweight HTTP client.

(2) Send a PUT request

Use the request context to call the PUT method on a given API endpoint.
Provide necessary details like:

URL → The endpoint where the resource exists (e.g., /users/123).
Headers → Usually includes Content-Type: application/json, and sometimes Authorization tokens.

Request body → JSON data with updated information for the resource.

(3) Validate the Response

Check the status code (e.g., 200 OK or 204 No Content indicates success).
Verify the response body (if API returns the updated resource).
Assert that changes are correctly applied by checking response fields or sending a subsequent GET request to fetch updated data.

(4) Error Handling

If you send invalid data, the server should return 400 Bad Request.
If you update a non-existing resource, you might get 404 Not Found.
These scenarios should also be tested.

To test a PUT API using Playwright Java, you can use the APIRequestContext interface provided by Playwright. A PUT request is generally used to update an existing resource on the server. Here's how you can test it step-by-step:

Steps to Test a PUT API in Playwright Java

Initialize Playwright and APIRequestContext
Prepare the request headers and body
Send the PUT request using put() method
Verify the response (status code, body, etc.)

Example Scenario

Let’s say we are updating a user at endpoint:

https://reqres.in/api/users/2

Below is the input JSON request for PUT API

{
  "name": "Himanshu",
  "job": "Software Developer"
}

Java Code to Test PUT API with Playwright

import com.microsoft.playwright.*;
import com.microsoft.playwright.options.*;

import java.util.*;

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

      APIRequestContext requestContext = request.newContext(new APIRequest.NewContextOptions()
        .setBaseURL("https://reqres.in/api"));

      // Prepare JSON request body
      Map<String, Object> data = new HashMap<>();
      data.put("name", "Himanshu");
      data.put("job", "Software Developer");

      // Send PUT request
      APIResponse response = requestContext.put("/users/2",
        RequestOptions.create()
          .setHeader("Content-Type", "application/json")
          .setData(data)
      );

      // Print status code
      System.out.println("Status Code: " + response.status());

      // Print response body
      System.out.println("Response Body: " + response.text());

      // Optional: Validate status code
      if (response.ok()) {
        System.out.println("PUT request successful.");
      } else {
        System.out.println("PUT request failed.");
      }
    }
  }
}

Code explanation:

(a) Create object of APIRequestContext class

(b) Prepare JSON request body

(d) Print the status code

(e) Print the response

(d) Validate status code

Output:

Status Code: 200
Response Body: {
    "name": "Himanshu",
    "job": "Software Developer",
    "updatedAt": "2025-07-28T12:13:45.012Z"
}
PUT request successful.

Above is the output of PUT API. We can see status code is 200 as API is successfully executed and have response in the response body.

Important Points:

APIRequestContext.put() is used to send the PUT request.
You can validate more fields using:

response.json().get("name").toString();

Always set the Content-Type header for JSON payloads.