pomwright 1.5.0 → 2.0.0

package/srcV2/helpers/playwrightReportLogger.ts

@@ -1,196 +0,0 @@
-import type { TestInfo } from "@playwright/test";
-
-// Defines valid log levels as a union of string literal types.
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-// Defines the structure of a log entry.
-export type LogEntry = {
-	timestamp: Date;
-	logLevel: LogLevel;
-	prefix: string;
-	message: string;
-};
-
-/**
- * PlaywrightReportLogger is a logger implementation designed for Playwright tests.
- * It records log messages and attaches them to the Playwright HTML report.
- *
- * The logger enables all fixtures implementing a child logger to share the same log level
- * within the scope of a single test, independant of other tests run in parallell.
- * In the same way each fixture will share a single logEntry for recording all log
- * statements produced throughout the tests execution, when the test is done, all log
- * entries are chronologically sorted and attached to the playwright HTML report.
- *
- * Log messages can be recorded with various log levels (debug, info, warn, error).
- *
- * The getNewChildLogger method allows you to create a new 'child' logger instance
- * with a new contextual name (e.g. the class it's used in), while sharing the logLevel
- * and LogEntry with the 'parent' fixture.
- *
- * @example
- * 20:49:50 05.05.2023 - DEBUG : [TestCase]
- * 20:49:50 05.05.2023 - DEBUG : [TestCase -> MobilEier]
- * 20:49:51 05.05.2023 - ERROR : [TestCase -> MobilEier -> Axe]
- * 20:49:52 05.05.2023 - INFO : [TestCase -> MobilEier]
- * 20:49:52 05.05.2023 - DEBUG : [TestCase -> MobilEier -> GetBy]
- */
-export class PlaywrightReportLogger {
-	private readonly contextName: string;
-	private readonly logLevels: LogLevel[] = ["debug", "info", "warn", "error"];
-
-	// Initializes the logger with shared log level, log entries, and a context name.
-	constructor(
-		private sharedLogLevel: { current: LogLevel; initial: LogLevel },
-		private sharedLogEntry: LogEntry[],
-		contextName: string,
-	) {
-		this.contextName = contextName;
-	}
-
-	/**
-	 * Creates a child logger with a new contextual name, sharing the same log level and log entries with the parent logger.
-	 *
-	 * The root loggers log "level" is referenced by all child loggers and their child loggers and so on...
-	 * Changing the log "level" of one, will change it for all.
-	 */
-	getNewChildLogger(prefix: string): PlaywrightReportLogger {
-		return new PlaywrightReportLogger(this.sharedLogLevel, this.sharedLogEntry, `${this.contextName} -> ${prefix}`);
-	}
-
-	/**
-	 * Logs a message with the specified log level, prefix, and additional arguments if the current log level permits.
-	 */
-	// biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-	private log(level: LogLevel, message: string, ...args: any[]) {
-		const logLevelIndex = this.logLevels.indexOf(level);
-
-		if (logLevelIndex < this.getCurrentLogLevelIndex()) {
-			return;
-		}
-
-		this.sharedLogEntry.push({
-			timestamp: new Date(),
-			logLevel: level,
-			prefix: this.contextName,
-			message: `${message}\n\n${args.join("\n\n")}`,
-		});
-	}
-
-	/**
-	 * Logs a debug-level message with the specified message and arguments.
-	 */
-	// biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-	debug(message: string, ...args: any[]) {
-		this.log("debug", message, ...args);
-	}
-
-	/**
-	 * Logs a info-level message with the specified message and arguments.
-	 */
-	// biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-	info(message: string, ...args: any[]) {
-		this.log("info", message, ...args);
-	}
-
-	/**
-	 * Logs a warn-level message with the specified message and arguments.
-	 */
-	// biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-	warn(message: string, ...args: any[]) {
-		this.log("warn", message, ...args);
-	}
-
-	/**
-	 * Logs a error-level message with the specified message and arguments.
-	 */
-	// biome-ignore lint/suspicious/noExplicitAny: logger accepts arbitrary payloads for debug output.
-	error(message: string, ...args: any[]) {
-		this.log("error", message, ...args);
-	}
-
-	/**
-	 * Sets the current log level to the specified level during runTime.
-	 */
-	setLogLevel(level: LogLevel) {
-		this.sharedLogLevel.current = level;
-	}
-
-	/**
-	 * Retrieves the current log level during runtime.
-	 */
-	getCurrentLogLevel(): LogLevel {
-		return this.sharedLogLevel.current;
-	}
-
-	/**
-	 * Retrieves the index of the current log level in the logLevels array during runtime.
-	 */
-	getCurrentLogLevelIndex(): number {
-		return this.logLevels.indexOf(this.sharedLogLevel.current);
-	}
-
-	/**
-	 * Resets the current log level to the initial level during runtime.
-	 */
-	resetLogLevel() {
-		this.sharedLogLevel.current = this.sharedLogLevel.initial;
-	}
-
-	/**
-	 * Checks if the input log level is equal to the current log level of the PlaywrightReportLogger instance.
-	 */
-	isCurrentLogLevel(level: LogLevel): boolean {
-		return this.sharedLogLevel.current === level;
-	}
-
-	/**
-	 * Returns 'true' if the "level" parameter provided has an equal or greater index than the current logLevel.
-	 */
-	public isLogLevelEnabled(level: LogLevel): boolean {
-		const logLevelIndex = this.logLevels.indexOf(level);
-
-		if (logLevelIndex < this.getCurrentLogLevelIndex()) {
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Attaches the recorded log entries to the Playwright HTML report in a sorted and formatted manner.
-	 */
-	attachLogsToTest(testInfo: TestInfo) {
-		this.sharedLogEntry.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-
-		for (const log of this.sharedLogEntry) {
-			const printTime = log.timestamp.toLocaleTimeString("nb-NO", {
-				hour: "2-digit",
-				minute: "2-digit",
-				second: "2-digit",
-			});
-			const printDate = log.timestamp.toLocaleDateString("nb-NO", {
-				day: "2-digit",
-				month: "2-digit",
-				year: "numeric",
-			});
-			const printLogLevel = `${log.logLevel.toUpperCase()}`;
-			const printPrefix = log.prefix ? `: [${log.prefix}]` : "";
-
-			let messageBody = "";
-			let messageContentType = "";
-			try {
-				const parsedMessage = JSON.parse(log.message);
-				messageContentType = "application/json";
-				messageBody = JSON.stringify(parsedMessage, null, 2);
-			} catch (_error) {
-				messageContentType = "text/plain";
-				messageBody = log.message;
-			}
-
-			testInfo.attach(`${printTime} ${printDate} - ${printLogLevel} ${printPrefix}`, {
-				contentType: messageContentType,
-				body: Buffer.from(messageBody),
-			});
-		}
-	}
-}

package/srcV2/helpers/sessionStorage.ts

@@ -1,251 +0,0 @@
-import { type Frame, type Page, test } from "@playwright/test";
-
-/**
- * Defines the SessionStorage class to manage session storage in Playwright.
- * It provides methods to set, get, and clear session storage data, and to handle data before page navigation.
- */
-type SessionStorageState<T = unknown> = Record<string, T>;
-
-type SetOptions = {
-	reload?: boolean;
-	waitForContext?: boolean;
-};
-
-type WaitForContextOptions = {
-	waitForContext?: boolean;
-};
-
-type SessionStorageOptions = {
-	label?: string;
-};
-
-export class SessionStorage {
-	// Defines an object to hold states to be set in session storage, allowing any value type.
-	private queuedStates: SessionStorageState = {};
-	// Indicates if the session storage manipulation has been initiated.
-	private isInitiated = false;
-
-	// Initializes the class with a Playwright Page object and an optional label for step titles.
-	constructor(
-		private page: Page,
-		private options: SessionStorageOptions = {},
-	) {}
-
-	private getStepLabel(methodName: string) {
-		const prefix = this.options.label ? `${this.options.label}.` : "";
-		return `${prefix}SessionStorage.${methodName}:`;
-	}
-
-	private async hasContext() {
-		return await this.page.evaluate(() => {
-			return typeof window !== "undefined" && window.sessionStorage !== undefined;
-		});
-	}
-
-	private async waitForContextAvailability() {
-		try {
-			const contextExists = await this.hasContext();
-			if (contextExists) {
-				return;
-			}
-		} catch (_e) {
-			// Execution context was destroyed; wait for a new one.
-		}
-
-		await new Promise<void>((resolve) => {
-			const handler = async (frame: Frame) => {
-				if (frame !== this.page.mainFrame()) {
-					return;
-				}
-				try {
-					const contextExists = await this.hasContext();
-					if (!contextExists) {
-						return;
-					}
-				} catch (_e) {
-					return;
-				}
-				this.page.off("framenavigated", handler);
-				resolve();
-			};
-			this.page.on("framenavigated", handler);
-		});
-	}
-
-	private async ensureContext({ waitForContext = false }: WaitForContextOptions = {}) {
-		try {
-			const contextExists = await this.hasContext();
-			if (contextExists) {
-				return;
-			}
-		} catch (_e) {
-			// Ignore and fall through.
-		}
-
-		if (!waitForContext) {
-			throw new Error("SessionStorage context is not available.");
-		}
-
-		await this.waitForContextAvailability();
-	}
-
-	/** Writes states to session storage. Accepts an object with key-value pairs representing the states. */
-	private async writeToSessionStorage<T = unknown>(states: SessionStorageState<T>) {
-		await this.page.evaluate((storage) => {
-			for (const [key, value] of Object.entries(storage)) {
-				window.sessionStorage.setItem(key, JSON.stringify(value));
-			}
-		}, states);
-	}
-
-	/** Reads all states from session storage and returns them as an object. */
-	private async readFromSessionStorage<T = unknown>(): Promise<SessionStorageState<T>> {
-		const storage = await this.page.evaluate(() => {
-			const storage: Record<string, unknown> = {};
-			for (let i = 0; i < sessionStorage.length; i++) {
-				const key = sessionStorage.key(i);
-				if (key !== null) {
-					const item = sessionStorage.getItem(key);
-					try {
-						storage[key] = item ? JSON.parse(item) : null;
-					} catch (_e) {
-						storage[key] = item;
-					}
-				}
-			}
-			return storage;
-		});
-		return storage as SessionStorageState<T>;
-	}
-
-	/**
-	 * Sets the specified states in session storage.
-	 * Optionally waits for the next main-frame navigation to establish a valid context before writing,
-	 * and reloads the page after setting the data.
-	 *
-	 * Parameters:
-	 * states: Object representing the states to set in session storage.
-	 * reload: Boolean indicating whether to reload the page after setting the session storage data.
-	 * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
-	 */
-	public async set<T = unknown>(states: SessionStorageState<T>, options: SetOptions = {}) {
-		await test.step(this.getStepLabel("set"), async () => {
-			await this.ensureContext({ waitForContext: options.waitForContext });
-			await this.writeToSessionStorage(states);
-			if (options.reload) {
-				await this.page.reload();
-			}
-		});
-	}
-
-	/**
-	 * Queues states to be set in the sessionStorage before the next navigation occurs.
-	 * Handles different scenarios based on multiple calls made before the navigation occurs.
-	 *
-	 * 1. No Context, Single Call: Queues and sets states upon the next navigation.
-	 * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
-	 * 3. With Context: Still queues until the next navigation.
-	 *
-	 * Parameters:
-	 * states: Object representing the states to queue for setting in session storage.
-	 */
-	public async setOnNextNavigation<T = unknown>(states: SessionStorageState<T>) {
-		this.queuedStates = { ...this.queuedStates, ...states };
-
-		const populateStorage = async () => {
-			await test.step(this.getStepLabel("setOnNextNavigation"), async () => {
-				await this.writeToSessionStorage(this.queuedStates);
-			});
-			this.queuedStates = {}; // Clear queued states
-		};
-
-		if (!this.isInitiated) {
-			this.isInitiated = true;
-			const handler = async (frame: Frame) => {
-				if (frame !== this.page.mainFrame()) {
-					return;
-				}
-				await populateStorage();
-				this.page.off("framenavigated", handler);
-				this.isInitiated = false;
-			};
-			this.page.on("framenavigated", handler);
-		}
-	}
-
-	/**
-	 * Fetches states from session storage.
-	 * If specific keys are provided, fetches only those states; otherwise, fetches all states.
-	 *
-	 * Parameters:
-	 * keys: Optional array of keys to specify which states to fetch from session storage.
-	 * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
-	 *
-	 * Returns:
-	 * Object containing the fetched states.
-	 */
-	public async get<T = unknown>(keys?: string[]): Promise<SessionStorageState<T>>;
-	public async get<T = unknown>(
-		keys: string[] | undefined,
-		options: WaitForContextOptions,
-	): Promise<SessionStorageState<T>>;
-	public async get<T = unknown>(keys?: string[], options: WaitForContextOptions = {}): Promise<SessionStorageState<T>> {
-		let result: SessionStorageState<T> = {};
-		await test.step(this.getStepLabel("get"), async () => {
-			await this.ensureContext(options);
-			const allData = await this.readFromSessionStorage<T>();
-			if (keys && keys.length > 0) {
-				for (const key of keys) {
-					if (Object.hasOwn(allData, key)) {
-						const value = allData[key];
-						if (value !== undefined) {
-							result[key] = value;
-						}
-					}
-				}
-			} else {
-				result = allData;
-			}
-		});
-		return result;
-	}
-
-	/**
-	 * Clears states in sessionStorage. When keys are provided, clears only those entries.
-	 * Pass `waitForContext` to wait for the next main-frame navigation and validate that a usable context exists.
-	 */
-	public async clear(): Promise<void>;
-	public async clear(options: WaitForContextOptions): Promise<void>;
-	public async clear(key: string | string[]): Promise<void>;
-	public async clear(key: string | string[], options: WaitForContextOptions): Promise<void>;
-	public async clear(
-		keyOrOptions?: string | string[] | WaitForContextOptions,
-		options: WaitForContextOptions = {},
-	): Promise<void> {
-		const { keys, waitForContext } = (() => {
-			if (Array.isArray(keyOrOptions)) {
-				return { keys: keyOrOptions, waitForContext: options.waitForContext };
-			}
-			if (typeof keyOrOptions === "string") {
-				return { keys: [keyOrOptions], waitForContext: options.waitForContext };
-			}
-			if (keyOrOptions) {
-				return { keys: undefined, waitForContext: keyOrOptions.waitForContext };
-			}
-			return { keys: undefined, waitForContext: options.waitForContext };
-		})();
-
-		await test.step(this.getStepLabel("clear"), async () => {
-			await this.ensureContext({ waitForContext });
-			if (!keys || keys.length === 0) {
-				await this.page.evaluate(() => sessionStorage.clear());
-				return;
-			}
-			await this.page.evaluate((keysToClear) => {
-				for (const key of keysToClear) {
-					sessionStorage.removeItem(key);
-				}
-			}, keys);
-		});
-	}
-}

package/srcV2/helpers/stepDecorator.ts

@@ -1,106 +0,0 @@
-import { test } from "@playwright/test";
-
-type AnyMethod<This = unknown, Args extends unknown[] = unknown[], Return = unknown> = (
-	this: This,
-	...args: Args
-) => Return;
-
-type StepTitle = Parameters<typeof test.step>[0];
-type StepOptions = Parameters<typeof test.step>[2];
-
-type StepDecoratorArgs = [] | [StepTitle] | [StepOptions] | [StepTitle, StepOptions];
-
-type LegacyMethodDecoratorArgs<T extends AnyMethod = AnyMethod> = [object, string | symbol, TypedPropertyDescriptor<T>];
-
-type Stage3MethodDecoratorArgs<T extends AnyMethod = AnyMethod> = [T, ClassMethodDecoratorContext<unknown, T>];
-
-interface StepDecoratorFactory {
-	<This, Args extends unknown[], Return>(
-		value: AnyMethod<This, Args, Return>,
-		context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>,
-	): AnyMethod<This, Args, Return> | undefined;
-	<This, Args extends unknown[], Return>(
-		target: object,
-		propertyKey: string | symbol,
-		descriptor: TypedPropertyDescriptor<AnyMethod<This, Args, Return>>,
-	): TypedPropertyDescriptor<AnyMethod<This, Args, Return>> | undefined;
-}
-
-const isMethodDecoratorArgs = (args: unknown[]): args is LegacyMethodDecoratorArgs<AnyMethod> =>
-	args.length === 3 && typeof args[0] === "object" && (typeof args[1] === "string" || typeof args[1] === "symbol");
-
-const isStage3MethodDecoratorArgs = (args: unknown[]): args is Stage3MethodDecoratorArgs<AnyMethod> =>
-	args.length === 2 && typeof args[0] === "function" && args[1] !== null && typeof args[1] === "object";
-
-const normalizeStepArguments = (args: StepDecoratorArgs) => {
-	const [titleOrOptions, maybeOptions] = args;
-	const title = typeof titleOrOptions === "string" ? titleOrOptions : undefined;
-	const options = typeof titleOrOptions === "string" ? maybeOptions : titleOrOptions;
-	return { title, options };
-};
-
-const createWrappedMethod = <T extends AnyMethod>(
-	original: T,
-	methodName: string | symbol,
-	title?: StepTitle,
-	options?: StepOptions,
-) =>
-	function (this: ThisParameterType<T>, ...methodArgs: Parameters<T>) {
-		const rawClassName = (this as { constructor?: { name?: string } }).constructor?.name ?? "";
-		const className = rawClassName && rawClassName !== "Object" ? rawClassName : "Anonymous";
-		const resolvedTitle = title ?? `${className}.${String(methodName)}`;
-		return test.step(resolvedTitle, () => original.apply(this, methodArgs), options) as ReturnType<T>;
-	} as T;
-
-const createStepDecorator =
-	({ title, options }: { title?: StepTitle; options?: StepOptions }) =>
-	<T extends AnyMethod>(
-		valueOrTarget: T | LegacyMethodDecoratorArgs<T>[0],
-		contextOrKey: ClassMethodDecoratorContext | LegacyMethodDecoratorArgs<T>[1],
-		descriptor?: LegacyMethodDecoratorArgs<T>[2],
-	): T | undefined | TypedPropertyDescriptor<T> => {
-		if (typeof valueOrTarget === "function" && isStage3MethodDecoratorArgs([valueOrTarget, contextOrKey])) {
-			const [original, context] = [valueOrTarget, contextOrKey] as Stage3MethodDecoratorArgs<T>;
-			return createWrappedMethod(original, context.name, title, options);
-		}
-
-		if (!descriptor || typeof descriptor.value !== "function") {
-			throw new Error("@step decorator can only be applied to methods.");
-		}
-
-		const original = descriptor.value;
-		descriptor.value = createWrappedMethod(original, contextOrKey as string | symbol, title, options);
-
-		return descriptor;
-	};
-
-/**
- * Wraps a method in Playwright `test.step`, defaulting the title to `ClassName.methodName`.
- *
- * Examples:
- * - `@step`
- * - `@step("title")`
- * - `@step({ box: true })`
- * - `@step("title", { timeout: 5000 })`
- */
-export function step(): StepDecoratorFactory;
-export function step(title: StepTitle): StepDecoratorFactory;
-export function step(options: StepOptions): StepDecoratorFactory;
-export function step(title: StepTitle, options: StepOptions): StepDecoratorFactory;
-export function step<This, Args extends unknown[], Return>(
-	value: AnyMethod<This, Args, Return>,
-	context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>,
-): AnyMethod<This, Args, Return> | undefined;
-export function step(
-	...args: StepDecoratorArgs | LegacyMethodDecoratorArgs<AnyMethod> | Stage3MethodDecoratorArgs<AnyMethod>
-): StepDecoratorFactory | AnyMethod | undefined | TypedPropertyDescriptor<AnyMethod> {
-	if (isStage3MethodDecoratorArgs(args)) {
-		return createStepDecorator(normalizeStepArguments([]))(...args);
-	}
-
-	if (isMethodDecoratorArgs(args)) {
-		return createStepDecorator(normalizeStepArguments([]))(...args);
-	}
-
-	return createStepDecorator(normalizeStepArguments(args as StepDecoratorArgs));
-}

package/srcV2/locators/index.ts

@@ -1,15 +0,0 @@
-export type { LocatorQueryBuilderPublic } from "./locatorQueryBuilder";
-export { LocatorQueryBuilder } from "./locatorQueryBuilder";
-export { LocatorRegistrationBuilder } from "./locatorRegistrationBuilder";
-export type {
-	AddAccessor,
-	GetLocatorAccessor,
-	GetLocatorSchemaAccessor,
-	GetNestedLocatorAccessor,
-	LocatorRegistry,
-} from "./locatorRegistry";
-export { createRegistryWithAccessors, LocatorRegistryInternal } from "./locatorRegistry";
-export { LocatorUpdateBuilder } from "./locatorUpdateBuilder";
-export { ReusableLocatorBuilder, ReusableLocatorFactory } from "./reusableLocatorBuilder";
-export * from "./types";
-export * from "./utils";