odottaa

Custom playwright matchers to test the state of the API response

---

Table of Contents

• Table of Contents
• Installation
• Usage
  • TypeScript
  • JavaScript
• API
  • toHaveStatusCode
  • toHaveStatusText
  • toBeCreated
  • toBeUnauthorized
  • toBeForbidden
  • toBeNotFound
  • toHaveJSON
  • toContainJSON
  • toMatchJSON
  • toHaveHeader
  • toHaveHeaders
  • toHaveContentType
  • toContainTextContent
  • toHaveLocation
  • toBeRedirected
• Author
• License

Installation

This module is distributed via npm which is bundled with node and should be installed as one of your project's devDependencies:

npm i -D odottaa

Usage

TypeScript

1. Import odottaa module
2. Extend expect with custom API matchers

// 1. In your playwright.config.ts
import { expect } from '@playwright/test';
import playwrightApiMatchers from 'odottaa';

// 2. extend expect with custom API matchers
expect.extend(playwrightApiMatchers);

JavaScript

// 1. In your playwright.config.js
const { expect } = require('@playwright/test');
const { default: playwrightApiMatchers } = require('odottaa');

// 2. extend expect with custom API matchers
expect.extend(playwrightApiMatchers);

API

toHaveStatusCode

Use toHaveStatusCode matcher to verify that the response's status code is equal to the expected status code

const response = await request.get('https://example.com/');

await expect(response).toHaveStatusCode(201);

toHaveStatusText

Use toHaveStatusText matcher to verify that the response' status text is equal to the expected status text

const response = await request.get('https://example.com/404');

await expect(response).toHaveStatusText('Not Found');

toBeCreated

Use toBeCreated matcher to verify that the response's status code is 201

const response = await request.post('https://example.com/create');

await expect(response).toBeCreated();

toBeUnauthorized

Use toBeUnauthorized matcher to verify that the response's status code is 401

const response = await request.post('https://example.com/create');

await expect(response).toBeUnauthorized();

toBeForbidden

Use toBeForbidden matcher to verify that the response's status code is 403

const response = await request.post('https://example.com/create');

await expect(response).toBeForbidden();

toBeNotFound

Use toBeNotFound matcher to verify that the response's status code is 404

const response = await request.post('https://example.com/list');

await expect(response).toBeNotFound();

toHaveJSON

Use toHaveJSON matcher to verify that the response's body json is equal to the all properties of object instances (also known as "deep" equality)

const response = await request.get('https://example.com/data.json');
// e.g. response { name: 'Ben', age: 37 }

await expect(response).toHaveJSON({
  name: 'Ben',
  age: 37
});

toContainJSON

Use toContainJSON matcher to verify that the response's body array contains that an item with a specific structure and values is contained in an array.

const response = await request.get('https://example.com/data.json');
// e.g. response [{ name: 'Ben', age: 37 }, { name: 'Anna', age: 26 }]

await expect(response).toContainJSON({
  name: 'Ben',
  age: 37
});

toMatchJSON

Use toMatchJSON matcher to verify that the response's body json matches a subset of the properties of an object. It'll match received objects with properties that are not in the expected object.

const response = await request.get('https://example.com/data.json');
// e.g. response [{ name: 'Ben', age: 37 }, { name: 'Anna', age: 26 }]

await expect(response).toMatchJSON({
  name: 'John Doe',
});

toHaveHeader

Use toHaveHeader matcher to verify that the response's headers contains the expected header and value

const response = await request.get('https://example.com');

// Asserts that the response's headers contains the header 'content-length'
await expect(response).toHaveHeader('content-length');

// Asserts that the response's headers contains the header 'content-length' with value '22'
await expect(response).toHaveHeader('content-length', '22');

toHaveHeaders

Use toHaveHeaders matcher to verify that the response's headers contains the expected header

const response = await request.get('https://example.com');

// Single
await expect(response).toHaveHeaders({ 'content-length': '22' });

// Multiple
await expect(response).toHaveHeaders({ 'content-type': 'text/html', 'content-length': '22' });

toHaveContentType

Use toHaveContentType matcher to verify that the response' headers content type is equal to the expected type

const response = await request.get('https://example.com/');

await expect(response).toHaveContentType('text/html');

toContainTextContent

Use toContainTextContent matcher to verify that the response' body text contains the expected text

const response = await request.get('https://example.com/');

await expect(response).toContainTextContent('Hello, World!');

toHaveLocation

Use toHaveLocation matcher to verify that the response' headers location is equal to the expected location

const response = await request.get('https://example.com/');

await expect(response).toHaveLocation('/home');

toBeRedirected

Use toBeRedirected matcher to verify that the response' url is being redirected to the expected url

const response = await request.get('https://example.com/user/profile');

await expect(response).toBeRedirected('https://example.com/auth/login');

Author

Yevhen Laichenkov [e-mail]

License

MIT