@emesoft_company/playwright-core 2.1.0

package/dist/fixtures/index.js

@@ -0,0 +1,651 @@
+import { expect as expect$1, test as test$1 } from '@playwright/test';
+import { z } from 'zod';
+import pino from 'pino';
+
+// src/fixtures/base-test.ts
+
+// src/errors/app-error.ts
+var AppError = class extends Error {
+  code;
+  context;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.code = options.code;
+    this.context = options.context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ConfigValidationError = class extends AppError {
+  constructor(message, issues, context) {
+    super(message, { code: "CONFIG_VALIDATION_ERROR", context: { issues, ...context } });
+  }
+};
+var ApiError = class extends AppError {
+  status;
+  method;
+  url;
+  constructor(message, options) {
+    super(message, options);
+    this.status = options.status;
+    this.method = options.method;
+    this.url = options.url;
+  }
+};
+var AuthError = class extends AppError {
+  constructor(message, options = {}) {
+    super(message, { code: "AUTH_ERROR", ...options });
+  }
+};
+
+// src/auth/token-provider.ts
+var NullTokenProvider = class {
+  async getToken() {
+    return "";
+  }
+  invalidate() {
+  }
+};
+var JwtTokenProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  cached;
+  inFlight;
+  async getToken() {
+    if (this.cached && this.cached.expiresAt > Date.now()) {
+      return this.cached.token;
+    }
+    if (!this.inFlight) {
+      this.inFlight = this.fetchToken().finally(() => {
+        this.inFlight = void 0;
+      });
+    }
+    return this.inFlight;
+  }
+  invalidate() {
+    this.cached = void 0;
+  }
+  async fetchToken() {
+    const { tokenUrl, clientId, clientSecret, username, password, refreshSkewSeconds = 30, logger: logger2, fetchImpl = fetch } = this.options;
+    const body = new URLSearchParams();
+    if (username && password) {
+      body.set("grant_type", "password");
+      body.set("username", username);
+      body.set("password", password);
+    } else {
+      body.set("grant_type", "client_credentials");
+    }
+    if (clientId) body.set("client_id", clientId);
+    if (clientSecret) body.set("client_secret", clientSecret);
+    logger2?.debug({ tokenUrl }, "fetching auth token");
+    let response;
+    try {
+      response = await fetchImpl(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body
+      });
+    } catch (cause) {
+      throw new AuthError(`Failed to reach token endpoint ${tokenUrl}`, { cause });
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new AuthError(`Token endpoint returned ${response.status}: ${text}`, {
+        context: { status: response.status, tokenUrl }
+      });
+    }
+    const data = await response.json();
+    if (!data.access_token) {
+      throw new AuthError("Token endpoint response missing access_token", { context: { tokenUrl } });
+    }
+    const expiresInSeconds = data.expires_in ?? 300;
+    this.cached = {
+      token: data.access_token,
+      expiresAt: Date.now() + Math.max(expiresInSeconds - refreshSkewSeconds, 0) * 1e3
+    };
+    return this.cached.token;
+  }
+};
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/errors/retry.ts
+function backoffDelay(attempt, minDelayMs, maxDelayMs, factor) {
+  const exponential = minDelayMs * factor ** (attempt - 1);
+  const jitter = Math.random() * minDelayMs;
+  return Math.min(exponential + jitter, maxDelayMs);
+}
+async function withRetry(fn, options = {}) {
+  const {
+    retries = 2,
+    minDelayMs = 200,
+    maxDelayMs = 5e3,
+    factor = 2,
+    retryOn = () => true,
+    onRetry,
+    onGiveUp
+  } = options;
+  const maxAttempts = retries + 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const isLastAttempt = attempt >= maxAttempts;
+      if (isLastAttempt || !retryOn(error)) {
+        onGiveUp?.(error, attempt);
+        throw error;
+      }
+      onRetry?.(error, attempt);
+      await sleep(backoffDelay(attempt, minDelayMs, maxDelayMs, factor));
+    }
+  }
+  throw new Error("withRetry: unreachable state");
+}
+
+// src/api/interceptors.ts
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500 && status <= 599;
+}
+
+// src/api/api-client.ts
+var TransientHttpError = class extends Error {
+  constructor(status) {
+    super(`Transient HTTP status ${status}`);
+    this.status = status;
+  }
+  status;
+};
+var ApiClient = class {
+  request;
+  baseUrl;
+  tokenProvider;
+  logger;
+  retryOptions;
+  defaultHeaders;
+  interceptors;
+  constructor(options) {
+    this.request = options.request;
+    this.baseUrl = options.baseUrl;
+    this.tokenProvider = options.tokenProvider ?? new NullTokenProvider();
+    this.logger = options.logger;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+    this.interceptors = options.interceptors ?? {};
+    this.retryOptions = { ...options.retry };
+  }
+  get(path, options) {
+    return this.requestBody("GET", path, options);
+  }
+  post(path, options) {
+    return this.requestBody("POST", path, options);
+  }
+  put(path, options) {
+    return this.requestBody("PUT", path, options);
+  }
+  patch(path, options) {
+    return this.requestBody("PATCH", path, options);
+  }
+  delete(path, options) {
+    return this.requestBody("DELETE", path, options);
+  }
+  /**
+   * Full response including status and headers. Retries transient statuses, then returns
+   * whatever came back — a 404 or 500 is a normal return value here, not an exception.
+   * Network/timeout failures still throw.
+   */
+  async send(method, path, options = {}) {
+    const url = this.resolveUrl(path, options.params);
+    let lastResponse;
+    try {
+      await withRetry(
+        async () => {
+          lastResponse = await this.fetchOnce(method, url, options);
+          if (isRetryableStatus(lastResponse.status) && !this.isExpectedStatus(lastResponse.status, options)) {
+            throw new TransientHttpError(lastResponse.status);
+          }
+        },
+        {
+          ...this.retryOptions,
+          retryOn: (error) => error instanceof TransientHttpError,
+          onRetry: (error, attempt) => this.logger?.warn({ method, url, attempt, err: error }, "retrying API request")
+        }
+      );
+    } catch (error) {
+      if (!(error instanceof TransientHttpError)) throw error;
+    }
+    if (!lastResponse) {
+      throw new AppError(`API request produced no response: ${method} ${url}`, {
+        code: "API_NO_RESPONSE",
+        context: { method, url }
+      });
+    }
+    return lastResponse;
+  }
+  async requestBody(method, path, options = {}) {
+    const response = await this.send(method, path, options);
+    if (!this.isExpectedStatus(response.status, options)) {
+      if (response.status === 401) this.tokenProvider.invalidate();
+      this.logger?.error(
+        { status: response.status, method, url: response.url, body: response.data },
+        "API request failed"
+      );
+      throw new ApiError(
+        `API request failed: ${method} ${response.url} -> ${response.status}` + (options.expectStatus === void 0 ? "" : ` (expected ${String(options.expectStatus)})`),
+        {
+          code: "API_REQUEST_FAILED",
+          status: response.status,
+          method,
+          url: response.url,
+          context: { body: response.data }
+        }
+      );
+    }
+    return response.data;
+  }
+  isExpectedStatus(status, options) {
+    if (options.expectStatus === void 0) return status >= 200 && status < 300;
+    const expected = Array.isArray(options.expectStatus) ? options.expectStatus : [options.expectStatus];
+    return expected.includes(status);
+  }
+  async fetchOnce(method, url, options) {
+    const headers = await this.buildHeaders(method, url, options);
+    const response = await this.request.fetch(url, {
+      method,
+      headers,
+      data: options.data,
+      form: options.form,
+      multipart: options.multipart,
+      timeout: options.timeoutMs
+    });
+    await this.interceptors.onResponse?.({ method, url, status: response.status() });
+    return {
+      status: response.status(),
+      ok: response.ok(),
+      headers: response.headers(),
+      data: await this.parseBody(response, options),
+      url,
+      method
+    };
+  }
+  resolveUrl(path, params) {
+    const base2 = this.baseUrl ? new URL(path, this.baseUrl).toString() : path;
+    if (!params) return base2;
+    const url = new URL(base2);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  async buildHeaders(method, url, options) {
+    let headers = { ...this.defaultHeaders, ...options.headers };
+    if (!options.skipAuth) {
+      const token = await this.tokenProvider.getToken();
+      if (token) headers = { ...headers, Authorization: `Bearer ${token}` };
+    }
+    const overridden = await this.interceptors.onRequest?.({ method, url, headers });
+    return overridden ?? headers;
+  }
+  async parseBody(response, options) {
+    const raw = await this.readBody(response);
+    if (!options.schema) return raw;
+    const result = options.schema.safeParse(raw);
+    if (!result.success) {
+      throw new ApiError(`API response did not match the expected schema: ${response.url()}`, {
+        code: "API_SCHEMA_MISMATCH",
+        status: response.status(),
+        url: response.url(),
+        context: { issues: result.error.issues, body: raw }
+      });
+    }
+    return result.data;
+  }
+  async readBody(response) {
+    const contentType = response.headers()["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text.trim() === "") return void 0;
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    return response.text();
+  }
+};
+
+// src/utils/deep-merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base2, override) {
+  if (override === void 0) return base2;
+  if (!isPlainObject(base2) || !isPlainObject(override)) {
+    return override;
+  }
+  const result = { ...base2 };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) continue;
+    const baseValue = base2[key];
+    result[key] = isPlainObject(baseValue) && isPlainObject(value) ? deepMerge(baseValue, value) : value;
+  }
+  return result;
+}
+function pruneUndefined(value) {
+  if (Array.isArray(value)) return value.map(pruneUndefined);
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (val === void 0) continue;
+      const pruned = pruneUndefined(val);
+      if (isPlainObject(pruned) && Object.keys(pruned).length === 0) continue;
+      result[key] = pruned;
+    }
+    return result;
+  }
+  return value;
+}
+var EnvironmentSchema = z.string().min(1);
+var TimeoutsSchema = z.object({
+  actionMs: z.number().int().positive().default(15e3),
+  navigationMs: z.number().int().positive().default(3e4),
+  testMs: z.number().int().positive().default(6e4),
+  /** Default budget for `waitForCondition` and other non-locator polling. */
+  waitMs: z.number().int().positive().default(3e4)
+});
+var AuthConfigSchema = z.object({
+  tokenUrl: z.string().url().optional(),
+  clientId: z.string().optional(),
+  clientSecret: z.string().optional(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  /** Single-session storage state file (see `buildGlobalSetup`). */
+  storageStatePath: z.string().optional(),
+  /** Directory used for per-role storage state files in multi-role setups. */
+  storageStateDir: z.string().default(".auth")
+}).default({});
+var ReportingConfigSchema = z.object({
+  allureEnabled: z.boolean().default(false),
+  resultsDir: z.string().default("allure-results"),
+  /** `{id}` is replaced with a test-case id — see `meta()` in `@emesoft_company/playwright-core/reporting`. */
+  testCaseUrlTemplate: z.string().optional()
+}).default({});
+var RetryConfigSchema = z.object({
+  retries: z.number().int().min(0).default(2),
+  minDelayMs: z.number().int().positive().default(200),
+  maxDelayMs: z.number().int().positive().default(5e3)
+}).default({});
+var DiagnosticsConfigSchema = z.object({
+  /** Collect browser console errors + failed requests and attach them to the report. */
+  enabled: z.boolean().default(true),
+  /** Fail the test if the page logged a console error. Off by default — many apps are noisy. */
+  failOnConsoleError: z.boolean().default(false),
+  /** Fail the test on an uncaught page exception. */
+  failOnPageError: z.boolean().default(false),
+  /** Console messages matching any of these substrings are ignored entirely. */
+  ignoreConsolePatterns: z.array(z.string()).default([])
+}).default({});
+var AppConfigSchema = z.object({
+  environment: EnvironmentSchema,
+  baseUrl: z.string().url(),
+  apiBaseUrl: z.string().url().optional(),
+  tenant: z.string().optional(),
+  timeouts: TimeoutsSchema.default({}),
+  auth: AuthConfigSchema,
+  reporting: ReportingConfigSchema,
+  retry: RetryConfigSchema,
+  diagnostics: DiagnosticsConfigSchema,
+  logLevel: z.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]).default("info"),
+  custom: z.record(z.string(), z.unknown()).default({})
+});
+
+// src/config/loader.ts
+function readEnvConfig(env) {
+  return {
+    environment: env.TEST_ENV ?? "dev",
+    baseUrl: env.BASE_URL,
+    apiBaseUrl: env.API_BASE_URL,
+    tenant: env.TENANT,
+    logLevel: env.LOG_LEVEL,
+    timeouts: {
+      actionMs: env.ACTION_TIMEOUT_MS ? Number(env.ACTION_TIMEOUT_MS) : void 0,
+      navigationMs: env.NAVIGATION_TIMEOUT_MS ? Number(env.NAVIGATION_TIMEOUT_MS) : void 0,
+      testMs: env.TEST_TIMEOUT_MS ? Number(env.TEST_TIMEOUT_MS) : void 0,
+      waitMs: env.WAIT_TIMEOUT_MS ? Number(env.WAIT_TIMEOUT_MS) : void 0
+    },
+    auth: {
+      tokenUrl: env.AUTH_TOKEN_URL,
+      clientId: env.AUTH_CLIENT_ID,
+      clientSecret: env.AUTH_CLIENT_SECRET,
+      username: env.AUTH_USERNAME,
+      password: env.AUTH_PASSWORD,
+      storageStatePath: env.AUTH_STORAGE_STATE_PATH,
+      storageStateDir: env.AUTH_STORAGE_STATE_DIR
+    },
+    reporting: {
+      allureEnabled: env.REPORT_ALLURE === "true",
+      resultsDir: env.ALLURE_RESULTS_DIR,
+      testCaseUrlTemplate: env.TEST_CASE_URL_TEMPLATE
+    },
+    retry: {
+      retries: env.RETRY_COUNT ? Number(env.RETRY_COUNT) : void 0,
+      minDelayMs: env.RETRY_MIN_DELAY_MS ? Number(env.RETRY_MIN_DELAY_MS) : void 0,
+      maxDelayMs: env.RETRY_MAX_DELAY_MS ? Number(env.RETRY_MAX_DELAY_MS) : void 0
+    },
+    diagnostics: {
+      enabled: env.DIAGNOSTICS === void 0 ? void 0 : env.DIAGNOSTICS !== "false",
+      failOnConsoleError: env.FAIL_ON_CONSOLE_ERROR === void 0 ? void 0 : env.FAIL_ON_CONSOLE_ERROR === "true",
+      failOnPageError: env.FAIL_ON_PAGE_ERROR === void 0 ? void 0 : env.FAIL_ON_PAGE_ERROR === "true"
+    }
+  };
+}
+function loadConfig(options = {}) {
+  const { env = process.env, overrides } = options;
+  const fromEnv = pruneUndefined(readEnvConfig(env));
+  const merged = deepMerge(fromEnv, overrides);
+  const result = AppConfigSchema.safeParse(merged);
+  if (!result.success) {
+    throw new ConfigValidationError(
+      `Invalid application config: ${result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")}`,
+      result.error.issues
+    );
+  }
+  return result.data;
+}
+function createLogger(options = {}) {
+  const {
+    level = process.env.LOG_LEVEL ?? "info",
+    name = "playwright-core",
+    pretty = process.env.LOG_PRETTY === "true"
+  } = options;
+  return pino({
+    name,
+    level,
+    ...pretty ? {
+      transport: {
+        target: "pino-pretty",
+        options: { colorize: true, translateTime: "SYS:standard" }
+      }
+    } : {}
+  });
+}
+createLogger();
+
+// src/reporting/meta.ts
+function linkTestCases(testInfo, urlTemplate) {
+  if (!urlTemplate) return;
+  for (const annotation of testInfo.annotations) {
+    if (annotation.type === "testCase" && annotation.description) {
+      annotation.description = urlTemplate.replace("{id}", annotation.description);
+    }
+  }
+}
+
+// src/fixtures/auth.fixture.ts
+function resolveTokenProvider(config, logger2) {
+  const { auth } = config;
+  if (auth.tokenUrl) {
+    return new JwtTokenProvider({
+      tokenUrl: auth.tokenUrl,
+      clientId: auth.clientId,
+      clientSecret: auth.clientSecret,
+      username: auth.username,
+      password: auth.password,
+      logger: logger2
+    });
+  }
+  return new NullTokenProvider();
+}
+
+// src/reporting/attachments.ts
+async function attachText(testInfo, name, body) {
+  await testInfo.attach(name, { body, contentType: "text/plain" });
+}
+
+// src/fixtures/diagnostics.fixture.ts
+function collectDiagnostics(page, config) {
+  const collected = { consoleErrors: [], pageErrors: [], failedRequests: [] };
+  const isIgnored = (text) => config.ignoreConsolePatterns.some((pattern) => text.includes(pattern));
+  page.on("console", (message) => {
+    if (message.type() !== "error") return;
+    const text = message.text();
+    if (!isIgnored(text)) collected.consoleErrors.push(text);
+  });
+  page.on("pageerror", (error) => {
+    collected.pageErrors.push(error.message);
+  });
+  page.on("requestfailed", (request) => {
+    collected.failedRequests.push(
+      `${request.method()} ${request.url()} \u2014 ${request.failure()?.errorText ?? "failed"}`
+    );
+  });
+  const report = async (testInfo) => {
+    if (collected.consoleErrors.length > 0) {
+      await attachText(testInfo, "console-errors", collected.consoleErrors.join("\n"));
+    }
+    if (collected.pageErrors.length > 0) {
+      await attachText(testInfo, "page-errors", collected.pageErrors.join("\n"));
+    }
+    if (collected.failedRequests.length > 0) {
+      await attachText(testInfo, "failed-requests", collected.failedRequests.join("\n"));
+    }
+    if (testInfo.status !== "passed") return;
+    if (config.failOnPageError && collected.pageErrors.length > 0) {
+      throw new Error(`Uncaught page error(s):
+${collected.pageErrors.join("\n")}`);
+    }
+    if (config.failOnConsoleError && collected.consoleErrors.length > 0) {
+      throw new Error(`Console error(s):
+${collected.consoleErrors.join("\n")}`);
+    }
+  };
+  return { collected, report };
+}
+var expect = expect$1.extend({
+  /**
+   * Asserts the status of an `ApiResponse` from `apiClient.send()`, printing the body on
+   * failure — otherwise a wrong status tells you nothing about why.
+   */
+  toHaveStatus(received, expected) {
+    const pass = received.status === expected;
+    return {
+      pass,
+      name: "toHaveStatus",
+      expected,
+      actual: received.status,
+      message: () => pass ? `Expected status not to be ${expected}` : `Expected ${received.method} ${received.url} to return ${expected}, got ${received.status}
+Body: ${JSON.stringify(received.data, null, 2)}`
+    };
+  },
+  /** Asserts a value matches a zod schema, listing the exact field-level issues on failure. */
+  toMatchSchema(received, schema) {
+    const result = schema.safeParse(received);
+    return {
+      pass: result.success,
+      name: "toMatchSchema",
+      message: () => result.success ? "Expected value not to match the schema" : `Value did not match the schema:
+${result.error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n")}`
+    };
+  }
+});
+
+// src/fixtures/base-test.ts
+var test = test$1.extend({
+  workerConfig: [
+    async ({}, use) => {
+      await use(loadConfig());
+    },
+    { scope: "worker" }
+  ],
+  appConfig: async ({ workerConfig }, use) => {
+    await use(workerConfig);
+  },
+  logger: async ({ appConfig }, use, testInfo) => {
+    await use(createLogger({ level: appConfig.logLevel, name: testInfo.title }));
+  },
+  tokenProvider: async ({ appConfig, logger: logger2 }, use) => {
+    await use(resolveTokenProvider(appConfig, logger2));
+  },
+  apiClient: async ({ appConfig, tokenProvider, logger: logger2, request }, use) => {
+    await use(
+      new ApiClient({
+        request,
+        baseUrl: appConfig.apiBaseUrl ?? appConfig.baseUrl,
+        tokenProvider,
+        logger: logger2,
+        retry: {
+          retries: appConfig.retry.retries,
+          minDelayMs: appConfig.retry.minDelayMs,
+          maxDelayMs: appConfig.retry.maxDelayMs
+        }
+      })
+    );
+  },
+  retry: async ({ logger: logger2 }, use) => {
+    const boundRetry = (fn, options) => withRetry(fn, {
+      onRetry: (error, attempt) => logger2.warn({ err: error, attempt }, "retrying operation"),
+      ...options
+    });
+    await use(boundRetry);
+  },
+  cleanup: async ({ logger: logger2 }, use) => {
+    const tasks = [];
+    await use((task) => {
+      tasks.push(task);
+    });
+    for (const task of tasks.reverse()) {
+      try {
+        await task();
+      } catch (error) {
+        logger2.error({ err: error }, "cleanup task failed");
+      }
+    }
+  },
+  // Overriding `page` (instead of an auto fixture) keeps API-only tests from launching a
+  // browser: the override only runs for tests that actually request a page.
+  page: async ({ page, appConfig }, use, testInfo) => {
+    if (!appConfig.diagnostics.enabled) {
+      await use(page);
+      return;
+    }
+    const diagnostics = collectDiagnostics(page, appConfig.diagnostics);
+    await use(page);
+    await diagnostics.report(testInfo);
+  },
+  // testInfo-only, so this is safe to run automatically for every test.
+  _testCaseLinks: [
+    async ({ appConfig }, use, testInfo) => {
+      linkTestCases(testInfo, appConfig.reporting.testCaseUrlTemplate);
+      await use();
+    },
+    { auto: true }
+  ]
+});
+
+export { collectDiagnostics, expect, resolveTokenProvider, test };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map