@dev-blinq/bvt-playwright-js 1.0.0-dev.1 → 1.0.0-dev.2

package/index.d.mts

@@ -9298,9 +9298,18 @@ export type BlinqTestFixtures = {
 	readonly bvt: BlinqTestRuntime;
 };
 /**
- * Build a Playwright `test` extended with a `bvt` fixture. Generated spec
- * files import `test` from this function and call `bvt.executeCommand(...)`
- * inside `test.step` blocks, exactly as they did with the cucumber runner.
+ * Build a Playwright `test` extended with a `bvt` fixture and a `beforeEach`
+ * hook that navigates to the resolved environment's `baseURL`.
+ *
+ * The environments file is read **synchronously, once** when this function
+ * is called (i.e. when `support/bvt.ts` is evaluated). The resolved baseURL
+ * is then used by a `test.beforeEach` hook that runs **first** before each
+ * test — Playwright executes `beforeEach` hooks in registration order, and
+ * because `createBlinqTest` runs at module-evaluation time, any
+ * user-registered `beforeEach` runs after this one.
+ *
+ * Generated spec files import `test` from this function and call
+ * `bvt.executeCommand(...)` inside `test.step` blocks.
  */
 export declare function createBlinqTest(options?: CreateBlinqTestOptions): import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & BlinqTestFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
 

package/index.mjs

@@ -1,12 +1,12 @@
 import crypto$1, { randomUUID } from "node:crypto";
+import { createWriteStream, readFileSync } from "node:fs";
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium, firefox, webkit } from "playwright";
 import { expect } from "playwright/test";
-import { createWriteStream } from "node:fs";
-import { mkdirSync, readFileSync, statSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync$1, statSync } from "fs";
 import { dirname as dirname$1 } from "path";
 import { createContext, runInContext } from "node:vm";
 import { test } from "@playwright/test";
@@ -19468,7 +19468,7 @@ var Tester = class {
 		});
 	}
 	async uploadFile(presignedUrl, filePath) {
-		const fileData = readFileSync(filePath);
+		const fileData = readFileSync$1(filePath);
 		this.obs.logger.log(`Uploading file from ${filePath} (size=${fileData.byteLength} bytes) via PUT`);
 		const response = await fetch(presignedUrl, {
 			method: "PUT",
@@ -24014,11 +24014,10 @@ var PlaywrightRunner = class {
 		return scope;
 	}
 };
-async function loadEnvironmentsFile(filePath) {
+function loadEnvironmentsFileSync(filePath) {
 	if (!filePath) return null;
 	try {
-		const raw = await readFile(filePath, "utf8");
-		return JSON.parse(raw);
+		return JSON.parse(readFileSync(filePath, "utf8"));
 	} catch (error) {
 		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
 		throw error;
@@ -24037,9 +24036,18 @@ function resolveEnvironmentParameters(environments) {
 	};
 }
 /**
-* Build a Playwright `test` extended with a `bvt` fixture. Generated spec
-* files import `test` from this function and call `bvt.executeCommand(...)`
-* inside `test.step` blocks, exactly as they did with the cucumber runner.
+* Build a Playwright `test` extended with a `bvt` fixture and a `beforeEach`
+* hook that navigates to the resolved environment's `baseURL`.
+*
+* The environments file is read **synchronously, once** when this function
+* is called (i.e. when `support/bvt.ts` is evaluated). The resolved baseURL
+* is then used by a `test.beforeEach` hook that runs **first** before each
+* test — Playwright executes `beforeEach` hooks in registration order, and
+* because `createBlinqTest` runs at module-evaluation time, any
+* user-registered `beforeEach` runs after this one.
+*
+* Generated spec files import `test` from this function and call
+* `bvt.executeCommand(...)` inside `test.step` blocks.
 */
 function createBlinqTest(options = {}) {
 	const environmentsFilePath = toFilePath(options.environmentsFilePath);
@@ -24047,13 +24055,16 @@ function createBlinqTest(options = {}) {
 	const runtimeFilePath = toFilePath(options.testDataFilePath);
 	const logger = options.logger ?? console;
 	const defaultParameters = options.parameters ?? {};
-	return test.extend({ bvt: async ({ page }, use, testInfo) => {
-		const resolved = resolveEnvironmentParameters(await loadEnvironmentsFile(environmentsFilePath));
+	const envResolved = resolveEnvironmentParameters(loadEnvironmentsFileSync(environmentsFilePath));
+	const baseParameters = {
+		...defaultParameters,
+		...envResolved,
+		...seedFilePath ? { testDataSeedFilePath: seedFilePath } : {}
+	};
+	const test$1 = test.extend({ bvt: async ({ page }, use, testInfo) => {
 		const runner = new PlaywrightRunner({ parameters: {
-			...defaultParameters,
-			...resolved,
-			scenarioId: defaultParameters.scenarioId ?? testInfo.testId,
-			...seedFilePath ? { testDataSeedFilePath: seedFilePath } : {},
+			...baseParameters,
+			scenarioId: baseParameters.scenarioId ?? testInfo.testId,
 			...runtimeFilePath ? { testDataFilePath: runtimeFilePath } : { testDataFilePath: path.join(tmpdir(), `blinq-bvt-playwright-${process.pid}-${testInfo.workerIndex}-${testInfo.testId}.json`) }
 		} }, { logger });
 		runner.attach(page);
@@ -24071,6 +24082,10 @@ function createBlinqTest(options = {}) {
 			runner.detach();
 		}
 	} });
+	test$1.beforeEach(async ({ page }) => {
+		if (baseParameters.baseUrl) await page.goto(baseParameters.baseUrl);
+	});
+	return test$1;
 }
 
 //#endregion