@hyperfixi/testing-framework 2.7.2 → 2.9.0

package/dist/runner.mjs

@@ -0,0 +1,1097 @@
+import { JSDOM } from 'jsdom';
+import { diffLines } from 'diff';
+
+/* Testing Framework for HyperFixi Applications */
+
+var AssertionError = class extends Error {
+  constructor(message, expected, actual, operator) {
+    super(message);
+    this.expected = expected;
+    this.actual = actual;
+    this.operator = operator;
+    this.name = "AssertionError";
+  }
+};
+function deepEqual(actual, expected) {
+  if (actual === expected) return true;
+  if (actual == null || expected == null) return actual === expected;
+  if (typeof actual !== typeof expected) return false;
+  if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+  }
+  if (actual instanceof RegExp && expected instanceof RegExp) {
+    return actual.toString() === expected.toString();
+  }
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    if (actual.length !== expected.length) return false;
+    for (let i = 0; i < actual.length; i++) {
+      if (!deepEqual(actual[i], expected[i])) return false;
+    }
+    return true;
+  }
+  if (typeof actual === "object" && typeof expected === "object") {
+    const actualKeys = Object.keys(actual);
+    const expectedKeys = Object.keys(expected);
+    if (actualKeys.length !== expectedKeys.length) return false;
+    for (const key of actualKeys) {
+      if (!expectedKeys.includes(key)) return false;
+      if (!deepEqual(actual[key], expected[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function generateDiff(actual, expected) {
+  const actualStr = typeof actual === "string" ? actual : JSON.stringify(actual, null, 2);
+  const expectedStr = typeof expected === "string" ? expected : JSON.stringify(expected, null, 2);
+  const diff = diffLines(expectedStr, actualStr);
+  return diff.map((part) => {
+    const prefix = part.added ? "+" : part.removed ? "-" : " ";
+    return part.value.split("\n").map((line) => `${prefix} ${line}`).join("\n");
+  }).join("\n");
+}
+function isInDocument(element) {
+  if (typeof document === "undefined") return false;
+  return document.contains(element);
+}
+function isVisible(element) {
+  if (!isInDocument(element)) return false;
+  const style = window.getComputedStyle(element);
+  return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+}
+var ExpectMatcherImpl = class _ExpectMatcherImpl {
+  constructor(actual, isNot = false) {
+    this.actual = actual;
+    this.isNot = isNot;
+  }
+  get not() {
+    return new _ExpectMatcherImpl(this.actual, !this.isNot);
+  }
+  get resolves() {
+    if (!this.isPromise(this.actual)) {
+      throw new AssertionError("Expected value to be a Promise");
+    }
+    return new _ExpectMatcherImpl(
+      this.actual.then((value) => value),
+      this.isNot
+    );
+  }
+  get rejects() {
+    if (!this.isPromise(this.actual)) {
+      throw new AssertionError("Expected value to be a Promise");
+    }
+    return new _ExpectMatcherImpl(
+      this.actual.then(
+        (value) => {
+          throw new Error("Promise did not reject");
+        },
+        (error) => error
+      ),
+      this.isNot
+    );
+  }
+  toBe(expected) {
+    const passed = this.actual === expected;
+    this.assert(
+      passed,
+      "toBe",
+      expected,
+      `Expected ${this.format(this.actual)} to be ${this.format(expected)}`
+    );
+  }
+  toEqual(expected) {
+    const passed = deepEqual(this.actual, expected);
+    this.assert(
+      passed,
+      "toEqual",
+      expected,
+      `Expected ${this.format(this.actual)} to equal ${this.format(expected)}`
+    );
+  }
+  toStrictEqual(expected) {
+    const passed = this.actual === expected && deepEqual(this.actual, expected);
+    this.assert(
+      passed,
+      "toStrictEqual",
+      expected,
+      `Expected ${this.format(this.actual)} to strictly equal ${this.format(expected)}`
+    );
+  }
+  toBeTruthy() {
+    const passed = Boolean(this.actual);
+    this.assert(passed, "toBeTruthy", true, `Expected ${this.format(this.actual)} to be truthy`);
+  }
+  toBeFalsy() {
+    const passed = !Boolean(this.actual);
+    this.assert(passed, "toBeFalsy", false, `Expected ${this.format(this.actual)} to be falsy`);
+  }
+  toBeNull() {
+    const passed = this.actual === null;
+    this.assert(passed, "toBeNull", null, `Expected ${this.format(this.actual)} to be null`);
+  }
+  toBeUndefined() {
+    const passed = this.actual === void 0;
+    this.assert(
+      passed,
+      "toBeUndefined",
+      void 0,
+      `Expected ${this.format(this.actual)} to be undefined`
+    );
+  }
+  toBeDefined() {
+    const passed = this.actual !== void 0;
+    this.assert(
+      passed,
+      "toBeDefined",
+      "defined",
+      `Expected ${this.format(this.actual)} to be defined`
+    );
+  }
+  toBeNaN() {
+    const passed = Number.isNaN(this.actual);
+    this.assert(passed, "toBeNaN", NaN, `Expected ${this.format(this.actual)} to be NaN`);
+  }
+  toBeInstanceOf(constructor) {
+    const passed = this.actual instanceof constructor;
+    this.assert(
+      passed,
+      "toBeInstanceOf",
+      constructor,
+      `Expected ${this.format(this.actual)} to be instance of ${constructor.name}`
+    );
+  }
+  toBeCloseTo(expected, precision = 2) {
+    if (typeof this.actual !== "number" || typeof expected !== "number") {
+      throw new AssertionError("Expected both values to be numbers");
+    }
+    const diff = Math.abs(this.actual - expected);
+    const passed = diff < Math.pow(10, -precision) / 2;
+    this.assert(
+      passed,
+      "toBeCloseTo",
+      expected,
+      `Expected ${this.actual} to be close to ${expected} (precision: ${precision})`
+    );
+  }
+  toMatch(expected) {
+    if (typeof this.actual !== "string") {
+      throw new AssertionError("Expected value to be a string");
+    }
+    const regex = typeof expected === "string" ? new RegExp(expected) : expected;
+    const passed = regex.test(this.actual);
+    this.assert(passed, "toMatch", expected, `Expected "${this.actual}" to match ${expected}`);
+  }
+  toContain(expected) {
+    let passed = false;
+    if (typeof this.actual === "string" && typeof expected === "string") {
+      passed = this.actual.includes(expected);
+    } else if (Array.isArray(this.actual)) {
+      passed = this.actual.includes(expected);
+    } else if (this.actual && typeof this.actual.has === "function") {
+      passed = this.actual.has(expected);
+    }
+    this.assert(
+      passed,
+      "toContain",
+      expected,
+      `Expected ${this.format(this.actual)} to contain ${this.format(expected)}`
+    );
+  }
+  toHaveLength(expected) {
+    if (this.actual == null || typeof this.actual.length !== "number") {
+      throw new AssertionError("Expected value to have a length property");
+    }
+    const passed = this.actual.length === expected;
+    this.assert(
+      passed,
+      "toHaveLength",
+      expected,
+      `Expected length ${this.actual.length} to be ${expected}`
+    );
+  }
+  toContainEqual(expected) {
+    if (!Array.isArray(this.actual)) {
+      throw new AssertionError("Expected value to be an array");
+    }
+    const passed = this.actual.some((item) => deepEqual(item, expected));
+    this.assert(
+      passed,
+      "toContainEqual",
+      expected,
+      `Expected array to contain equal to ${this.format(expected)}`
+    );
+  }
+  toHaveProperty(path, value) {
+    const keys = path.split(".");
+    let current = this.actual;
+    for (const key of keys) {
+      if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {
+        this.assert(false, "toHaveProperty", path, `Expected object to have property "${path}"`);
+        return;
+      }
+      current = current[key];
+    }
+    if (value !== void 0) {
+      const passed = deepEqual(current, value);
+      this.assert(
+        passed,
+        "toHaveProperty",
+        value,
+        `Expected property "${path}" to have value ${this.format(value)}, got ${this.format(current)}`
+      );
+    } else {
+      this.assert(true, "toHaveProperty", path, "");
+    }
+  }
+  toMatchObject(expected) {
+    if (typeof this.actual !== "object" || this.actual === null) {
+      throw new AssertionError("Expected value to be an object");
+    }
+    const passed = Object.keys(expected).every(
+      (key) => deepEqual(this.actual[key], expected[key])
+    );
+    this.assert(
+      passed,
+      "toMatchObject",
+      expected,
+      `Expected object to match ${this.format(expected)}`
+    );
+  }
+  // DOM-specific matchers
+  toBeInTheDocument() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = isInDocument(this.actual);
+    this.assert(
+      passed,
+      "toBeInTheDocument",
+      "in document",
+      "Expected element to be in the document"
+    );
+  }
+  toBeVisible() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = isVisible(this.actual);
+    this.assert(passed, "toBeVisible", "visible", "Expected element to be visible");
+  }
+  toBeDisabled() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.disabled === true || this.actual.hasAttribute("disabled");
+    this.assert(passed, "toBeDisabled", "disabled", "Expected element to be disabled");
+  }
+  toBeEnabled() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.disabled !== true && !this.actual.hasAttribute("disabled");
+    this.assert(passed, "toBeEnabled", "enabled", "Expected element to be enabled");
+  }
+  toBeChecked() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.checked === true;
+    this.assert(passed, "toBeChecked", "checked", "Expected element to be checked");
+  }
+  toHaveClass(className) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.classList.contains(className);
+    this.assert(passed, "toHaveClass", className, `Expected element to have class "${className}"`);
+  }
+  toHaveAttribute(name, value) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    if (value === void 0) {
+      const passed = this.actual.hasAttribute(name);
+      this.assert(
+        passed,
+        "toHaveAttribute",
+        `attribute "${name}"`,
+        `Expected element to have attribute "${name}"`
+      );
+    } else {
+      const passed = this.actual.getAttribute(name) === value;
+      this.assert(
+        passed,
+        "toHaveAttribute",
+        `${name}="${value}"`,
+        `Expected element to have attribute "${name}" with value "${value}"`
+      );
+    }
+  }
+  toHaveTextContent(text) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const textContent = this.actual.textContent || "";
+    const passed = typeof text === "string" ? textContent === text : text.test(textContent);
+    this.assert(
+      passed,
+      "toHaveTextContent",
+      text,
+      `Expected element to have text content "${text}"`
+    );
+  }
+  toHaveValue(value) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const actualValue = this.actual.value;
+    const passed = actualValue === value;
+    this.assert(
+      passed,
+      "toHaveValue",
+      value,
+      `Expected element to have value "${value}", got "${actualValue}"`
+    );
+  }
+  // HyperScript-specific matchers
+  toHaveCompiledScript() {
+    const passed = this.actual && typeof this.actual._hyperscript !== "undefined";
+    this.assert(
+      passed,
+      "toHaveCompiledScript",
+      "compiled script",
+      "Expected element to have compiled hyperscript"
+    );
+  }
+  toHaveExecutedScript() {
+    const passed = this.actual && this.actual._hyperscriptExecuted === true;
+    this.assert(
+      passed,
+      "toHaveExecutedScript",
+      "executed script",
+      "Expected hyperscript to have executed"
+    );
+  }
+  toHaveTriggeredEvent(eventType) {
+    const passed = this.actual && this.actual._triggeredEvents && this.actual._triggeredEvents.includes(eventType);
+    this.assert(
+      passed,
+      "toHaveTriggeredEvent",
+      eventType,
+      `Expected event "${eventType}" to have been triggered`
+    );
+  }
+  toHaveUpdatedElement() {
+    const passed = this.actual && this.actual._wasUpdated === true;
+    this.assert(
+      passed,
+      "toHaveUpdatedElement",
+      "updated element",
+      "Expected element to have been updated"
+    );
+  }
+  assert(passed, operator, expected, message) {
+    if (this.isNot) {
+      passed = !passed;
+      message = message.replace("Expected", "Expected NOT");
+    }
+    if (!passed) {
+      const error = new AssertionError(message, expected, this.actual, operator);
+      if (typeof this.actual === "object" && typeof expected === "object") {
+        error.message += "\n\nDiff:\n" + generateDiff(this.actual, expected);
+      }
+      throw error;
+    }
+  }
+  format(value) {
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    if (typeof value === "string") return `"${value}"`;
+    if (typeof value === "function") return value.name || "function";
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof RegExp) return value.toString();
+    if (Array.isArray(value)) return `[${value.map((v) => this.format(v)).join(", ")}]`;
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  }
+  isPromise(value) {
+    return value && typeof value.then === "function";
+  }
+};
+function createExpectAPI() {
+  return function expect(actual) {
+    return new ExpectMatcherImpl(actual);
+  };
+}
+var AssertAPIImpl = class {
+  ok(value, message) {
+    if (!value) {
+      throw new AssertionError(message || `Expected ${value} to be truthy`);
+    }
+  }
+  equal(actual, expected, message) {
+    if (actual != expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to equal ${expected}`,
+        expected,
+        actual,
+        "equal"
+      );
+    }
+  }
+  strictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to strictly equal ${expected}`,
+        expected,
+        actual,
+        "strictEqual"
+      );
+    }
+  }
+  notEqual(actual, expected, message) {
+    if (actual == expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to not equal ${expected}`,
+        expected,
+        actual,
+        "notEqual"
+      );
+    }
+  }
+  notStrictEqual(actual, expected, message) {
+    if (actual === expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to not strictly equal ${expected}`,
+        expected,
+        actual,
+        "notStrictEqual"
+      );
+    }
+  }
+  throws(fn, error, message) {
+    let thrown = false;
+    let actualError;
+    try {
+      fn();
+    } catch (e) {
+      thrown = true;
+      actualError = e;
+    }
+    if (!thrown) {
+      throw new AssertionError(message || "Expected function to throw");
+    }
+    if (error && !this.matchesError(actualError, error)) {
+      throw new AssertionError(
+        message || `Expected function to throw ${error}, but got ${actualError}`,
+        error,
+        actualError,
+        "throws"
+      );
+    }
+  }
+  doesNotThrow(fn, message) {
+    try {
+      fn();
+    } catch (e) {
+      throw new AssertionError(
+        message || `Expected function to not throw, but got: ${e}`,
+        "no error",
+        e,
+        "doesNotThrow"
+      );
+    }
+  }
+  ifError(value) {
+    if (value) {
+      throw value;
+    }
+  }
+  async rejects(promise, error, message) {
+    let rejected = false;
+    let actualError;
+    try {
+      await promise;
+    } catch (e) {
+      rejected = true;
+      actualError = e;
+    }
+    if (!rejected) {
+      throw new AssertionError(message || "Expected promise to reject");
+    }
+    if (error && !this.matchesError(actualError, error)) {
+      throw new AssertionError(
+        message || `Expected promise to reject with ${error}, but got ${actualError}`,
+        error,
+        actualError,
+        "rejects"
+      );
+    }
+  }
+  async doesNotReject(promise, message) {
+    try {
+      await promise;
+    } catch (e) {
+      throw new AssertionError(
+        message || `Expected promise to not reject, but got: ${e}`,
+        "no error",
+        e,
+        "doesNotReject"
+      );
+    }
+  }
+  elementExists(selector, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(message || `Expected element with selector "${selector}" to exist`);
+    }
+  }
+  elementVisible(selector, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (!isVisible(element)) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to be visible`
+      );
+    }
+  }
+  elementHasClass(selector, className, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (!element.classList.contains(className)) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to have class "${className}"`
+      );
+    }
+  }
+  elementHasText(selector, text, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (element.textContent !== text) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to have text "${text}"`
+      );
+    }
+  }
+  scriptCompiled(script, message) {
+    throw new AssertionError(message || "Script compilation assertion not implemented");
+  }
+  scriptExecuted(script, message) {
+    throw new AssertionError(message || "Script execution assertion not implemented");
+  }
+  eventTriggered(eventType, message) {
+    throw new AssertionError(message || "Event trigger assertion not implemented");
+  }
+  matchesError(actual, expected) {
+    if (typeof expected === "string") {
+      return actual.message === expected;
+    }
+    if (expected instanceof RegExp) {
+      return expected.test(actual.message);
+    }
+    if (typeof expected === "function") {
+      return actual instanceof expected;
+    }
+    return actual === expected;
+  }
+};
+function createAssertAPI() {
+  return new AssertAPIImpl();
+}
+
+// src/runner.ts
+var CoreTestRunner = class {
+  constructor() {
+    this.executionContext = null;
+  }
+  /**
+   * Run all test suites
+   */
+  async run(suites, config) {
+    const results = [];
+    this.executionContext = await this.setupExecutionContext(config);
+    try {
+      await this.runSetupFiles(config.setupFiles);
+      for (const suite of suites) {
+        const suiteResults = await this.runSuite(suite, config);
+        results.push(...suiteResults);
+      }
+      await this.runTeardownFiles(config.teardownFiles);
+    } finally {
+      await this.cleanupExecutionContext();
+    }
+    return results;
+  }
+  /**
+   * Run a single test suite
+   */
+  async runSuite(suite, config) {
+    const results = [];
+    if (suite.skip) {
+      for (const test of suite.tests) {
+        results.push(this.createSkippedResult(suite.name, test.name));
+      }
+      return results;
+    }
+    try {
+      if (suite.setup) {
+        await suite.setup();
+      }
+      for (const test of suite.tests) {
+        const result = await this.runTest(test, this.createTestContext(suite, test, config));
+        results.push(result);
+      }
+      for (const nestedSuite of suite.suites) {
+        const nestedResults = await this.runSuite(nestedSuite, config);
+        results.push(...nestedResults);
+      }
+    } catch (error) {
+      const testError = this.formatError(error);
+      for (const test of suite.tests) {
+        results.push({
+          suite: suite.name,
+          test: test.name,
+          status: "failed",
+          duration: 0,
+          error: testError,
+          logs: [],
+          screenshots: []
+        });
+      }
+    } finally {
+      try {
+        if (suite.teardown) {
+          await suite.teardown();
+        }
+      } catch (error) {
+        console.error("Suite teardown failed:", error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Run a single test
+   */
+  async runTest(test, context) {
+    const startTime = Date.now();
+    if (test.skip) {
+      return this.createSkippedResult(context.suite, context.test);
+    }
+    let status = "running";
+    let error;
+    const logs = [];
+    const screenshots = [];
+    try {
+      await this.setupTestFixtures(test, context);
+      await this.runBeforeEachHooks(context);
+      const timeout = test.timeout || this.executionContext?.config.timeout || 5e3;
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Test timeout after ${timeout}ms`)), timeout);
+      });
+      await Promise.race([test.fn(context), timeoutPromise]);
+      status = "passed";
+    } catch (err) {
+      status = "failed";
+      error = this.formatError(err);
+      if (this.executionContext?.page && this.executionContext.config.environment === "browser") {
+        try {
+          const screenshotPath = await this.takeScreenshot(context.suite, context.test);
+          if (screenshotPath) {
+            screenshots.push(screenshotPath);
+          }
+        } catch (screenshotError) {
+          console.warn("Failed to take screenshot:", screenshotError);
+        }
+      }
+    } finally {
+      try {
+        await this.runAfterEachHooks(context);
+        await this.cleanupTestFixtures(test, context);
+      } catch (cleanupError) {
+        console.error("Test cleanup failed:", cleanupError);
+      }
+    }
+    const duration = Date.now() - startTime;
+    return {
+      suite: context.suite,
+      test: context.test,
+      status,
+      duration,
+      error,
+      logs: [...logs, ...this.executionContext?.logs || []],
+      screenshots
+    };
+  }
+  /**
+   * Setup execution context
+   */
+  async setupExecutionContext(config) {
+    const context = {
+      config,
+      logs: [],
+      screenshots: []
+    };
+    switch (config.environment) {
+      case "jsdom":
+        await this.setupJSDOMContext(context);
+        break;
+      case "browser":
+      case "playwright":
+        await this.setupBrowserContext(context);
+        break;
+      case "puppeteer":
+        await this.setupPuppeteerContext(context);
+        break;
+    }
+    return context;
+  }
+  /**
+   * Setup JSDOM context
+   */
+  async setupJSDOMContext(context) {
+    const { config } = context;
+    const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+      url: config.baseURL || "http://localhost",
+      contentType: "text/html",
+      pretendToBeVisual: true,
+      resources: "usable"
+    });
+    global.window = dom.window;
+    global.document = dom.window.document;
+    global.navigator = dom.window.navigator;
+    global.location = dom.window.location;
+    global.HTMLElement = dom.window.HTMLElement;
+    global.Event = dom.window.Event;
+    global.CustomEvent = dom.window.CustomEvent;
+  }
+  /**
+   * Setup browser context (Playwright)
+   */
+  async setupBrowserContext(context) {
+    try {
+      const { chromium, firefox, webkit } = await import('playwright');
+      const { config } = context;
+      let browserEngine;
+      switch (config.browser) {
+        case "firefox":
+          browserEngine = firefox;
+          break;
+        case "webkit":
+          browserEngine = webkit;
+          break;
+        default:
+          browserEngine = chromium;
+      }
+      const browser = await browserEngine.launch({
+        headless: config.headless
+      });
+      context.browser = browser;
+      const browserContext = await browser.newContext({
+        ...config.viewport && { viewport: config.viewport },
+        ...config.baseURL && { baseURL: config.baseURL }
+      });
+      context.page = await browserContext.newPage();
+      context.page.on("console", (msg) => {
+        context.logs.push({
+          level: msg.type(),
+          message: msg.text(),
+          timestamp: Date.now(),
+          source: "browser"
+        });
+      });
+      context.page.on("pageerror", (error) => {
+        context.logs.push({
+          level: "error",
+          message: error.message,
+          timestamp: Date.now(),
+          source: "browser"
+        });
+      });
+    } catch (error) {
+      throw new Error(`Failed to setup browser context: ${error}`);
+    }
+  }
+  /**
+   * Setup Puppeteer context
+   */
+  async setupPuppeteerContext(context) {
+    try {
+      const puppeteer = await import('puppeteer');
+      const { config } = context;
+      const browser = await puppeteer.default.launch({
+        headless: config.headless,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+      context.browser = browser;
+      context.page = await browser.newPage();
+      await context.page.setViewport(config.viewport);
+      if (config.baseURL) {
+        await context.page.goto(config.baseURL);
+      }
+      context.page.on("console", (msg) => {
+        context.logs.push({
+          level: msg.type(),
+          message: msg.text(),
+          timestamp: Date.now(),
+          source: "browser"
+        });
+      });
+      context.page.on("pageerror", (error) => {
+        context.logs.push({
+          level: "error",
+          message: error.message,
+          timestamp: Date.now(),
+          source: "browser"
+        });
+      });
+    } catch (error) {
+      throw new Error(`Failed to setup Puppeteer context: ${error}`);
+    }
+  }
+  /**
+   * Create test context
+   */
+  createTestContext(suite, test, config) {
+    const context = {
+      suite: suite.name,
+      test: test.name,
+      environment: config.environment,
+      fixtures: { ...config.fixtures, ...test.fixtures },
+      expect: createExpectAPI(),
+      assert: createAssertAPI(),
+      skip: () => {
+        throw new Error("SKIP_TEST");
+      },
+      fail: (message) => {
+        throw new Error(message);
+      },
+      timeout: (ms) => {
+      }
+    };
+    if (this.executionContext?.page) {
+      context.page = this.executionContext.page;
+      context.browser = this.executionContext.browser;
+    }
+    if (config.environment === "jsdom") {
+      context.document = global.document;
+      context.window = global.window;
+    }
+    return context;
+  }
+  /**
+   * Setup test fixtures
+   */
+  async setupTestFixtures(test, context) {
+  }
+  /**
+   * Cleanup test fixtures
+   */
+  async cleanupTestFixtures(test, context) {
+  }
+  /**
+   * Run beforeEach hooks
+   */
+  async runBeforeEachHooks(context) {
+  }
+  /**
+   * Run afterEach hooks
+   */
+  async runAfterEachHooks(context) {
+  }
+  /**
+   * Run setup files
+   */
+  async runSetupFiles(setupFiles) {
+    for (const file of setupFiles) {
+      try {
+        await import(file);
+      } catch (error) {
+        console.error(`Failed to run setup file ${file}:`, error);
+        throw error;
+      }
+    }
+  }
+  /**
+   * Run teardown files
+   */
+  async runTeardownFiles(teardownFiles) {
+    for (const file of teardownFiles) {
+      try {
+        await import(file);
+      } catch (error) {
+        console.error(`Failed to run teardown file ${file}:`, error);
+      }
+    }
+  }
+  /**
+   * Take screenshot
+   */
+  async takeScreenshot(suite, test) {
+    if (!this.executionContext?.page) return null;
+    try {
+      const filename = `${suite}-${test}-${Date.now()}.png`;
+      const path = `./screenshots/${filename}`;
+      await this.executionContext.page.screenshot({
+        path,
+        fullPage: true
+      });
+      return path;
+    } catch (error) {
+      console.error("Screenshot failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Format error for test result
+   */
+  formatError(error) {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return {
+      name: "Error",
+      message: String(error)
+    };
+  }
+  /**
+   * Create skipped test result
+   */
+  createSkippedResult(suite, test) {
+    return {
+      suite,
+      test,
+      status: "skipped",
+      duration: 0,
+      logs: [],
+      screenshots: []
+    };
+  }
+  /**
+   * Cleanup execution context
+   */
+  async cleanupExecutionContext() {
+    if (!this.executionContext) return;
+    try {
+      if (this.executionContext.browser) {
+        await this.executionContext.browser.close();
+      }
+      if (this.executionContext.config.environment === "jsdom") {
+        delete global.window;
+        delete global.document;
+        delete global.navigator;
+        delete global.location;
+        delete global.HTMLElement;
+        delete global.Event;
+        delete global.CustomEvent;
+      }
+    } catch (error) {
+      console.error("Cleanup failed:", error);
+    } finally {
+      this.executionContext = null;
+    }
+  }
+};
+var ParallelTestRunner = class extends CoreTestRunner {
+  /**
+   * Run test suites in parallel
+   */
+  async run(suites, config) {
+    if (!config.parallel || config.maxWorkers <= 1) {
+      return super.run(suites, config);
+    }
+    const workers = Math.min(config.maxWorkers, suites.length);
+    const chunks = this.chunkSuites(suites, workers);
+    const workerPromises = chunks.map((chunk) => this.runWorker(chunk, config));
+    const workerResults = await Promise.all(workerPromises);
+    return workerResults.flat();
+  }
+  /**
+   * Split suites into chunks for parallel execution
+   */
+  chunkSuites(suites, chunkCount) {
+    const chunks = [];
+    const chunkSize = Math.ceil(suites.length / chunkCount);
+    for (let i = 0; i < suites.length; i += chunkSize) {
+      chunks.push(suites.slice(i, i + chunkSize));
+    }
+    return chunks;
+  }
+  /**
+   * Run a worker with assigned test suites
+   */
+  async runWorker(suites, config) {
+    const worker = new CoreTestRunner();
+    return worker.run(suites, config);
+  }
+};
+function createTestRunner(config) {
+  if (config.parallel && config.maxWorkers > 1) {
+    return new ParallelTestRunner();
+  }
+  return new CoreTestRunner();
+}
+async function measurePerformance(page, testFn) {
+  await page.evaluate(() => {
+    performance.clearMarks();
+    performance.clearMeasures();
+  });
+  const startTime = Date.now();
+  await testFn();
+  const metrics = await page.evaluate(() => {
+    const navigation = performance.getEntriesByType("navigation")[0];
+    const paint = performance.getEntriesByType("paint");
+    const firstPaint = paint.find((entry) => entry.name === "first-paint")?.startTime || 0;
+    const firstContentfulPaint = paint.find((entry) => entry.name === "first-contentful-paint")?.startTime || 0;
+    return {
+      loadTime: navigation ? navigation.loadEventEnd - navigation.startTime : 0,
+      domContentLoaded: navigation ? navigation.domContentLoadedEventEnd - navigation.startTime : 0,
+      firstPaint,
+      firstContentfulPaint,
+      largestContentfulPaint: 0,
+      // Would need additional measurement
+      cumulativeLayoutShift: 0,
+      // Would need additional measurement
+      firstInputDelay: 0,
+      // Would need additional measurement
+      memoryUsage: performance.memory ? {
+        usedJSHeapSize: performance.memory.usedJSHeapSize,
+        totalJSHeapSize: performance.memory.totalJSHeapSize,
+        jsHeapSizeLimit: performance.memory.jsHeapSizeLimit
+      } : {
+        usedJSHeapSize: 0,
+        totalJSHeapSize: 0,
+        jsHeapSizeLimit: 0
+      }
+    };
+  });
+  return {
+    ...metrics,
+    loadTime: metrics.loadTime || Date.now() - startTime
+  };
+}
+
+export { CoreTestRunner, ParallelTestRunner, createTestRunner, measurePerformance };
+//# sourceMappingURL=runner.mjs.map
+//# sourceMappingURL=runner.mjs.map