Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

3.0 KB
Raw Blame
import {
  test as base,
  type APIRequest,
  type APIRequestContext,
} from "@playwright/test";
import { readFileSync } from "fs";
import path from "path";
import { PLAYWRIGHT_API_BASE } from "./constants";

const authFile = path.join(__dirname, "../.auth/api.json");

type ApiResponse<T> = {
  status: number;
  data: T;
};

export type ApiClient = {
  get: <T>(url: string) => Promise<ApiResponse<T>>;
  post: <T>(url: string, data?: unknown) => Promise<ApiResponse<T>>;
  put: <T>(url: string, data?: unknown) => Promise<ApiResponse<T>>;
  patch: <T>(url: string, data?: unknown) => Promise<ApiResponse<T>>;
  delete: <T>(url: string) => Promise<ApiResponse<T>>;
};

type WorkerFixtures = {
  api: ApiClient;
  workspace: { id: string; slug: string };
};

export function loadApiAuth() {
  return JSON.parse(readFileSync(authFile, "utf-8")) as {
    token: string;
    workspaceId: string;
    workspaceSlug: string;
  };
}

export function createApiClient(request: APIRequestContext): ApiClient {
  async function parse<T>(
    responsePromise: ReturnType<APIRequestContext["fetch"]>,
  ): Promise<ApiResponse<T>> {
    const response = await responsePromise;
    return {
      status: response.status(),
      data: (await response.json()) as T,
    };
  }

  return {
    get: <T>(url: string) => parse<T>(request.get(url)),
    post: <T>(url: string, data?: unknown) =>
      parse<T>(request.post(url, { data })),
    put: <T>(url: string, data?: unknown) =>
      parse<T>(request.put(url, { data })),
    patch: <T>(url: string, data?: unknown) =>
      parse<T>(request.patch(url, { data })),
    delete: <T>(url: string) => parse<T>(request.delete(url)),
  };
}

export async function createBearerApiClient({
  playwright,
  token,
  baseURL = PLAYWRIGHT_API_BASE,
}: {
  playwright: { request: APIRequest };
  token: string;
  baseURL?: string;
}) {
  const context = await playwright.request.newContext({
    baseURL,
    extraHTTPHeaders: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
  });

  return {
    api: createApiClient(context),
    dispose: () => context.dispose(),
  };
}

export const test = base.extend<{}, WorkerFixtures>({
  // Authenticated API client (token from globalSetup → .auth/api.json).
  // Worker-scoped so beforeAll hooks can use api (Playwright rejects test-scoped fixtures there).
  api: [
    async ({ playwright }, use, workerInfo) => {
      const { token } = loadApiAuth();
      const context = await playwright.request.newContext({
        baseURL: workerInfo.project.use.baseURL,
        extraHTTPHeaders: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
        },
      });
      await use(createApiClient(context));
      await context.dispose();
    },
    { scope: "worker" },
  ],

  workspace: [
    async ({}, use) => {
      const { workspaceId, workspaceSlug } = loadApiAuth();
      await use({ id: workspaceId, slug: workspaceSlug });
    },
    { scope: "worker" },
  ],
});