@prismicio/e2e-tests-utils 1.4.0-alpha.2 → 1.4.1

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,10 +1,12 @@
-import { APIResponse, request } from "@playwright/test";
+import { APIResponse } from "@playwright/test";
 
-export interface Error {
+import { AuthenticatedApiClient } from "./apiClient";
+
+export interface ContentApiError {
 	type: string;
 	message: string;
 }
-export interface SearchResponse {
+export interface ContentApiSearchResponse {
 	page: number;
 	results_per_page: number;
 	results_size: number;
@@ -12,10 +14,10 @@ export interface SearchResponse {
 	total_pages: number;
 	next_page: string | null;
 	prev_page: string | null;
-	results: Document[];
+	results: ContentApiDocument[];
 }
 
-export interface Document {
+export interface ContentApiDocument {
 	id: string;
 	uid: string | null;
 	url: string | null;
@@ -32,22 +34,22 @@ export interface Document {
 	data: Record<string, any>;
 }
 
-export interface GraphQLResponse {
+export interface ContentApiGraphQLResponse {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	data: Record<string, any>;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	errors?: { message: string; locations: any }[];
 }
 
-export interface Ref {
+export interface ContentApiRef {
 	id: string;
 	ref: string;
 	label: string;
 	isMasterRef?: boolean;
 }
 
-export interface RepoConfig {
-	refs: Ref[];
+interface ContentApiRepoConfigResponse {
+	refs: ContentApiRef[];
 	bookmarks: Record<string, unknown>;
 	types: Record<string, string>;
 	languages: {
@@ -62,7 +64,7 @@ export interface RepoConfig {
 	version: string;
 }
 
-export type QueryParams = {
+type SearchQueryParams = {
 	ref?: string;
 	query?: string;
 	q?: string;
@@ -80,18 +82,22 @@ 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 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 new ContentApiClient("https://my-repo.cdn.prismic.io" { version :
-	 * "v2", accessToken: "my-secret-token" })
+	 * @example To instantiate the class:
+	 *
+	 * ```js
+	 * new ContentApiClient("https://my-repo.cdn.prismic.io", {
+	 * 	version: "v2",
+	 * 	accessToken: "my-secret-token",
+	 * });
+	 * ```
 	 *
 	 * @param baseURL - the api base URL like https://my-repo.cdn.prismic.io
 	 * @param config - Optional configuration
@@ -101,30 +107,25 @@ 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 Authorization header in case it is already set globally in the project Playwright config file.
+		// This is because the content api returns an error in case it gets an non-empty invalid Authorization
+		// even though it actually checks authorization from the access_token query parameter.
+		super(baseURL, config.accessToken || "");
+		this.version = config.version || "v2";
+		this.accessToken = config.accessToken;
 	}
 
 	async get(
 		path: string,
-		params?: QueryParams,
+		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, {
@@ -135,7 +136,7 @@ export class ContentApiClient {
 
 	async getAsJson<T>(
 		url: string,
-		params?: QueryParams,
+		params?: SearchQueryParams,
 		headers?: Record<string, string>,
 	): Promise<T> {
 		const response = await this.get(url, params, headers);
@@ -144,16 +145,21 @@ export class ContentApiClient {
 	}
 
 	/** Query the graphql api - https://prismic.io/docs/graphql-technical-reference */
-	async graphql(ref: string, query: string): Promise<GraphQLResponse> {
-		return this.getAsJson<GraphQLResponse>(
-			"/graphql",
+	async graphql(
+		ref: string,
+		query: string,
+	): Promise<ContentApiGraphQLResponse> {
+		return this.getAsJson<ContentApiGraphQLResponse>(
+			"graphql",
 			{ query },
 			{ "Prismic-ref": ref },
 		);
 	}
 
-	async getRefs(): Promise<Ref[]> {
-		const data = await this.getAsJson<RepoConfig>(`/api/${this.#version}`);
+	async getRefs(): Promise<ContentApiRef[]> {
+		const data = await this.getAsJson<ContentApiRepoConfigResponse>(
+			`api/${this.version}`,
+		);
 
 		return data.refs;
 	}
@@ -180,14 +186,14 @@ export class ContentApiClient {
 	}
 
 	/** Search documents from the `/api/v<version>/documents/search` endpoint. */
-	async search(filters?: QueryParams): Promise<SearchResponse> {
+	async search(filters?: SearchQueryParams): Promise<ContentApiSearchResponse> {
 		let ref = filters?.ref;
 		if (!ref) {
 			ref = await this.getMasterRef();
 		}
 
-		return this.getAsJson<SearchResponse>(
-			`/api/${this.#version}/documents/search`,
+		return this.getAsJson<ContentApiSearchResponse>(
+			`api/${this.version}/documents/search`,
 			{
 				...filters,
 				ref,
@@ -199,15 +205,18 @@ export class ContentApiClient {
 	 * Search for a single document by its it, using the
 	 * `/api/v<version>/documents/search` endpoint and a default filter.
 	 */
-	async searchByID(id: string, filters?: QueryParams): Promise<SearchResponse> {
+	async searchByID(
+		id: string,
+		filters?: SearchQueryParams,
+	): Promise<ContentApiSearchResponse> {
 		return this.search({ ...filters, q: `[[at(document.id, "${id}")]]` });
 	}
 
 	/** Retrieve a single document or undefined if not found. */
 	async getDocumentByID(
 		id: string,
-		filters?: QueryParams,
-	): Promise<Document | undefined> {
+		filters?: SearchQueryParams,
+	): Promise<ContentApiDocument | undefined> {
 		const data = await this.searchByID(id, filters);
 		switch (data.results_size) {
 			case 0:

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,
-	};
-};
+}