API testing using Playwright

Why Choose Playwright for API Testing?

Playwright is a popular choice for UI automation, but it's also a powerful tool for API testing. In version 1.16, Playwright introduced the APIRequestContext class, which enables users to make API calls and create assertions on various aspects of the HTTP response. This flexibility means that you can create standalone API tests, as well as combine API calls with UI actions like clicks and inputs.

There are several key reasons to choose Playwright for API testing:

1. Ease of use: Playwright offers a simple, intuitive API for sending HTTP(S) requests over the network.
2. Language support: Tests can be written in JavaScript or TypeScript, aligning with the language preferences of many development teams.
3. Integration with UI testing: Playwright's seamless integration of UI and API testing allows for efficient end-to-end testing.
4. In-built features: Playwright's built-in request fixture supports configuration options such as baseURL and extraHTTPHeaders, simplifying test setup.

Getting Started with Playwright API Testing

To start using Playwright for API testing, you'll need to set up a new Playwright project. First, create a new directory and initialize a Playwright project using the following command:

npm init playwright@latest

This command will generate a default project structure including a playwright.config.ts file, where you can configure your project's settings.

To run your Playwright tests, use the command: npx playwright test. Once the tests have finished, view the test results with: npx playwright show-report.

Basic CRUD Operations in API Testing

CRUD (Create, Read, Update, Delete) operations are the foundation of API testing, allowing you to interact with your application's resources. Here's a brief overview of CRUD operations in API testing:

Create (POST)

This operation creates a new resource. The client sends a POST request to the API endpoint with the new resource's data in the request body. The API creates the resource and returns a response with the details of the newly created resource, including its unique identifier.

Read (GET)

This operation retrieves an existing resource or a list of resources. The client sends a GET request to the API endpoint, optionally with query parameters to filter, sort, or paginate the results. The API returns the requested resource(s) in the response body.

Update (PUT or PATCH)

This operation modifies an existing resource. The client sends a PUT or PATCH request to the API endpoint with the updated data for the resource in the request body. PUT replaces the entire resource with the new data, while PATCH only updates the specified fields. The API updates the resource and returns a response with the updated resource details.

Delete (DELETE)

This operation removes an existing resource. The client sends a DELETE request to the API endpoint with the unique identifier of the resource to be deleted. The API removes the resource and returns a response with a status code indicating success or failure.

Sending API Requests with Playwright

Using Playwright's APIRequestContext class, you can easily send API requests and perform assertions on the response. Here's a simple example demonstrating how to use Playwright to test issue creation via the GitHub API:

import { test, expect } from '@playwright/test';

test('should create a bug report', async ({ request }) => {
  const newIssue = await request.post('/repos/github-username/test-repo-1/issues', {
    data: {
      title: '[Bug] report 1',
      body: 'Bug description',
    },
  });

  expect(newIssue.ok()).toBeTruthy();

  const issues = await request.get('/repos/github-username/test-repo-1/issues');

  expect(issues.ok()).toBeTruthy();
  expect(await issues.json()).toContainEqual(expect.objectContaining({
    title: '[Bug] report 1',
    body: 'Bug description',
  }));
});

In this example, we're using the post and get methods provided by the APIRequestContext class to send API requests and validate the server state.

Configuring Playwright for API Testing

You can configure your Playwright project for API testing by modifying the playwright.config.ts file. For example, you can set the baseURL and configure authorization headers as follows:

import { defineConfig } from '@playwright/test';

export default defineConfig({
  use: {
    baseURL: 'https://api.example.com',
    extraHTTPHeaders: {
      'Authorization': `Bearer ${process.env.API_TOKEN}`,
    },
  },
});

This configuration allows you to send API requests with the specified baseURL and authorization headers.

Advanced API Testing Techniques

Once you've mastered the basics of API testing with Playwright, you can explore more advanced techniques to enhance your test coverage and reliability. Some of these techniques include:

1. Calculating API Endpoint Coverage: Track the coverage of your API endpoints to ensure that your tests cover all critical paths.
2. Creating Data Factories: Manage test data efficiently by creating data factories that generate and clean up test data automatically.
3. Creating Helper Functions: Build reusable helper functions for common tasks, such as validating JSON schema or handling authentication.
4. Organizing Tests: Organize your tests using beforeAll and beforeEach hooks to set up preconditions and configurations.
5. Custom Assertions: Extend Playwright's built-in expect assertions with custom assertions tailored to your application's needs.

Further reading

This just scratches the surface of what's possible with Playwright for API testing. To learn more about API testing with Playwright, check out the following resources:

• https://playwright.dev/docs/api-testing
• https://playwrightsolutions.com/the-definitive-guide-to-api-test-automation-with-playwright-part-1-basics-of-api-testing-get/

Conclusion

API testing is a crucial aspect of modern software development, and Playwright provides a powerful, flexible framework for creating comprehensive API test suites. By mastering the techniques outlined in this guide, you'll be well-equipped to create robust, efficient API tests that ensure the reliability and performance of your applications. Whether you're new to Playwright or an experienced user, API testing with Playwright is an invaluable skill that can help you deliver high-quality software and enhance your development workflow.