@testspectra/cli 1.0.7 → 1.0.10

package/src/runner/bridge.ts

@@ -1,146 +0,0 @@
-import { spawn } from "child_process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { ConfigData } from "../config/schema.js";
-import { Reporter, TestRunResult } from "./reporter.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export interface RunOptions {
-  baseDir: string;
-  appDataPath: string;
-  platform: "web" | "android" | "ios" | "common";
-  suite: string;
-  testCases: Array<{ id: string; title: string; executionOrder?: number }>;
-  config: ConfigData;
-  targetDevice?: string;
-  outputJsonPath?: string;
-}
-
-export class RustCoreBridge {
-  static resolveBinaryPath(): string {
-    // 1. Look for precompiled release/debug binary in workspace target
-    const workspaceRoot = path.resolve(__dirname, "../../..");
-    const candidatePaths = [
-      path.join(workspaceRoot, "target/debug/testspectra-runner"),
-      path.join(workspaceRoot, "target/release/testspectra-runner"),
-      path.join(workspaceRoot, "core/test-runner/target/debug/testspectra-runner"),
-      path.join(workspaceRoot, "core/test-runner/target/release/testspectra-runner"),
-      path.join(__dirname, "../../bin/testspectra-runner"),
-    ];
-
-    for (const p of candidatePaths) {
-      if (fs.existsSync(p)) {
-        return p;
-      }
-      if (fs.existsSync(`${p}.exe`)) {
-        return `${p}.exe`;
-      }
-    }
-
-    return "cargo"; // Fallback to cargo run
-  }
-
-  static async run(options: RunOptions, reporter: Reporter): Promise<TestRunResult> {
-    const binPath = this.resolveBinaryPath();
-    const payload = JSON.stringify({
-      baseDir: options.baseDir,
-      appDataPath: options.appDataPath,
-      platform: options.platform,
-      suite: options.suite,
-      testCases: options.testCases,
-      config: options.config,
-      targetDevice: options.targetDevice,
-    });
-
-    return new Promise<TestRunResult>((resolve, reject) => {
-      let child;
-      if (binPath === "cargo") {
-        const workspaceRoot = path.resolve(__dirname, "../../..");
-        child = spawn(
-          "cargo",
-          ["run", "--manifest-path", "core/test-runner/Cargo.toml", "--bin", "testspectra-runner", "--", payload],
-          {
-            cwd: workspaceRoot,
-            env: { ...process.env, RUST_LOG: "info" },
-          }
-        );
-      } else {
-        child = spawn(binPath, [payload], {
-          env: { ...process.env, RUST_LOG: "info" },
-        });
-      }
-
-      let runStatus = "failed";
-      let runDuration = "0s";
-
-      child.stdout.on("data", (data) => {
-        const lines = data.toString().split("\n");
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const parsed = JSON.parse(line);
-            if (parsed.type === "log") {
-              reporter.addLog({
-                timestamp: parsed.timestamp,
-                level: parsed.level,
-                message: parsed.message,
-              });
-            } else if (parsed.type === "network") {
-              reporter.addNetwork({
-                requestId: parsed.requestId,
-                url: parsed.url,
-                method: parsed.method,
-                status: parsed.status,
-              });
-            } else if (parsed.type === "complete") {
-              runStatus = parsed.status;
-              runDuration = parsed.duration;
-            } else if (parsed.type === "error") {
-              reporter.addLog({
-                timestamp: new Date().toLocaleTimeString(),
-                level: "ERROR",
-                message: parsed.message,
-              });
-            }
-          } catch {
-            // Raw non-JSON output (cargo compile warnings, etc.)
-            console.log(line);
-          }
-        }
-      });
-
-      child.stderr.on("data", (data) => {
-        const str = data.toString();
-        // Ignore normal compilation progress
-        if (!str.includes("Compiling") && !str.includes("Checking") && !str.includes("Finished")) {
-          reporter.addLog({
-            timestamp: new Date().toLocaleTimeString(),
-            level: "DEBUG",
-            message: str.trim(),
-          });
-        }
-      });
-
-      child.on("close", (code) => {
-        const result = reporter.generateResult(code === 0 ? "passed" : runStatus, runDuration);
-
-        if (options.outputJsonPath) {
-          const outDir = path.dirname(options.outputJsonPath);
-          if (!fs.existsSync(outDir)) {
-            fs.mkdirSync(outDir, { recursive: true });
-          }
-          fs.writeFileSync(options.outputJsonPath, JSON.stringify(result, null, 2), "utf-8");
-        }
-
-        resolve(result);
-      });
-
-      child.on("error", (err) => {
-        reject(err);
-      });
-    });
-  }
-}

package/src/runner/reporter.ts

@@ -1,64 +0,0 @@
-export interface TestLog {
-  timestamp: string;
-  level: "INFO" | "SUCCESS" | "WARNING" | "ERROR" | "DEBUG" | string;
-  message: string;
-}
-
-export interface NetworkResource {
-  requestId: string;
-  url: string;
-  method: string;
-  status: number;
-}
-
-export interface TestRunResult {
-  status: "passed" | "failed" | "error" | string;
-  duration: string;
-  logs: TestLog[];
-  networkResources?: NetworkResource[];
-}
-
-export class Reporter {
-  private logs: TestLog[] = [];
-  private networkEvents: NetworkResource[] = [];
-
-  addLog(log: TestLog) {
-    this.logs.push(log);
-    const time = `\x1b[90m${log.timestamp}\x1b[0m`;
-    let prefix = `[${log.level}]`;
-    if (log.level === "SUCCESS" || log.level === "PASSED") {
-      prefix = `\x1b[32m${prefix}\x1b[0m`;
-    } else if (log.level === "ERROR" || log.level === "FAILED") {
-      prefix = `\x1b[31m${prefix}\x1b[0m`;
-    } else if (log.level === "WARN" || log.level === "WARNING") {
-      prefix = `\x1b[33m${prefix}\x1b[0m`;
-    } else if (log.level === "INFO") {
-      prefix = `\x1b[36m${prefix}\x1b[0m`;
-    } else {
-      prefix = `\x1b[90m${prefix}\x1b[0m`;
-    }
-
-    console.log(`${time} ${prefix} ${log.message}`);
-  }
-
-  addNetwork(res: NetworkResource) {
-    this.networkEvents.push(res);
-  }
-
-  getLogs(): TestLog[] {
-    return this.logs;
-  }
-
-  getNetworkEvents(): NetworkResource[] {
-    return this.networkEvents;
-  }
-
-  generateResult(status: string, duration: string): TestRunResult {
-    return {
-      status,
-      duration,
-      logs: this.logs,
-      networkResources: this.networkEvents,
-    };
-  }
-}

package/src/step/index.ts

@@ -1,6 +0,0 @@
-export * from "./types.js";
-export * from "./matchers.js";
-export * from "./runner/single.js";
-export * from "./runner/collection.js";
-export * from "./spectra.js";
-export * from "./proto.js";

package/src/step/matchers.ts

@@ -1,131 +0,0 @@
-import { SingleElementMatcher, MultiElementMatcher, ElementTarget } from "./types.js";
-
-/**
- * Resolves an ElementTarget (selector string, WebdriverIO.Element, or ChainablePromiseElement)
- * to an actionable WebdriverIO.Element.
- */
-export async function resolveElement(target: ElementTarget): Promise<WebdriverIO.Element> {
-  if (typeof target === "string") {
-    const el = await $(target);
-    return el as unknown as WebdriverIO.Element;
-  }
-  const el = await (target as any);
-  return el as unknown as WebdriverIO.Element;
-}
-
-/**
- * Executes a single element matcher against the WebdriverIO browser / element context.
- */
-export async function executeSingleMatcher(
-  target: ElementTarget | undefined,
-  matcher: SingleElementMatcher,
-  args: any[]
-): Promise<void> {
-  const isBrowserLevel =
-    matcher === "have.url" ||
-    matcher === "contain.url" ||
-    matcher === "have.title" ||
-    matcher === "contain.title";
-
-  if (isBrowserLevel) {
-    const expected = args[0];
-    switch (matcher) {
-      case "have.url":
-        await expect(browser).toHaveUrl(expected);
-        break;
-      case "contain.url":
-        await expect(browser).toHaveUrl(expect.stringContaining(expected));
-        break;
-      case "have.title":
-        await expect(browser).toHaveTitle(expected);
-        break;
-      case "contain.title":
-        await expect(browser).toHaveTitle(expect.stringContaining(expected));
-        break;
-    }
-    return;
-  }
-
-  if (!target) {
-    throw new Error(`Assertion matcher '${matcher}' requires an element target.`);
-  }
-
-  const el = await resolveElement(target);
-
-  switch (matcher) {
-    case "be.visible":
-      await expect(el).toBeDisplayed();
-      break;
-    case "not.be.visible":
-      await expect(el).not.toBeDisplayed();
-      break;
-    case "exist":
-      await expect(el).toExist();
-      break;
-    case "not.exist":
-      await expect(el).not.toExist();
-      break;
-    case "be.enabled":
-      await expect(el).toBeEnabled();
-      break;
-    case "be.disabled":
-      await expect(el).toBeDisabled();
-      break;
-    case "be.checked":
-    case "be.selected":
-      await expect(el).toBeSelected();
-      break;
-    case "have.value":
-      await expect(el).toHaveValue(args[0]);
-      break;
-    case "contain.value":
-      await expect(el).toHaveValue(expect.stringContaining(args[0]));
-      break;
-    case "have.text":
-      await expect(el).toHaveText(args[0]);
-      break;
-    case "contain.text":
-      await expect(el).toHaveText(expect.stringContaining(args[0]));
-      break;
-    case "have.class":
-      await expect(el).toHaveElementClass(args[0]);
-      break;
-    case "have.attr":
-      if (args.length >= 2) {
-        await expect(el).toHaveAttribute(args[0], args[1]);
-      } else {
-        await expect(el).toHaveAttribute(args[0]);
-      }
-      break;
-    default:
-      throw new Error(`Unsupported matcher: ${matcher}`);
-  }
-}
-
-/**
- * Executes a multi-element collection matcher against WebdriverIO $$.
- */
-export async function executeMultiMatcher(
-  selector: string,
-  matcher: MultiElementMatcher,
-  args: any[]
-): Promise<void> {
-  const elements = await $$(selector);
-
-  switch (matcher) {
-    case "have.length":
-      await expect(elements).toBeElementsArrayOfSize(args[0]);
-      break;
-    case "have.length.greaterThan":
-      await expect(elements).toBeElementsArrayOfSize({ gte: args[0] + 1 });
-      break;
-    case "be.empty":
-      await expect(elements).toBeElementsArrayOfSize(0);
-      break;
-    case "exist":
-      await expect(elements).toBeElementsArrayOfSize({ gte: 1 });
-      break;
-    default:
-      throw new Error(`Unsupported multi-element matcher: ${matcher}`);
-  }
-}

package/src/step/proto.ts

@@ -1,163 +0,0 @@
-import { ElementTarget } from "./types.js";
-import { resolveElement } from "./matchers.js";
-
-declare global {
-  namespace WebdriverIO {
-    interface Element {
-      shouldBeVisible(): Promise<Element>;
-      shouldNotBeVisible(): Promise<Element>;
-      shouldExist(): Promise<Element>;
-      shouldNotExist(): Promise<Element>;
-      shouldBeEnabled(): Promise<Element>;
-      shouldBeDisabled(): Promise<Element>;
-      shouldBeSelected(): Promise<Element>;
-      shouldBeChecked(): Promise<Element>;
-      shouldHaveValue(expectedValue: string): Promise<Element>;
-      shouldContainValue(expectedValue: string): Promise<Element>;
-      shouldHaveText(expectedText: string): Promise<Element>;
-      shouldContainText(expectedText: string): Promise<Element>;
-      shouldHaveClass(className: string): Promise<Element>;
-      shouldHaveAttribute(attributeName: string, expectedValue?: string): Promise<Element>;
-    }
-
-    interface Browser {
-      shouldHaveUrl(expectedUrl: string): Promise<void>;
-      shouldContainUrl(expectedUrl: string): Promise<void>;
-      shouldHaveTitle(expectedTitle: string): Promise<void>;
-      shouldContainTitle(expectedTitle: string): Promise<void>;
-    }
-  }
-
-  interface Promise<T> {
-    shouldBeVisible(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldNotBeVisible(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldExist(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldNotExist(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldBeEnabled(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldBeDisabled(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldBeSelected(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldBeChecked(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-    shouldHaveValue(this: Promise<WebdriverIO.Element>, expectedValue: string): Promise<WebdriverIO.Element>;
-    shouldContainValue(this: Promise<WebdriverIO.Element>, expectedValue: string): Promise<WebdriverIO.Element>;
-    shouldHaveText(this: Promise<WebdriverIO.Element>, expectedText: string): Promise<WebdriverIO.Element>;
-    shouldContainText(this: Promise<WebdriverIO.Element>, expectedText: string): Promise<WebdriverIO.Element>;
-    shouldHaveClass(this: Promise<WebdriverIO.Element>, className: string): Promise<WebdriverIO.Element>;
-    shouldHaveAttribute(this: Promise<WebdriverIO.Element>, attributeName: string, expectedValue?: string): Promise<WebdriverIO.Element>;
-  }
-}
-
-/**
- * Install direct callable assertion methods onto WebdriverIO browser/element and Promise prototypes.
- */
-export function installPrototypes() {
-  const elementCommands: Record<string, Function> = {
-    async shouldBeVisible(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toBeDisplayed();
-      return el;
-    },
-    async shouldNotBeVisible(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).not.toBeDisplayed();
-      return el;
-    },
-    async shouldExist(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toExist();
-      return el;
-    },
-    async shouldNotExist(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).not.toExist();
-      return el;
-    },
-    async shouldBeEnabled(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toBeEnabled();
-      return el;
-    },
-    async shouldBeDisabled(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toBeDisabled();
-      return el;
-    },
-    async shouldBeSelected(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toBeSelected();
-      return el;
-    },
-    async shouldBeChecked(this: any) {
-      const el = await resolveElement(this);
-      await expect(el).toBeSelected();
-      return el;
-    },
-    async shouldHaveValue(this: any, val: string) {
-      const el = await resolveElement(this);
-      await expect(el).toHaveValue(val);
-      return el;
-    },
-    async shouldContainValue(this: any, val: string) {
-      const el = await resolveElement(this);
-      await expect(el).toHaveValue(expect.stringContaining(val));
-      return el;
-    },
-    async shouldHaveText(this: any, text: string) {
-      const el = await resolveElement(this);
-      await expect(el).toHaveText(text);
-      return el;
-    },
-    async shouldContainText(this: any, text: string) {
-      const el = await resolveElement(this);
-      await expect(el).toHaveText(expect.stringContaining(text));
-      return el;
-    },
-    async shouldHaveClass(this: any, cls: string) {
-      const el = await resolveElement(this);
-      await expect(el).toHaveElementClass(cls);
-      return el;
-    },
-    async shouldHaveAttribute(this: any, name: string, val?: string) {
-      const el = await resolveElement(this);
-      if (val !== undefined) {
-        await expect(el).toHaveAttribute(name, val);
-      } else {
-        await expect(el).toHaveAttribute(name);
-      }
-      return el;
-    },
-  };
-
-  const browserCommands: Record<string, Function> = {
-    async shouldHaveUrl(url: string) {
-      await expect(browser).toHaveUrl(url);
-    },
-    async shouldContainUrl(url: string) {
-      await expect(browser).toHaveUrl(expect.stringContaining(url));
-    },
-    async shouldHaveTitle(title: string) {
-      await expect(browser).toHaveTitle(title);
-    },
-    async shouldContainTitle(title: string) {
-      await expect(browser).toHaveTitle(expect.stringContaining(title));
-    },
-  };
-
-  if (typeof browser !== "undefined" && (browser as any).addCommand) {
-    for (const [name, fn] of Object.entries(elementCommands)) {
-      (browser as any).addCommand(name, fn, true);
-    }
-    for (const [name, fn] of Object.entries(browserCommands)) {
-      (browser as any).addCommand(name, fn, false);
-    }
-  }
-
-  // Attach to Promise.prototype for ChainablePromiseElement unwrapping
-  for (const [name, fn] of Object.entries(elementCommands)) {
-    if (typeof (Promise.prototype as any)[name] !== "function") {
-      (Promise.prototype as any)[name] = async function (this: Promise<any>, ...args: any[]) {
-        const el = await this;
-        return await fn.call(el, ...args);
-      };
-    }
-  }
-}

package/src/step/runner/collection.ts

@@ -1,73 +0,0 @@
-import { MultiElementMatcher } from "../types.js";
-import { executeMultiMatcher } from "../matchers.js";
-import { SingleElementRunner } from "./single.js";
-
-type CollectionAssertion = {
-  matcher: MultiElementMatcher;
-  args: any[];
-};
-
-export class MultiElementRunner implements PromiseLike<void> {
-  private _selector: string;
-  private _assertions: CollectionAssertion[] = [];
-
-  constructor(selector: string) {
-    this._selector = selector;
-  }
-
-  // --- Collection Assertions ---
-
-  should(matcher: MultiElementMatcher, ...args: any[]): this {
-    this._assertions.push({ matcher, args });
-    return this;
-  }
-
-  // --- Item Navigation ---
-
-  eq(index: number): SingleElementRunner {
-    const indexedSelector = `(${this._selector})[${index + 1}]`;
-    return new SingleElementRunner(indexedSelector);
-  }
-
-  first(): SingleElementRunner {
-    return this.eq(0);
-  }
-
-  last(): SingleElementRunner {
-    const indexedSelector = `(${this._selector})[last()]`;
-    return new SingleElementRunner(indexedSelector);
-  }
-
-  // --- Iteration Callback ---
-
-  async each(
-    callback: (el: SingleElementRunner, index: number) => Promise<void>
-  ): Promise<void> {
-    const elements = await $$(this._selector);
-    const count = await (elements as any).length;
-    for (let i = 0; i < count; i++) {
-      const runner = this.eq(i);
-      await callback(runner, i);
-    }
-  }
-
-  // --- Execution when awaited ---
-
-  async then<TResult1 = void, TResult2 = never>(
-    onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-  ): Promise<TResult1 | TResult2> {
-    try {
-      for (const assert of this._assertions) {
-        await executeMultiMatcher(this._selector, assert.matcher, assert.args);
-      }
-      const res = (onfulfilled ? await onfulfilled() : undefined) as TResult1;
-      return res;
-    } catch (err) {
-      if (onrejected) {
-        return onrejected(err);
-      }
-      throw err;
-    }
-  }
-}