rea/src/application/javascript/ElectronObservationService.test.ts

import { expect, it } from "vitest";

import { classifyBrowserCompleteness } from "../../domain/browserCompleteness.js";
import {
  AnalysisCancelledError,
  AnalysisOutputError,
} from "../../domain/analysisErrorCore.js";
import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
import { parseEvidence } from "../../domain/evidence.js";
import {
  electronPageInspectionSchema,
  electronTargetListSchema,
  inspectElectronPageInputSchema,
} from "../../domain/javascript/electronObservation.js";
import { err } from "../../domain/result.js";
import type { ElectronObservationPort } from "./ElectronObservationPort.js";
import {
  inspectElectronPage,
  listElectronTargets,
} from "./ElectronObservationService.js";

const identity = { id: "electron-fixture", name: "Fixture", version: "1" };
const input = inspectElectronPageInputSchema.parse({
  cdp_endpoint: "http://127.0.0.1:9222",
  target_id: "electron-page",
  observation_ms: 0,
});
const inspection = electronPageInspectionSchema.parse({
  browser: {
    product: "Electron",
    protocol_version: "1.3",
    revision: "fixture",
    user_agent: "Electron fixture",
    js_version: "V8 fixture",
  },
  target: {
    target_id: "electron-page",
    type: "page",
    title: "Fixture",
    file_path: "/app/index.html",
    attached: false,
  },
  capture_window: {
    started_at: "2026-01-01T00:00:00.000Z",
    ended_at: "2026-01-01T00:00:00.000Z",
    observation_ms: 0,
  },
  completeness: classifyBrowserCompleteness({
    policyFilteredSections: new Set(),
    attachLimitedSections: new Set(),
    truncatedSections: new Set(),
    unavailableSections: new Set(),
    excluded: [],
    droppedEvents: {
      scripts: 0,
      network_requests: 0,
      console_events: 0,
      websocket_connections: 0,
      websocket_frames: 0,
      webmcp_tools: 0,
      timeline_events: 0,
    },
  }),
  frames: [],
  dom: { total_nodes: 0, nodes: [] },
  scripts: { total: 0, items: [] },
  resources: [],
  workers: [],
  limitations: [],
});

it("converts a retained raw Electron inspection into partial Evidence", async () => {
  const failure = new AnalysisCancelledError("inspect_electron_page", {
    partialObservation: inspection,
  });
  const provider: ElectronObservationPort = {
    identity: () => identity,
    listTargets: async () =>
      err(new AnalysisCancelledError("list_electron_targets")),
    inspectPage: async () => err(failure),
  };
  const result = await inspectElectronPage(provider, input);
  expect(result.ok).toBe(false);
  if (!result.ok) {
    expect(result.error).toBe(failure);
    expect(parseEvidence(result.error.partialObservation)).toMatchObject({
      operation: "inspect_electron_page",
      normalized_result: inspection,
    });
  }
});

it("converts a raw inspection retained by provider cleanup failure", async () => {
  const failure = new ProviderCleanupError(
    "rea-cdp-electron",
    ["electron-page"],
    { reason: "target detach failed" },
    { operation: "inspect_electron_page", partialObservation: inspection },
  );
  const provider: ElectronObservationPort = {
    identity: () => identity,
    listTargets: async () =>
      err(new AnalysisCancelledError("list_electron_targets")),
    inspectPage: async () => err(failure),
  };
  const result = await inspectElectronPage(provider, input);
  expect(result.ok).toBe(false);
  if (!result.ok) {
    expect(result.error).toBe(failure);
    expect(result.error.cleanupIncomplete).toBe(true);
    expect(parseEvidence(result.error.partialObservation)).toMatchObject({
      operation: "inspect_electron_page",
      normalized_result: inspection,
    });
  }
});

it("returns a typed output error for malformed Electron target output after abort", async () => {
  const controller = new AbortController();
  const malformed = {
    browser: {
      product: "Electron",
      protocol_version: "1.3",
      revision: "fixture",
      user_agent: "Electron fixture",
      js_version: "V8 fixture",
    },
    targets: [],
    excluded: { unsupported_url: 0, non_page: 0 },
    limitations: [() => undefined],
  } as unknown as ReturnType<typeof electronTargetListSchema.parse>;
  const provider: ElectronObservationPort = {
    identity: () => identity,
    listTargets: async () => {
      controller.abort();
      return { ok: true, value: malformed };
    },
    inspectPage: async () =>
      err(new AnalysisCancelledError("inspect_electron_page")),
  };
  const result = await listElectronTargets(
    provider,
    {
      cdp_endpoint: "http://127.0.0.1:9222",
    },
    { signal: controller.signal },
  );
  expect(result.ok).toBe(false);
  if (!result.ok) expect(result.error).toBeInstanceOf(AnalysisOutputError);
});