@prismicio/e2e-tests-utils 1.3.2 → 1.4.0

package/src/clients/authenticationApi.ts

@@ -1,82 +1,84 @@
-import axios, { AxiosInstance } from "axios";
+import { APIRequestContext, request } from "@playwright/test";
 
 import { AuthConfig } from "../types";
 
-import { logHttpResponse, logger } from "../utils/log";
-
-export type AuthenticationClient = {
-	getToken: () => Promise<string>;
-	getMachine2MachineToken: (repository: string) => Promise<string>;
-};
+import { logPlaywrightApiResponse, logger } from "../utils/log";
 
 /** Client for interacting with the authentication service to manage tokens */
-export const createAuthenticationApiClient = (
-	baseURL: string,
-	auth: AuthConfig,
-): AuthenticationClient => {
-	let authToken: string;
-
-	const client: AxiosInstance = axios.create({
-		baseURL,
-		validateStatus: () => true, // Don't throw on 4XX errors
-	});
-
-	async function login(): Promise<string> {
+export class AuthenticationApiClient {
+	private authToken?: string;
+	private _context?: APIRequestContext;
+
+	constructor(
+		private readonly baseURL: string,
+		private readonly auth: AuthConfig,
+	) {}
+
+	private async getContext(): Promise<APIRequestContext> {
+		if (!this._context) {
+			this._context = await request.newContext({
+				baseURL: this.baseURL,
+			});
+		}
+
+		return this._context;
+	}
+
+	private async login(): Promise<string> {
 		const profiler = logger.startTimer();
 
-		const result = await client.post("login", {
-			email: auth.email,
-			password: auth.password,
+		const context = await this.getContext();
+		const result = await context.post("login", {
+			data: {
+				email: this.auth.email,
+				password: this.auth.password,
+			},
 		});
 
-		if (!result.data || typeof result.data !== "string") {
-			logHttpResponse(result);
+		const token = await result.text();
+		if (!result.ok() || !token) {
+			logPlaywrightApiResponse(result);
 			throw new Error("Authentication failed, no token received.");
 		}
 
 		profiler.done({
-			message: `generated user token for ${auth.email} from auth service`,
+			message: `generated user token for ${this.auth.email} from auth service`,
 		});
 
-		return result.data;
+		return token;
 	}
 
 	/** Return an api user token. Creates one if needed. */
-	async function getToken(): Promise<string> {
-		if (!authToken) {
-			authToken = await login();
+	async getToken(): Promise<string> {
+		if (!this.authToken) {
+			this.authToken = await this.login();
 		}
 
-		return authToken;
+		return this.authToken;
 	}
 
 	/** Return an api user token. Creates one if needed. */
-	async function getMachine2MachineToken(repository: string): Promise<string> {
-		if (!authToken) {
-			authToken = await login();
+	async getMachine2MachineToken(repository: string): Promise<string> {
+		if (!this.authToken) {
+			this.authToken = await this.login();
 		}
-		const result = await client.get<{ token: string; timestamp: number }>(
-			"machine2machine",
-			{
-				headers: {
-					Authorization: `Bearer ${authToken}`,
-					repository,
-				},
+
+		const context = await this.getContext();
+		const result = await context.get("machine2machine", {
+			headers: {
+				Authorization: `Bearer ${this.authToken}`,
+				repository,
 			},
-		);
+		});
 
-		if (![200].includes(result.status) || !result.data.token) {
-			logHttpResponse(result);
+		if (!result.ok()) {
+			logPlaywrightApiResponse(result);
 			throw new Error(
 				"Machine2Machine token generation failed, no token received.",
 			);
 		}
+		const token = (await result.json()).token;
 
-		return result.data.token;
+		return token;
 	}
-
-	return {
-		getToken,
-		getMachine2MachineToken,
-	};
-};
+}

package/src/clients/contentApi.ts

@@ -1,4 +1,6 @@
-import { APIResponse, request } from "@playwright/test";
+import { APIResponse } from "@playwright/test";
+
+import { AuthenticatedApiClient } from "./apiClient";
 
 export interface ContentApiError {
 	type: string;
@@ -80,14 +82,12 @@ type ApiVersions = "v1" | "v2";
 
 /**
  * Client to query the Prismic content api. Uses Playwright to benefit from
- * network request traces in your reports. The @prismicio/client package could
- * have been used but had too many abstractions (caching, error handling) that
- * we didn't want for test execution. See api docs:
+ * network request traces in your reports. See api docs:
  * https://prismic.io/docs/rest-api-technical-reference
  */
-export class ContentApiClient {
-	#version: ApiVersions;
-	#accessToken: string | undefined;
+export class ContentApiClient extends AuthenticatedApiClient {
+	private version: ApiVersions;
+	private accessToken: string | undefined;
 
 	/**
 	 * @example To instantiate the class:
@@ -107,20 +107,14 @@ export class ContentApiClient {
 	 *       https://prismic.io/docs/access-token
 	 */
 	constructor(
-		private readonly baseURL: string,
+		baseURL: string,
 		config: { version?: ApiVersions; accessToken?: string } = {},
 	) {
-		this.#version = config.version || "v2";
-		this.#accessToken = config.accessToken;
-	}
-
-	#context() {
-		return request.newContext({
-			baseURL: this.baseURL,
-			// reset any Authorization header set globally with Playwright
-			// didn't find a way to delete it
-			extraHTTPHeaders: { Authorization: "" },
-		});
+		// Use an empty string as auth header in case it is already set globally in the project Playwright config file.
+		// This is because the api returns an error whenever an auth header is present in the content api request.
+		super(baseURL, "");
+		this.version = config.version || "v2";
+		this.accessToken = config.accessToken;
 	}
 
 	async get(
@@ -128,9 +122,9 @@ export class ContentApiClient {
 		params?: SearchQueryParams,
 		headers?: Record<string, string>,
 	): Promise<APIResponse> {
-		const context = await this.#context();
+		const context = await this.getContext();
 		const securityParams = {
-			...(this.#accessToken ? { access_token: this.#accessToken } : {}),
+			...(this.accessToken ? { access_token: this.accessToken } : {}),
 		};
 
 		return context.get(path, {
@@ -155,7 +149,7 @@ export class ContentApiClient {
 		query: string,
 	): Promise<ContentApiGraphQLResponse> {
 		return this.getAsJson<ContentApiGraphQLResponse>(
-			"/graphql",
+			"graphql",
 			{ query },
 			{ "Prismic-ref": ref },
 		);
@@ -163,7 +157,7 @@ export class ContentApiClient {
 
 	async getRefs(): Promise<ContentApiRef[]> {
 		const data = await this.getAsJson<ContentApiRepoConfigResponse>(
-			`/api/${this.#version}`,
+			`api/${this.version}`,
 		);
 
 		return data.refs;
@@ -198,7 +192,7 @@ export class ContentApiClient {
 		}
 
 		return this.getAsJson<ContentApiSearchResponse>(
-			`/api/${this.#version}/documents/search`,
+			`api/${this.version}/documents/search`,
 			{
 				...filters,
 				ref,

package/src/clients/coreApi.ts

@@ -1,8 +1,6 @@
-import axios, { AxiosInstance } from "axios";
+import { logPlaywrightApiResponse, logger } from "../utils/log";
 
-import { logHttpResponse, logger } from "../utils/log";
-
-import { AuthenticationClient } from "./authenticationApi";
+import { AuthServerToken, AuthenticatedApiClient } from "./apiClient";
 
 type Language = {
 	id: string;
@@ -15,56 +13,52 @@ export type CoreClient = {
 	publishDraft(documentId: string): Promise<void>;
 };
 
-/** Client for interacting with the core API */
-export const createCoreApiClient = (
-	baseURL: string,
-	authClient: AuthenticationClient,
-): CoreClient => {
-	const client: AxiosInstance = axios.create({
-		baseURL,
-		validateStatus: () => true, // Don't throw on 4XX errors
-	});
-
-	// Add an interceptor to authenticate requests
-	client.interceptors.request.use(async (config) => {
-		const auth = "Authorization";
-		if (!config.headers[auth]) {
-			const token = await authClient.getToken();
-			config.headers[auth] = `Bearer ${token}`;
-		}
-
-		return config;
-	});
+export class CoreApiClient extends AuthenticatedApiClient {
+	/**
+	 * @example To instantiate the class:
+	 *
+	 * ```js
+	 * new CoreApiClient("https://my-repo.prismic.io", {
+	 * 	authToken: "my-secret-token",
+	 * });
+	 * ```
+	 *
+	 * @param baseURL - the api base URL like https://my-repo.prismic.io
+	 * @param config - Optional configuration
+	 *
+	 *   - {@link config.authToken}: Api token generated from the auth service or a
+	 *       function to fetch it when it's needed.
+	 */
+	constructor(baseURL: string, config: AuthServerToken) {
+		super(baseURL, config);
+	}
 
-	async function getLanguages(): Promise<Language[]> {
+	async getLanguages(): Promise<Language[]> {
 		const profiler = logger.startTimer();
-		const result = await client.get<{ languages: Language[] }>(
-			"core/repository",
-		);
+		const context = await this.getContext();
+		const result = await context.get("core/repository");
 
-		if (200 !== result.status || !result.data.languages) {
-			logHttpResponse(result);
+		if (200 !== result.status() || !(await result.json()).languages) {
+			await logPlaywrightApiResponse(result);
 			throw new Error("Could not get languages from the core api.");
 		}
 
 		profiler.done({ message: "retrieved languages configuration" });
 
-		return result.data.languages;
+		return (await result.json()).languages;
 	}
 
-	async function publishDraft(documentId: string): Promise<void> {
-		const result = await client.patch(`core/documents/${documentId}/draft`, {
-			status: "published",
+	async publishDraft(documentId: string): Promise<void> {
+		const context = await this.getContext();
+		const result = await context.patch(`core/documents/${documentId}/draft`, {
+			data: {
+				status: "published",
+			},
 		});
 
-		if (204 !== result.status) {
-			logHttpResponse(result);
+		if (204 !== result.status()) {
+			await logPlaywrightApiResponse(result);
 			throw new Error(`Could not publish document with id ${documentId}`);
 		}
 	}
-
-	return {
-		getLanguages,
-		publishDraft,
-	};
-};
+}

package/src/clients/customTypesApi.ts

@@ -1,4 +1,3 @@
-import axios, { AxiosInstance } from "axios";
 import isEqual from "lodash.isequal";
 
 import {
@@ -6,46 +5,25 @@ import {
 	SharedSlice,
 } from "@prismicio/types-internal/lib/customtypes";
 
-import { logHttpResponse, logger } from "../utils/log";
+import { logPlaywrightApiResponse, logger } from "../utils/log";
 
-import { AuthenticationClient } from "./authenticationApi";
+import { AuthServerToken, AuthenticatedApiClient } from "./apiClient";
 
-export type CustomTypesClient = {
-	createCustomTypes(customTypes: CustomType[]): Promise<void>;
-	createSlices(slices: SharedSlice[]): Promise<void>;
-};
+type ItemType = CustomType | SharedSlice;
+type ItemTypePath = "customtypes" | "slices";
+type ItemOperation = "insert" | "update";
 
 /**
  * Client for interacting with the Custom Types API to create/update custom
  * types and slices.
  */
-export const createCustomTypesApiClient = (
-	baseURL: string,
-	repository: string,
-	authClient: AuthenticationClient,
-): CustomTypesClient => {
-	type ItemType = CustomType | SharedSlice;
-	type ItemTypePath = "customtypes" | "slices";
-	type ItemOperation = "insert" | "update";
-
-	const client: AxiosInstance = axios.create({
-		baseURL,
-		validateStatus: () => true, // Don't throw on 4XX errors
-		headers: {
-			repository,
-		},
-	});
-
-	// Add an interceptor to authenticate requests
-	client.interceptors.request.use(async (config) => {
-		const auth = "Authorization";
-		if (!config.headers[auth]) {
-			const token = await authClient.getToken();
-			config.headers[auth] = `Bearer ${token}`;
-		}
-
-		return config;
-	});
+export class CustomTypesApiClient extends AuthenticatedApiClient {
+	constructor(
+		baseURL: string,
+		config: { authToken: AuthServerToken; repository: string },
+	) {
+		super(baseURL, config.authToken, { repository: config.repository });
+	}
 
 	/**
 	 * Create or update a custom type or slice.
@@ -57,7 +35,7 @@ export const createCustomTypesApiClient = (
 	 * @throws Error if the item status cannot be retrieved or the item cannot be
 	 *   created/updated.
 	 */
-	async function upsert(
+	private async upsert(
 		endpoint: ItemTypePath,
 		operation: ItemOperation,
 		data: ItemType,
@@ -65,9 +43,10 @@ export const createCustomTypesApiClient = (
 		const profiler = logger.startTimer();
 		const path = `${endpoint}/${operation}`;
 
-		const result = await client.post(path, data, { headers: {} });
-		if (![201, 204].includes(result.status)) {
-			logHttpResponse(result);
+		const context = await this.getContext();
+		const result = await context.post(path, { data });
+		if (!result.ok()) {
+			logPlaywrightApiResponse(result);
 			throw new Error(`Could not ${operation} item`);
 		}
 		profiler.done({
@@ -75,20 +54,21 @@ export const createCustomTypesApiClient = (
 		});
 	}
 
-	async function getRemoteItems(
+	private async getRemoteItems(
 		endpoint: ItemTypePath,
 	): Promise<CustomType[] | SharedSlice[]> {
-		const result = await client.get(endpoint);
+		const context = await this.getContext();
+		const result = await context.get(endpoint);
 
-		if (![200].includes(result.status)) {
-			logHttpResponse(result);
+		if (!result.ok()) {
+			logPlaywrightApiResponse(result);
 			throw new Error("Could not get items status from the Custom Type api.");
 		}
 
-		return result.data;
+		return result.json();
 	}
 
-	async function getDifference(
+	private async getDifference(
 		remoteItems: CustomType[] | SharedSlice[],
 		local: ItemType,
 	): Promise<ItemOperation | undefined> {
@@ -106,16 +86,16 @@ export const createCustomTypesApiClient = (
 	}
 
 	/** Create items only if they have changed compared to their remote status */
-	async function upsertIfChanged(
+	private async upsertIfChanged(
 		itemType: ItemTypePath,
 		localItems: ItemType[] = [],
-	) {
-		const remoteItems = await getRemoteItems(itemType);
+	): Promise<void> {
+		const remoteItems = await this.getRemoteItems(itemType);
 		await Promise.all(
 			localItems.map(async (localItem) => {
-				const operation = await getDifference(remoteItems, localItem);
+				const operation = await this.getDifference(remoteItems, localItem);
 
-				return operation && upsert(itemType, operation, localItem);
+				return operation && this.upsert(itemType, operation, localItem);
 			}),
 		);
 	}
@@ -125,8 +105,8 @@ export const createCustomTypesApiClient = (
 	 *
 	 * @param customTypes -
 	 */
-	async function createCustomTypes(customTypes: CustomType[] = []) {
-		await upsertIfChanged("customtypes", customTypes);
+	async createCustomTypes(customTypes: CustomType[] = []): Promise<void> {
+		await this.upsertIfChanged("customtypes", customTypes);
 	}
 
 	/**
@@ -134,12 +114,7 @@ export const createCustomTypesApiClient = (
 	 *
 	 * @param slices -
 	 */
-	async function createSlices(slices: SharedSlice[] = []) {
-		await upsertIfChanged("slices", slices);
+	async createSlices(slices: SharedSlice[] = []): Promise<void> {
+		await this.upsertIfChanged("slices", slices);
 	}
-
-	return {
-		createCustomTypes,
-		createSlices,
-	};
-};
+}

package/src/clients/migrationApi.ts

@@ -1,12 +1,6 @@
-import axios, { AxiosInstance } from "axios";
+import { logPlaywrightApiResponse } from "../utils/log";
 
-import { logHttpResponse } from "../utils/log";
-
-import { AuthenticationClient } from "./authenticationApi";
-
-export type MigrationClient = {
-	createDocument(data: DocumentPayload): Promise<DocumentResponse>;
-};
+import { AuthServerToken, AuthenticatedApiClient } from "./apiClient";
 
 export type DocumentPayload = {
 	uid?: string | null;
@@ -19,7 +13,6 @@ export type DocumentPayload = {
 	// if true, the document will be part of the documents list instead of in the migration release
 	inDocuments?: boolean;
 };
-
 export type DocumentResponse = {
 	id: string;
 	type: string;
@@ -28,45 +21,40 @@ export type DocumentResponse = {
 	uid?: string;
 };
 
-export const createMigrationApiClient = (
-	baseURL: string,
-	repository: string,
-	authClient: AuthenticationClient,
-): MigrationClient => {
-	const client: AxiosInstance = axios.create({
-		baseURL,
-		headers: {
-			repository,
-		},
-		validateStatus: () => true, // Don't throw on 4XX errors
-	});
-
-	// Add an interceptor to authenticate requests
-	client.interceptors.request.use(async (config) => {
-		const auth = "Authorization";
-		if (!config.headers[auth]) {
-			const token = await authClient.getToken();
-			config.headers[auth] = `Bearer ${token}`;
-		}
-		config.headers["repository"] = repository;
-
-		return config;
-	});
+export class MigrationApiClient extends AuthenticatedApiClient {
+	/**
+	 * @example To instantiate the class:
+	 *
+	 * ```js
+	 * new MigrationApiClient("https://migration.prismic.io", {
+	 * 	authToken: "my-secret-token",
+	 * 	repository: "my-repo-name",
+	 * });
+	 * ```
+	 *
+	 * @param baseURL - the api base URL like https://migration.prismic.io
+	 * @param config - Optional configuration
+	 *
+	 *   - {@link config.authToken}: Api token generated from the auth service or a
+	 *       function to fetch it when it's needed.
+	 *   - {@link config.repository}: Repository name.
+	 */
+	constructor(
+		baseURL: string,
+		config: { authToken: AuthServerToken; repository: string },
+	) {
+		super(baseURL, config.authToken, { repository: config.repository });
+	}
 
-	async function createDocument(
-		data: DocumentPayload,
-	): Promise<DocumentResponse> {
-		const result = await client.post<DocumentResponse>("/documents", data);
+	async createDocument(data: DocumentPayload): Promise<DocumentResponse> {
+		const context = await this.getContext();
+		const result = await context.post("documents", { data });
 
-		if (201 !== result.status) {
-			logHttpResponse(result);
+		if (201 !== result.status()) {
+			await logPlaywrightApiResponse(result);
 			throw new Error("Could not create a document with the migration api.");
 		}
 
-		return result.data;
+		return result.json();
 	}
-
-	return {
-		createDocument,
-	};
-};
+}