@sudobility/testomniac_runner 0.0.128

package/src/runner/executor.ts

@@ -0,0 +1,167 @@
+import type { Page } from "puppeteer-core";
+import type { LegacyTestAction } from "@sudobility/testomniac_types";
+import { ACTION_TIMEOUT_MS } from "@sudobility/testomniac_runner_service";
+import pino from "pino";
+
+const logger = pino({ name: "executor" });
+
+interface MappedAction {
+  method: string;
+  selector?: string;
+  args?: unknown[];
+}
+
+export function mapActionToPuppeteer(action: LegacyTestAction): MappedAction {
+  switch (action.action) {
+    case "navigate":
+      return {
+        method: "goto",
+        args: [action.url, { waitUntil: "networkidle0" }],
+      };
+    case "waitForLoad":
+    case "waitForNavigation":
+      return {
+        method: "waitForNavigation",
+        args: [{ waitUntil: "networkidle0", timeout: ACTION_TIMEOUT_MS }],
+      };
+    case "mouseover":
+      return { method: "hover", selector: action.selector };
+    case "click":
+      return { method: "click", selector: action.selector };
+    case "fill":
+      return {
+        method: "type",
+        selector: action.selector,
+        args: [action.value],
+      };
+    case "select":
+      return {
+        method: "select",
+        selector: action.selector,
+        args: [action.value],
+      };
+    case "check":
+    case "toggle":
+      return { method: "click", selector: action.selector };
+    case "scroll":
+      return {
+        method: "evaluate",
+        args: [
+          `window.scrollBy(0, ${action.direction === "up" ? -(action.amount || 500) : action.amount || 500})`,
+        ],
+      };
+    case "screenshot":
+      return { method: "screenshot", args: [{ path: `${action.label}.jpg` }] };
+    case "assertVisible":
+      return {
+        method: "waitForSelector",
+        selector: action.selector,
+        args: [action.selector, { visible: true, timeout: 5000 }],
+      };
+    case "assertNotVisible":
+      return {
+        method: "waitForSelector",
+        selector: action.selector,
+        args: [action.selector, { hidden: true, timeout: 5000 }],
+      };
+    case "assertUrl":
+      return { method: "assertUrl", args: [action.pattern] };
+    case "assertUrlChanged":
+      return { method: "assertUrlChanged" };
+    case "check_email":
+      return { method: "checkEmail", args: [60000] };
+    case "step":
+      return { method: "noop" };
+    default:
+      return { method: "noop" };
+  }
+}
+
+export async function executeTestInteraction(
+  page: Page,
+  actions: LegacyTestAction[]
+): Promise<{ passed: boolean; error?: string; durationMs: number }> {
+  const start = Date.now();
+  const startUrl = page.url();
+
+  try {
+    for (const action of actions) {
+      const mapped = mapActionToPuppeteer(action);
+
+      switch (mapped.method) {
+        case "goto":
+          await page.goto(mapped.args![0] as string, mapped.args![1] as any);
+          break;
+        case "waitForNavigation":
+          try {
+            await page.waitForNavigation(mapped.args![0] as any);
+          } catch (err) {
+            logger.debug(
+              { err },
+              "navigation timeout during waitForNavigation action"
+            );
+          }
+          break;
+        case "hover": {
+          const el = await page.waitForSelector(mapped.selector!, {
+            timeout: ACTION_TIMEOUT_MS,
+          });
+          if (el) await el.hover();
+          break;
+        }
+        case "click": {
+          const el = await page.waitForSelector(mapped.selector!, {
+            timeout: ACTION_TIMEOUT_MS,
+          });
+          if (el) await el.click();
+          break;
+        }
+        case "type": {
+          const el = await page.waitForSelector(mapped.selector!, {
+            timeout: ACTION_TIMEOUT_MS,
+          });
+          if (el) await el.type(mapped.args![0] as string);
+          break;
+        }
+        case "select":
+          await page.select(mapped.selector!, mapped.args![0] as string);
+          break;
+        case "screenshot":
+          await page.screenshot(mapped.args![0] as any);
+          break;
+        case "waitForSelector":
+          await page.waitForSelector(
+            mapped.args![0] as string,
+            mapped.args![1] as any
+          );
+          break;
+        case "assertUrl": {
+          const pattern = mapped.args![0] as string;
+          if (!page.url().includes(pattern)) {
+            throw new Error(
+              `URL assertion failed: expected "${pattern}" in "${page.url()}"`
+            );
+          }
+          break;
+        }
+        case "assertUrlChanged":
+          if (page.url() === startUrl) {
+            throw new Error(`URL did not change from ${startUrl}`);
+          }
+          break;
+        case "evaluate":
+          await page.evaluate(mapped.args![0] as string);
+          break;
+        case "noop":
+          break;
+      }
+    }
+    return { passed: true, durationMs: Date.now() - start };
+  } catch (err: any) {
+    return {
+      passed: false,
+      error: err.message,
+      durationMs: Date.now() - start,
+    };
+  }
+}

package/src/runner/reporter.ts

@@ -0,0 +1,19 @@
+export interface RunSummary {
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  durationMs: number;
+}
+
+export function computeSummary(
+  results: Array<{ passed: boolean; durationMs: number }>
+): RunSummary {
+  return {
+    total: results.length,
+    passed: results.filter(r => r.passed).length,
+    failed: results.filter(r => !r.passed).length,
+    skipped: 0,
+    durationMs: results.reduce((sum, r) => sum + r.durationMs, 0),
+  };
+}

package/src/runner/worker-pool.ts

@@ -0,0 +1,106 @@
+import type { Browser } from "puppeteer-core";
+import type { LegacyTestAction, Screen } from "@sudobility/testomniac_types";
+import { executeTestInteraction } from "./executor";
+import { getApiClient } from "@sudobility/testomniac_runner_service";
+import pino from "pino";
+
+const logger = pino({ name: "worker-pool" });
+
+interface TestJob {
+  testInteractionId: number;
+  runId: number;
+  runnerId: number;
+  actions: LegacyTestAction[];
+  screen: Screen;
+}
+
+interface TestJobResult {
+  testRunId: number;
+  testInteractionId: number;
+  screen: string;
+  passed: boolean;
+  error?: string;
+  durationMs: number;
+}
+
+export async function runTestJobs(
+  browser: Browser,
+  jobs: TestJob[],
+  concurrency: number = 3
+): Promise<TestJobResult[]> {
+  const results: TestJobResult[] = [];
+  let jobIndex = 0;
+
+  const api = getApiClient();
+
+  async function worker(): Promise<void> {
+    while (jobIndex < jobs.length) {
+      const job = jobs[jobIndex++];
+      if (!job) break;
+
+      const testInteractionRun = await api.createTestInteractionRun({
+        testInteractionId: job.testInteractionId,
+      });
+      const testRun = await api.createTestRun({
+        runnerId: job.runnerId,
+        testInteractionRunId: testInteractionRun.id,
+        parentTestRunId: job.runId,
+        rootTestRunId: job.runId,
+        sizeClass: job.screen.name,
+      });
+
+      const page = await browser.newPage();
+      await page.setViewport({
+        width: job.screen.width,
+        height: job.screen.height,
+      });
+
+      let result = await executeTestInteraction(page, job.actions);
+
+      if (!result.passed) {
+        logger.info(
+          { testRunId: testRun.id, screen: job.screen.name },
+          "retrying failed test"
+        );
+        result = await executeTestInteraction(page, job.actions);
+      }
+
+      if (!result.passed && result.error) {
+        await api.createTestRunFinding({
+          testInteractionRunId: testInteractionRun.id,
+          type: "error",
+          priority: 1,
+          title: `Test failed: ${result.error.slice(0, 80)}`,
+          description: result.error,
+        });
+      }
+
+      await api.completeTestInteractionRun(testInteractionRun.id, {
+        status: result.passed ? "completed" : "failed",
+        durationMs: result.durationMs,
+        errorMessage: result.error,
+      });
+      await api.completeTestRun(testRun.id, {
+        status: result.passed ? "completed" : "failed",
+      });
+
+      results.push({
+        testRunId: testRun.id,
+        testInteractionId: job.testInteractionId,
+        screen: job.screen.name,
+        passed: result.passed,
+        error: result.error,
+        durationMs: result.durationMs,
+      });
+
+      await page.close();
+    }
+  }
+
+  const workers = Array.from(
+    { length: Math.min(concurrency, jobs.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}

package/src/runner-manager.ts

@@ -0,0 +1,163 @@
+import pino from "pino";
+import { getApiClient } from "@sudobility/testomniac_runner_service";
+import { loadConfig } from "./config/index";
+import { runFullScan } from "./orchestrator";
+
+const logger = pino({
+  name: "runner_manager",
+  level: process.env.LOG_LEVEL ?? "info",
+});
+
+type ActiveRun = {
+  runId: number;
+  startedAtMs: number;
+};
+
+export class RunnerManager {
+  private readonly processInstanceId = crypto.randomUUID();
+  private readonly activeRuns = new Map<number, ActiveRun>();
+  private tickInFlight = false;
+
+  constructor(
+    private readonly pollIntervalMs: number,
+    private readonly maxConcurrentRunners: number
+  ) {}
+
+  getActiveRunCount(): number {
+    return this.activeRuns.size;
+  }
+
+  async tick(): Promise<void> {
+    if (this.tickInFlight) return;
+
+    this.tickInFlight = true;
+    try {
+      const config = loadConfig();
+      const api = getApiClient(
+        config.apiUrl + "/api/v1/scanner",
+        config.scannerApiKey
+      );
+
+      while (this.activeRuns.size < this.maxConcurrentRunners) {
+        const pendingRun = await api.getPendingTestRun();
+        if (!pendingRun) {
+          logger.debug(
+            {
+              pollIntervalMs: this.pollIntervalMs,
+              activeRuns: this.activeRuns.size,
+              maxConcurrentRunners: this.maxConcurrentRunners,
+            },
+            "runner manager heartbeat — no pending runs"
+          );
+          break;
+        }
+
+        if (this.activeRuns.has(pendingRun.id)) {
+          break;
+        }
+
+        const slotNumber = this.activeRuns.size + 1;
+        const runner = await api.getRunner(pendingRun.runnerId);
+        if (!runner) {
+          logger.error(
+            { runnerId: pendingRun.runnerId, runId: pendingRun.id },
+            "runner not found for pending run"
+          );
+          await api.completeTestRun(pendingRun.id, { status: "failed" });
+          continue;
+        }
+
+        const runnerInstanceId = `${this.processInstanceId}:${slotNumber}`;
+        const runnerInstanceName = `${runner.title} [slot ${slotNumber}]`;
+        const claimed = await api.claimTestRun(
+          pendingRun.id,
+          runnerInstanceId,
+          runnerInstanceName
+        );
+        if (!claimed) {
+          logger.info(
+            { runId: pendingRun.id },
+            "pending run was claimed by another runner before launch"
+          );
+          continue;
+        }
+
+        this.activeRuns.set(pendingRun.id, {
+          runId: pendingRun.id,
+          startedAtMs: Date.now(),
+        });
+
+        logger.info(
+          {
+            runId: pendingRun.id,
+            slotNumber,
+            activeRuns: this.activeRuns.size,
+            maxConcurrentRunners: this.maxConcurrentRunners,
+          },
+          "starting claimed run"
+        );
+
+        void this.runClaimedRun({
+          runnerId: runner.id,
+          runId: pendingRun.id,
+          scanUrl: pendingRun.scanUrl ?? "",
+          sizeClass: pendingRun.sizeClass,
+          runnerName: runner.title,
+          runnerInstanceId,
+          runnerInstanceName,
+          quickScan: pendingRun.quickScan ?? false,
+        });
+      }
+    } finally {
+      this.tickInFlight = false;
+    }
+  }
+
+  private async runClaimedRun(params: {
+    runnerId: number;
+    runId: number;
+    scanUrl: string;
+    sizeClass: string;
+    runnerName: string;
+    runnerInstanceId: string;
+    runnerInstanceName: string;
+    quickScan: boolean;
+  }): Promise<void> {
+    const config = loadConfig();
+    const api = getApiClient(
+      config.apiUrl + "/api/v1/scanner",
+      config.scannerApiKey
+    );
+
+    try {
+      await runFullScan({
+        runnerId: params.runnerId,
+        scanId: params.runId,
+        scanUrl: params.scanUrl,
+        baseUrl: params.scanUrl,
+        sizeClass: params.sizeClass,
+        runnerName: params.runnerName,
+        runnerInstanceId: params.runnerInstanceId,
+        runnerInstanceName: params.runnerInstanceName,
+        quickScan: params.quickScan,
+      });
+
+      logger.info({ runId: params.runId }, "run completed successfully");
+    } catch (error) {
+      logger.error({ err: error, runId: params.runId }, "claimed run failed");
+      try {
+        await api.completeTestRun(params.runId, {
+          status: "failed",
+        });
+      } catch (completeError) {
+        logger.error(
+          { err: completeError, runId: params.runId },
+          "failed to mark claimed run as failed"
+        );
+      }
+    } finally {
+      this.activeRuns.delete(params.runId);
+      void this.tick();
+    }
+  }
+}

package/src/scanner/email-checker.ts

@@ -0,0 +1,106 @@
+import { SignicClient } from "@sudobility/signic_sdk";
+import type { Page } from "puppeteer-core";
+import pino from "pino";
+import {
+  EMAIL_CHECK_TIMEOUT_MS,
+  EMAIL_CHECK_INTERVAL_MS,
+} from "@sudobility/testomniac_runner_service";
+
+const logger = pino({ name: "email-checker" });
+
+export interface EmailCheckResult {
+  received: boolean;
+  otp?: string;
+  link?: string;
+  rawText?: string;
+}
+
+export async function checkEmail(
+  client: SignicClient
+): Promise<EmailCheckResult> {
+  const deadline = Date.now() + EMAIL_CHECK_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    const { emails } = await client.getUnreadEmails(5);
+    if (emails.length > 0) {
+      const full = await client.getEmail(emails[0].id);
+      await client.markAsRead(emails[0].id);
+      const body = full.text || full.html?.join("") || "";
+
+      const otpMatch = body.match(/\b(\d{4,8})\b/);
+      const linkMatch = body.match(
+        /https?:\/\/[^\s"'<>]+(verify|confirm|activate|reset)[^\s"'<>]*/i
+      );
+
+      logger.info(
+        { hasOtp: !!otpMatch, hasLink: !!linkMatch, subject: full.subject },
+        "email received"
+      );
+
+      return {
+        received: true,
+        otp: otpMatch?.[1],
+        link: linkMatch?.[0],
+        rawText: body.slice(0, 500),
+      };
+    }
+    await new Promise(r => setTimeout(r, EMAIL_CHECK_INTERVAL_MS));
+  }
+
+  logger.warn("email check timed out");
+  return { received: false };
+}
+
+export async function actOnEmail(
+  page: Page,
+  result: EmailCheckResult
+): Promise<boolean> {
+  if (!result.received) return false;
+
+  if (result.otp) {
+    const otpSelectors = [
+      'input[name*="code"]',
+      'input[name*="otp"]',
+      'input[name*="verification"]',
+      'input[placeholder*="code"]',
+      'input[type="number"]',
+    ];
+    for (const sel of otpSelectors) {
+      try {
+        const el = await page.waitForSelector(sel, {
+          timeout: 3000,
+          visible: true,
+        });
+        if (el) {
+          await el.type(result.otp);
+          await page.keyboard.press("Enter");
+          try {
+            await page.waitForNavigation({
+              waitUntil: "networkidle0",
+              timeout: 10_000,
+            });
+          } catch (err) {
+            logger.debug(
+              { err },
+              "navigation timeout during email verification"
+            );
+          }
+          return true;
+        }
+      } catch (err) {
+        logger.debug({ err, selector: sel }, "OTP field selector not found");
+        continue;
+      }
+    }
+  }
+
+  if (result.link) {
+    await page.goto(result.link, {
+      waitUntil: "networkidle0",
+      timeout: 15_000,
+    });
+    return true;
+  }
+
+  return false;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "allowSyntheticDefaultImports": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "scripts/**"]
+}