@argos-ci/playwright 6.4.2 → 6.6.0

package/dist/reporter.mjs

@@ -0,0 +1,323 @@
+import { createRequire } from "node:module";
+import chalk from "chalk";
+import { readConfig, upload } from "@argos-ci/core";
+import { copyFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { createDirectory, createTemporaryDirectory, getGitRepositoryPath, readVersionFromPackage } from "@argos-ci/util";
+import { AsyncLocalStorage } from "node:async_hooks";
+import "@argos-ci/browser";
+import createDebug from "debug";
+//#region src/metadata.ts
+const require$1 = createRequire(import.meta.url);
+/**
+* Try to resolve a package.
+*/
+function tryResolve(pkg) {
+	try {
+		return require$1.resolve(pkg);
+	} catch {
+		return null;
+	}
+}
+/**
+* Private metadata config storage.
+* Used to inject the metadata from other SDKs like @argos-ci/storybook.
+*/
+const metadataConfigStorage = new AsyncLocalStorage();
+const DEFAULT_PLAYWRIGHT_LIBRARIES = [
+	"@playwright/test",
+	"playwright",
+	"playwright-core"
+];
+/**
+* Get the name and version of the automation library.
+*/
+async function getAutomationLibraryMetadata() {
+	const libraries = metadataConfigStorage.getStore()?.playwrightLibraries ?? DEFAULT_PLAYWRIGHT_LIBRARIES;
+	for (const name of libraries) {
+		const pkgPath = tryResolve(`${name}/package.json`);
+		if (pkgPath) return {
+			version: await readVersionFromPackage(pkgPath),
+			name
+		};
+	}
+	throw new Error(`Unable to find any of the following packages: ${libraries.join(", ")}`);
+}
+/**
+* Get the version of the Argos Playwright SDK.
+*/
+async function getArgosPlaywrightVersion() {
+	return readVersionFromPackage(require$1.resolve("@argos-ci/playwright/package.json"));
+}
+/**
+* Get the name and version of the SDK.
+*/
+async function getSdkMetadata() {
+	const metadataConfig = metadataConfigStorage.getStore();
+	if (metadataConfig) return metadataConfig.sdk;
+	return {
+		name: "@argos-ci/playwright",
+		version: await getArgosPlaywrightVersion()
+	};
+}
+/**
+* Get the metadata of the automation library and the SDK.
+*/
+async function getLibraryMetadata() {
+	const [automationLibrary, sdk] = await Promise.all([getAutomationLibraryMetadata(), getSdkMetadata()]);
+	return {
+		automationLibrary,
+		sdk
+	};
+}
+async function getTestMetadataFromTestCase(testCase, testResult) {
+	const repositoryPath = await getGitRepositoryPath();
+	return {
+		title: testCase.title,
+		titlePath: testCase.titlePath(),
+		tags: testCase.tags.length > 0 ? testCase.tags : void 0,
+		retry: testResult.retry,
+		retries: testCase.retries,
+		repeat: testCase.repeatEachIndex,
+		location: {
+			file: repositoryPath ? relative(repositoryPath, testCase.location.file) : testCase.location.file,
+			line: testCase.location.line,
+			column: testCase.location.column
+		},
+		annotations: testCase.annotations
+	};
+}
+async function getMetadataFromTestCase(testCase, testResult) {
+	const [libMetadata, testMetadata] = await Promise.all([getLibraryMetadata(), getTestMetadataFromTestCase(testCase, testResult)]);
+	return {
+		test: testMetadata,
+		...libMetadata
+	};
+}
+createRequire(import.meta.url);
+const PNG_EXTENSION = `.png`;
+const ARIA_EXTENSION = `.aria.yml`;
+const METADATA_EXTENSION = `.argos.json`;
+/**
+* Maximum length for a screenshot name.
+*/
+const MAX_NAME_LENGTH = 255 - PNG_EXTENSION.length - METADATA_EXTENSION.length;
+/**
+* Truncate a text to a length and add `...`
+*/
+function truncate(text, length) {
+	if (text.length <= length) return text;
+	return text.slice(0, length - 1) + "…";
+}
+/**
+* Get the automatic screenshot name.
+*/
+function getAutomaticScreenshotName(test, result) {
+	const name = test.titlePath().join(" ");
+	let suffix = "";
+	suffix += result.retry > 0 ? ` #${result.retry + 1}` : "";
+	suffix += result.status === "failed" || result.status === "timedOut" ? " (failed)" : "";
+	const maxNameLength = MAX_NAME_LENGTH - suffix.length;
+	if (name.length > maxNameLength) return `${truncate(`${test.id} - ${test.title}`, maxNameLength)}${suffix}`;
+	return `${name}${suffix}`;
+}
+//#endregion
+//#region src/attachment.ts
+function parseAttachmentName(name) {
+	const match = name.match(/^argos\/(screenshot|aria)(\/metadata)?___(.*)$/);
+	if (!match) return null;
+	const [, mainType, metadataPart, originalName] = match;
+	if (!originalName) throw new Error(`Invalid attachment name: ${name}`);
+	return {
+		type: metadataPart ? `${mainType}/metadata` : mainType,
+		originalName
+	};
+}
+function getAttachmentFilename(attachment) {
+	const parsed = parseAttachmentName(attachment.name);
+	if (!parsed) throw new Error(`Invalid attachment name: ${attachment.name}`);
+	const { type, originalName } = parsed;
+	return `${originalName}${{
+		screenshot: PNG_EXTENSION,
+		aria: ARIA_EXTENSION,
+		"screenshot/metadata": `${PNG_EXTENSION}${METADATA_EXTENSION}`,
+		"aria/metadata": `${ARIA_EXTENSION}${METADATA_EXTENSION}`
+	}[type]}`;
+}
+function checkIsTrace(attachment) {
+	return attachment.name === "trace" && attachment.contentType === "application/zip" && Boolean(attachment.path);
+}
+function checkIsArgosSnapshot(attachment) {
+	const parsed = parseAttachmentName(attachment.name);
+	if (!parsed) return false;
+	return parsed.type === "aria" || parsed.type === "screenshot";
+}
+function checkIsArgosMetadata(attachment) {
+	const parsed = parseAttachmentName(attachment.name);
+	if (!parsed) return false;
+	return parsed.type === "aria/metadata" || parsed.type === "screenshot/metadata";
+}
+function checkIsAutomaticScreenshot(attachment) {
+	return attachment.name === "screenshot" && attachment.contentType === "image/png" && Boolean(attachment.path);
+}
+const debug = createDebug("@argos-ci/playwright");
+//#endregion
+//#region src/reporter.ts
+/**
+* Check if the build name is dynamic.
+*/
+function checkIsDynamicBuildName(buildName) {
+	return Boolean(typeof buildName === "object" && buildName);
+}
+function createArgosReporterOptions(options) {
+	return options;
+}
+async function getParallelFromConfig(config) {
+	if (!config.shard) return null;
+	if (config.shard.total === 1) return null;
+	const argosConfig = await readConfig();
+	if (!argosConfig.parallelNonce) throw new Error("Playwright shard mode detected. Please specify ARGOS_PARALLEL_NONCE env variable. Read /parallel-testing");
+	return {
+		total: argosConfig.parallelTotal ?? config.shard.total,
+		nonce: argosConfig.parallelNonce,
+		index: argosConfig.parallelIndex ?? config.shard.current
+	};
+}
+var ArgosReporter = class {
+	rootUploadDirectoryPromise;
+	uploadDirectoryPromises;
+	config;
+	playwrightConfig;
+	uploadToArgos;
+	constructor(config) {
+		this.config = config;
+		this.uploadToArgos = config.uploadToArgos ?? true;
+		this.rootUploadDirectoryPromise = null;
+		this.uploadDirectoryPromises = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Write a file to the temporary directory.
+	*/
+	async writeFile(path, body) {
+		await createDirectory(dirname(path));
+		debug(`Writing file to ${path}`);
+		await writeFile(path, body);
+		debug(`File written to ${path}`);
+	}
+	/**
+	* Copy a file to the temporary directory.
+	*/
+	async copyFile(from, to) {
+		await createDirectory(dirname(to));
+		debug(`Copying file from ${from} to ${to}`);
+		await copyFile(from, to);
+		debug(`File copied from ${from} to ${to}`);
+	}
+	/**
+	* Copy the trace file if found in the result.
+	*/
+	async copyTraceIfFound(result, path) {
+		const trace = result.attachments.find(checkIsTrace) ?? null;
+		if (trace) await this.copyFile(trace.path, path + ".pw-trace.zip");
+	}
+	/**
+	* Get the root upload directory (cached).
+	*/
+	getRootUploadDirectory() {
+		if (!this.rootUploadDirectoryPromise) this.rootUploadDirectoryPromise = createTemporaryDirectory();
+		return this.rootUploadDirectoryPromise;
+	}
+	onBegin(config) {
+		debug("ArgosReporter:onBegin");
+		this.playwrightConfig = config;
+	}
+	async onTestEnd(test, result) {
+		const buildName = checkIsDynamicBuildName(this.config.buildName) ? this.config.buildName.get(test) : this.config.buildName;
+		if (buildName === "") throw new Error("Argos \"buildName\" cannot be an empty string.");
+		const rootUploadDir = await this.getRootUploadDirectory();
+		const uploadDir = buildName ? join(rootUploadDir, buildName) : rootUploadDir;
+		debug("ArgosReporter:onTestEnd");
+		await Promise.all(result.attachments.map(async (attachment) => {
+			if (checkIsArgosSnapshot(attachment) || checkIsArgosMetadata(attachment)) {
+				const path = join(uploadDir, getAttachmentFilename(attachment));
+				await Promise.all([this.copyFile(attachment.path, path), this.copyTraceIfFound(result, path)]);
+				return;
+			}
+			if (checkIsAutomaticScreenshot(attachment)) {
+				const metadata = await getMetadataFromTestCase(test, result);
+				const path = join(uploadDir, `${getAutomaticScreenshotName(test, result)}${PNG_EXTENSION}`);
+				await Promise.all([
+					this.writeFile(path + METADATA_EXTENSION, JSON.stringify(metadata)),
+					this.copyFile(attachment.path, path),
+					this.copyTraceIfFound(result, path)
+				]);
+				return;
+			}
+		}));
+	}
+	async onEnd(result) {
+		debug("ArgosReporter:onEnd");
+		const rootUploadDir = await this.getRootUploadDirectory();
+		if (!this.uploadToArgos) {
+			debug("Not uploading to Argos because uploadToArgos is false.");
+			debug(`Upload directory: ${rootUploadDir}`);
+			return;
+		}
+		debug("Getting parallel from config");
+		const parallel = await getParallelFromConfig(this.playwrightConfig);
+		if (parallel) debug(`Using parallel config — total: ${parallel.total}, nonce: "${parallel.nonce}"`);
+		else debug("Non-parallel mode");
+		const buildNameConfig = this.config.buildName;
+		const uploadOptions = {
+			files: ["**/*.png", "**/*.aria.yml"],
+			parallel: parallel ?? void 0,
+			...this.config,
+			buildName: void 0,
+			metadata: { testReport: {
+				status: result.status,
+				stats: {
+					startTime: result.startTime.toISOString(),
+					duration: result.duration
+				}
+			} }
+		};
+		try {
+			if (checkIsDynamicBuildName(buildNameConfig)) {
+				debug(`Dynamic build names, uploading to Argos for each build name: ${buildNameConfig.values.join()}`);
+				const directories = await readdir(rootUploadDir);
+				if (directories.some((dir) => !buildNameConfig.values.includes(dir))) throw new Error(`The \`buildName.values\` (${buildNameConfig.values.join(", ")}) are inconsistent with the \`buildName.get\` returns values (${directories.join(", ")}). Please fix the configuration.`);
+				const iteratesOnBuildNames = parallel ? buildNameConfig.values : directories;
+				for (const buildName of iteratesOnBuildNames) {
+					const uploadDir = join(rootUploadDir, buildName);
+					await createDirectory(uploadDir);
+					debug(`Uploading to Argos for build: ${buildName}`);
+					const res = await upload({
+						...uploadOptions,
+						root: uploadDir,
+						buildName
+					});
+					console.log(chalk.green(`✅ Argos "${buildName}" build created: ${res.build.url}`));
+				}
+			} else {
+				debug("Uploading to Argos");
+				const uploadDir = buildNameConfig ? join(rootUploadDir, buildNameConfig) : rootUploadDir;
+				const res = await upload({
+					...uploadOptions,
+					root: uploadDir,
+					buildName: buildNameConfig ?? void 0
+				});
+				console.log(chalk.green(`✅ Argos build created: ${res.build.url}`));
+			}
+		} catch (error) {
+			console.error(chalk.red(`❌ Error while creating the Argos build`));
+			console.error(error);
+			if (!this.config.ignoreUploadFailures) return { status: "failed" };
+			else console.warn(chalk.yellow("⚠️  Upload failure ignored due to ignoreUploadFailures option"));
+		}
+	}
+	printsToStdio() {
+		return false;
+	}
+};
+//#endregion
+export { createArgosReporterOptions, ArgosReporter as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@argos-ci/playwright",
   "description": "Playwright SDK for visual testing with Argos.",
-  "version": "6.4.2",
+  "version": "6.6.0",
   "author": "Smooth Code",
   "license": "MIT",
   "repository": {
@@ -28,18 +28,18 @@
     "access": "public"
   },
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
     "./reporter": {
-      "types": "./dist/reporter.d.ts",
-      "import": "./dist/reporter.js",
-      "default": "./dist/reporter.js"
+      "types": "./dist/reporter.d.mts",
+      "import": "./dist/reporter.mjs",
+      "default": "./dist/reporter.mjs"
     },
     "./package.json": "./package.json"
   },
@@ -47,20 +47,20 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@argos-ci/browser": "5.1.2",
-    "@argos-ci/core": "5.1.1",
-    "@argos-ci/util": "3.2.0",
+    "@argos-ci/browser": "5.1.3",
+    "@argos-ci/core": "5.1.3",
+    "@argos-ci/util": "3.4.0",
     "chalk": "^5.6.2",
     "debug": "^4.4.3"
   },
   "devDependencies": {
-    "@playwright/test": "^1.58.1",
-    "@types/debug": "^4.1.12",
+    "@playwright/test": "^1.58.2",
+    "@types/debug": "^4.1.13",
     "@types/node": "catalog:",
     "vitest": "catalog:"
   },
   "scripts": {
-    "build": "tsup && cp ./src/index.cjs ./dist",
+    "build": "tsdown && cp ./src/index.cjs ./dist",
     "test-e2e": "pnpm exec -- playwright test",
     "build-e2e": "playwright install chromium --with-deps",
     "e2e": "UPLOAD_TO_ARGOS=true pnpm run test-e2e",
@@ -69,5 +69,5 @@
     "lint": "eslint .",
     "test": "vitest src"
   },
-  "gitHead": "52b2c59dc89e972ea9951dc7a94bf8f7d7922e4a"
+  "gitHead": "b49d186d5eb6e1338982a4cd5c3cb29e6cb0b7af"
 }

package/dist/index.d.ts

@@ -1,158 +0,0 @@
-import { Locator, Page, Frame, ElementHandle, PageScreenshotOptions, LocatorScreenshotOptions } from '@playwright/test';
-import { StabilizationPluginOptions, ViewportOption } from '@argos-ci/browser';
-import { ScreenshotMetadata } from '@argos-ci/util';
-
-type ArgosAttachment = {
-    name: string;
-    contentType: string;
-    path: string;
-};
-
-type LocatorOptions$1 = Parameters<Page["locator"]>[1];
-type ArgosSnapshotOptions = {
-    /**
-     * `Locator` or string selector of the element to take a snapshot of.
-     */
-    element?: string | Locator;
-    /**
-     * Folder where the snapshots will be saved if not using the Argos reporter.
-     * @default "./screenshots"
-     */
-    root?: string;
-    /**
-     * Wait for the UI to stabilize before taking the snapshot.
-     * Set to `false` to disable stabilization.
-     * Pass an object to customize the stabilization.
-     * @default true
-     */
-    stabilize?: boolean | StabilizationPluginOptions;
-    /**
-     * Maximum time in milliseconds. Defaults to `0` - no timeout
-     */
-    timeout?: number;
-} & LocatorOptions$1;
-/**
- * Stabilize the UI and takes a snapshot of the application under test.
- *
- * @example
- *    argosAriaSnapshot(page, "my-screenshot")
- * @see https://playwright.dev/docs/aria-snapshots
- */
-declare function argosAriaSnapshot(
-/**
- * Playwright `page` or `frame` object.
- */
-handler: Page | Frame, 
-/**
- * Name of the snapshot. Must be unique.
- */
-name: string, 
-/**
- * Options for the snapshot.
- */
-options?: ArgosSnapshotOptions): Promise<ArgosAttachment[]>;
-
-type LocatorOptions = Parameters<Page["locator"]>[1];
-type ScreenshotOptions<TBase extends PageScreenshotOptions | LocatorScreenshotOptions> = Omit<TBase, "encoding" | "type" | "omitBackground" | "path">;
-type ArgosScreenshotOptions = {
-    /**
-     * `Locator` or string selector of the element to take a screenshot of.
-     * Passing an `ElementHandle` is discouraged, use a `Locator` instead.
-     */
-    element?: string | ElementHandle | Locator;
-    /**
-     * Viewports to take screenshots of.
-     */
-    viewports?: ViewportOption[];
-    /**
-     * Capture an ARIA snapshot along with the screenshot.
-     * Each ARIA snapshot counts as an additional screenshot for billing.
-     * When using the viewports setting, one ARIA snapshot is taken per viewport.
-     * @see https://playwright.dev/docs/aria-snapshots#aria-snapshots
-     * @default false
-     */
-    ariaSnapshot?: boolean;
-    /**
-     * Custom CSS evaluated during the screenshot process.
-     */
-    argosCSS?: string;
-    /**
-     * Disable hover effects by moving the mouse to the top-left corner of the document.
-     * @default true
-     */
-    disableHover?: boolean;
-    /**
-     * Sensitivity threshold between 0 and 1.
-     * The higher the threshold, the less sensitive the diff will be.
-     * @default 0.5
-     */
-    threshold?: number;
-    /**
-     * Folder where the screenshots will be saved if not using the Argos reporter.
-     * @default "./screenshots"
-     */
-    root?: string;
-    /**
-     * Wait for the UI to stabilize before taking the screenshot.
-     * Set to `false` to disable stabilization.
-     * Pass an object to customize the stabilization.
-     * @default true
-     */
-    stabilize?: boolean | StabilizationPluginOptions;
-    /**
-     * Run a function before taking the screenshot.
-     * When using viewports, this function will run before taking sreenshots on each viewport.
-     */
-    beforeScreenshot?: (api: {
-        /**
-         * Run Argos stabilization alorithm.
-         * Accepts an object to customize the stabilization.
-         * Note that this function is independent of the `stabilize` option.
-         */
-        runStabilization: (options?: StabilizationPluginOptions) => Promise<void>;
-    }) => Promise<void> | void;
-    /**
-     * Run a function after taking the screenshot.
-     * When using viewports, this function will run after taking sreenshots on each viewport.
-     */
-    afterScreenshot?: () => Promise<void> | void;
-} & LocatorOptions & ScreenshotOptions<LocatorScreenshotOptions> & ScreenshotOptions<PageScreenshotOptions>;
-/**
- * Stabilize the UI and takes a screenshot of the application under test.
- *
- * @example
- *    argosScreenshot(page, "my-screenshot")
- * @see https://argos-ci.com/docs/playwright#api-overview
- */
-declare function argosScreenshot(
-/**
- * Playwright `page` or `frame` object.
- */
-handler: Page | Frame, 
-/**
- * Name of the screenshot. Must be unique.
- */
-name: string, 
-/**
- * Options for the screenshot.
- */
-options?: ArgosScreenshotOptions): Promise<ArgosAttachment[]>;
-
-/**
- * Get the CSP script hash.
- */
-declare function getCSPScriptHash(): string;
-
-type MetadataConfig = {
-    sdk: ScreenshotMetadata["sdk"];
-    playwrightLibraries: string[];
-    url?: string;
-    test?: ScreenshotMetadata["test"];
-    viewport?: ScreenshotMetadata["viewport"];
-};
-/**
- * Set the metadata config.
- */
-declare function setMetadataConfig(metadata: MetadataConfig): void;
-
-export { type ArgosAttachment, type ArgosScreenshotOptions, type ArgosSnapshotOptions, setMetadataConfig as DO_NOT_USE_setMetadataConfig, type MetadataConfig, argosAriaSnapshot, argosScreenshot, getCSPScriptHash };