Auth flows + JSON Schema

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

test('basic auth via httpCredentials', async () => {
  const ctx = await request.newContext({
    baseURL: 'https://httpbin.org',
    httpCredentials: { username: 'demo', password: 'pass' },
  });

  const res = await ctx.get('/basic-auth/demo/pass');
  expect(res.status()).toBe(200);
  expect((await res.json()).authenticated).toBe(true);

  const wrong = await ctx.get('/basic-auth/demo/different');
  expect(wrong.status()).toBe(401);

  await ctx.dispose();
});

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

export async function getSpotifyToken(id: string, secret: string) {
  const ctx = await request.newContext();
  const body = new URLSearchParams({ grant_type: 'client_credentials' });
  const creds = Buffer.from(`${id}:${secret}`).toString('base64');

  const res = await ctx.post('https://accounts.spotify.com/api/token', {
    headers: {
      'Authorization': `Basic ${creds}`,
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    data: body.toString(),
  });
  if (!res.ok()) throw new Error(`token request failed: ${res.status()}`);
  const json = await res.json();
  await ctx.dispose();
  return json as { access_token: string; expires_in: number; token_type: 'Bearer' };
}

import { test, expect, request } from '@playwright/test';
import { getSpotifyToken } from '../lib/spotify';

test('new releases endpoint returns 20 albums', async () => {
  const { access_token } = await getSpotifyToken(
    process.env.SPOTIFY_CLIENT_ID!,
    process.env.SPOTIFY_CLIENT_SECRET!,
  );

  const ctx = await request.newContext({
    baseURL: 'https://api.spotify.com',
    extraHTTPHeaders: { 'Authorization': `Bearer ${access_token}` },
  });

  const res = await ctx.get('/v1/browse/new-releases?limit=20');
  expect(res.status()).toBe(200);
  const body = await res.json();
  expect(body.albums.items).toHaveLength(20);
  await ctx.dispose();
});

import { APIRequestContext, request } from '@playwright/test';
import { getSpotifyToken } from './spotify';

let currentToken: string | null = null;

async function freshContext(): Promise<APIRequestContext> {
  const { access_token } = await getSpotifyToken(
    process.env.SPOTIFY_CLIENT_ID!,
    process.env.SPOTIFY_CLIENT_SECRET!,
  );
  currentToken = access_token;
  return request.newContext({
    baseURL: 'https://api.spotify.com',
    extraHTTPHeaders: { 'Authorization': `Bearer ${access_token}` },
  });
}

export async function getWithRefresh(path: string) {
  let ctx = await freshContext();
  let res = await ctx.get(path);
  if (res.status() === 401) {
    await ctx.dispose();
    ctx = await freshContext();
    res = await ctx.get(path);
  }
  const body = await res.json();
  await ctx.dispose();
  return { status: res.status(), body };
}

npm install ajv ajv-formats --save-dev

import Ajv, { ErrorObject } from 'ajv';
import addFormats from 'ajv-formats';

const ajv = new Ajv({ allErrors: true, strict: false });
addFormats(ajv);  // date, date-time, email, uri, uuid, etc.

export { ajv };
export type { ErrorObject };

import { expect } from '@playwright/test';
import { ajv } from './ajv';

expect.extend({
  toMatchSchema(received: unknown, schema: object) {
    const validate = ajv.compile(schema);
    const ok = validate(received);
    if (ok) return { pass: true, message: () => 'matched' };

    const details = (validate.errors ?? []).map(e =>
      `${e.instancePath || '(root)'} ${e.message}`
    ).join('\n');

    return {
      pass: false,
      message: () => `Schema mismatch:\n${details}`,
    };
  },
});

declare module '@playwright/test' {
  interface Matchers<R> {
    toMatchSchema(schema: object): R;
  }
}

import '../lib/matcher';

export default defineConfig({
  globalSetup: './tests/setup.ts',
  // ...rest of config
});

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "email": { "type": "string", "format": "email" }
  },
  "required": ["email"],
  "additionalProperties": false
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "booking",
  "type": "object",
  "properties": {
    "firstname": { "type": "string", "minLength": 1 },
    "lastname":  { "type": "string", "minLength": 1 },
    "totalprice": { "type": "number", "minimum": 0 },
    "depositpaid": { "type": "boolean" },
    "bookingdates": {
      "type": "object",
      "properties": {
        "checkin":  { "type": "string", "format": "date" },
        "checkout": { "type": "string", "format": "date" }
      },
      "required": ["checkin", "checkout"]
    },
    "additionalneeds": { "type": "string" }
  },
  "required": ["firstname", "lastname", "totalprice", "depositpaid", "bookingdates"],
  "additionalProperties": false
}

import { test, expect } from '@playwright/test';
import bookingSchema from '../schemas/booking.schema.json';

test('GET /booking/1 matches schema', async ({ request }) => {
  const res = await request.get('https://restful-booker.herokuapp.com/booking/1');
  expect(res.status()).toBe(200);
  const body = await res.json();
  expect(body).toMatchSchema(bookingSchema);
});

import { test, expect } from '@playwright/test';
import bookingSchema from '../schemas/booking.schema.json';

test.describe('contract drift', () => {
  test('/booking/{first} matches checked-in schema', async ({ request }) => {
    const list = await request.get('/booking');
    const ids = (await list.json()) as { bookingid: number }[];

    const res = await request.get(`/booking/${ids[0].bookingid}`);
    const body = await res.json();
    expect(body).toMatchSchema(bookingSchema);
  });
});