mirror of
https://github.com/morluto/rea.git
synced 2026-11-22 06:25:44 +00:00
436 lines
14 KiB
TypeScript
436 lines
14 KiB
TypeScript
import { createCommandCli } from "../support/cli/commandCli.js";
|
|
import { EventEmitter } from "node:events";
|
|
import { resolve } from "node:path";
|
|
import { expect, it, vi } from "vitest";
|
|
|
|
import type { BrowserScenarioCapturePort } from "../../src/ports/BrowserScenarioCapturePort.js";
|
|
import { createBrowserScenarioEvidence } from "../../src/application/BrowserScenarioEvidence.js";
|
|
import type {
|
|
BrowserScenarioSessionOpener,
|
|
BrowserScenarioSessionPort,
|
|
} from "../../src/browser/BrowserScenarioSessionPort.js";
|
|
import { PlaywrightBrowserScenarioProvider } from "../../src/browser/PlaywrightBrowserScenarioProvider.js";
|
|
import { PlaywrightScenarioSession } from "../../src/browser/PlaywrightScenarioSession.js";
|
|
import { PlaywrightScenarioBrowserCleanupOwner } from "../../src/browser/PlaywrightScenarioBrowser.js";
|
|
import { registerBrowserScenarioCommands } from "../../src/cliBrowserScenarioCommands.js";
|
|
import { sanitizeBrowserUrl } from "../../src/domain/browserObservation.js";
|
|
import {
|
|
browserScenarioSchema,
|
|
type BrowserScenario,
|
|
} from "../../src/domain/browserScenario.js";
|
|
import type { BrowserScenarioAction } from "../../src/domain/browserScenarioValues.js";
|
|
import { browserStepArtifactsSchema } from "../../src/domain/browserScenarioCaptureValues.js";
|
|
import { silentLogger } from "../../src/logger.js";
|
|
import {
|
|
AnalysisCancelledError,
|
|
AnalysisTimeoutError,
|
|
} from "../../src/domain/analysisErrorCore.js";
|
|
import { BrowserObservationError } from "../../src/domain/browserObservationError.js";
|
|
import { parseEvidence } from "../../src/domain/evidence.js";
|
|
import {
|
|
jsonObjectSchema,
|
|
jsonValueSchema,
|
|
} from "../../src/domain/jsonValue.js";
|
|
import { ok } from "../../src/domain/result.js";
|
|
import { phaseGate } from "../support/lifecycleHarness.js";
|
|
import { primaryAnalysisError } from "../../src/domain/analysisErrorBase.js";
|
|
|
|
const state = vi.hoisted(() => ({
|
|
provider: undefined as BrowserScenarioCapturePort | undefined,
|
|
launchPersistentContext: vi.fn(),
|
|
}));
|
|
vi.mock("playwright-core", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("playwright-core")>();
|
|
return {
|
|
...actual,
|
|
chromium: {
|
|
...actual.chromium,
|
|
launchPersistentContext: state.launchPersistentContext,
|
|
},
|
|
};
|
|
});
|
|
vi.mock("../../src/composition/browserScenario.js", () => ({
|
|
createBrowserScenarioProvider: () => state.provider,
|
|
}));
|
|
|
|
const scenario = browserScenarioSchema.parse({
|
|
browser: { mode: "launch", executable_path: resolve("/fixture/chromium") },
|
|
start_url: { url: "https://app.example.test/" },
|
|
actions: [{ step_id: "wait", action: "wait_for_timeout", duration_ms: 1 }],
|
|
storage: {},
|
|
capture: { after_each_step: ["url"], at_end: [], events: [] },
|
|
});
|
|
|
|
// Controlled session failures exercise the real provider and cleanup owner;
|
|
// this fixture opens no browser process or profile directory.
|
|
class RetrySession implements BrowserScenarioSessionPort {
|
|
readonly mode = "launch";
|
|
readonly processOwnership = "provider-owned";
|
|
readonly product = "Fixture Chromium";
|
|
readonly version = "1";
|
|
readonly initialUrl = "https://app.example.test/";
|
|
closeBrowserCalls = 0;
|
|
profileRemovalCalls = 0;
|
|
readonly cleanup = new PlaywrightScenarioBrowserCleanupOwner({
|
|
closeBrowser: async () => {
|
|
this.closeBrowserCalls += 1;
|
|
if (this.closeBrowserCalls <= this.closeFailures)
|
|
throw new Error(`injected close failure ${this.closeBrowserCalls}`);
|
|
},
|
|
removeProfile: async () => {
|
|
expect(this.cleanup.browserClosed).toBe(true);
|
|
this.profileRemovalCalls += 1;
|
|
},
|
|
});
|
|
|
|
get cleanupLease() {
|
|
return this.cleanup.cleanupLease;
|
|
}
|
|
constructor(private readonly closeFailures = 1) {}
|
|
|
|
currentUrl() {
|
|
return this.initialUrl;
|
|
}
|
|
sanitizeUrl(value: string) {
|
|
return sanitizeBrowserUrl(value);
|
|
}
|
|
setStep(_index: number) {}
|
|
nextEventSequence() {
|
|
return 1;
|
|
}
|
|
lastEventSequence() {
|
|
return 0;
|
|
}
|
|
events() {
|
|
return {
|
|
retained: 0,
|
|
dropped: 0,
|
|
items: [],
|
|
omissions: {
|
|
by_kind: [],
|
|
network_transactions: [],
|
|
network_transaction_range: null,
|
|
},
|
|
};
|
|
}
|
|
async perform(_action: BrowserScenarioAction) {}
|
|
async capture(
|
|
requested: ReadonlySet<
|
|
BrowserScenario["capture"]["after_each_step"][number]
|
|
>,
|
|
) {
|
|
const artifact = (
|
|
kind: BrowserScenario["capture"]["after_each_step"][number],
|
|
) =>
|
|
!requested.has(kind)
|
|
? { state: "not_requested" }
|
|
: kind === "url"
|
|
? { state: "captured", value: this.sanitizeUrl(this.initialUrl) }
|
|
: { state: "missing", reason: "fixture unavailable" };
|
|
return browserStepArtifactsSchema.parse({
|
|
screenshot: artifact("screenshot"),
|
|
dom: artifact("dom"),
|
|
accessibility: artifact("accessibility"),
|
|
url: artifact("url"),
|
|
history: artifact("history"),
|
|
storage: artifact("storage"),
|
|
});
|
|
}
|
|
async close() {
|
|
await this.cleanup.close();
|
|
return "terminated-owned-process" as const;
|
|
}
|
|
redactError(error: unknown) {
|
|
return error instanceof Error ? error.message : "fixture failure";
|
|
}
|
|
}
|
|
|
|
const serveScenario = async () => {
|
|
const cli = createCommandCli();
|
|
registerBrowserScenarioCommands(cli, silentLogger, {});
|
|
let stdout = "";
|
|
let exitCode = 0;
|
|
await cli.serve(
|
|
["capture-browser-scenario", JSON.stringify(scenario), "--json"],
|
|
{
|
|
env: {},
|
|
exit: (code) => {
|
|
exitCode = code;
|
|
},
|
|
stdout: (text) => {
|
|
stdout += text;
|
|
},
|
|
},
|
|
);
|
|
return {
|
|
output: jsonObjectSchema.parse(JSON.parse(stdout)),
|
|
exitCode,
|
|
processExitCode: process.exitCode,
|
|
};
|
|
};
|
|
|
|
it.each([false, true])(
|
|
"preserves the initial capture when the one-shot CLI retries close (retry refused: %s)",
|
|
async (retryRefused) => {
|
|
const savedExitCode = process.exitCode;
|
|
const session = new RetrySession(retryRefused ? 2 : 1);
|
|
const provider = new PlaywrightBrowserScenarioProvider(async () => session);
|
|
const close = vi.spyOn(provider, "close");
|
|
state.provider = provider;
|
|
try {
|
|
const result = await serveScenario();
|
|
expect(result.processExitCode).toBe(1);
|
|
expect(result.output).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "execution_failure",
|
|
details: {
|
|
cleanup: "incomplete",
|
|
resources: ["browser_transport", "browser_profile"],
|
|
partial_observation: {
|
|
capture: {
|
|
browser: { cleanup: "incomplete" },
|
|
steps: [{ step_id: "scenario_start" }, { step_id: "wait" }],
|
|
},
|
|
},
|
|
},
|
|
});
|
|
expect(close).toHaveBeenCalledOnce();
|
|
expect(session.closeBrowserCalls).toBe(2);
|
|
expect(session.profileRemovalCalls).toBe(retryRefused ? 0 : 1);
|
|
if (retryRefused) {
|
|
expect(result.output).toMatchObject({
|
|
details: {
|
|
diagnostics: {
|
|
primary_error: {
|
|
details: {
|
|
diagnostics: {
|
|
primary_error: {
|
|
details: { cleanup_reason: "injected close failure 1" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
cleanup_error: {
|
|
details: {
|
|
diagnostics: { reason: "injected close failure 2" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
await provider.close();
|
|
expect(session.closeBrowserCalls).toBe(3);
|
|
expect(session.profileRemovalCalls).toBe(1);
|
|
}
|
|
} finally {
|
|
try {
|
|
await provider.close();
|
|
} finally {
|
|
state.provider = undefined;
|
|
process.exitCode = savedExitCode;
|
|
}
|
|
}
|
|
},
|
|
);
|
|
|
|
it("retries a late Playwright open after cancellation before accepting another capture", async () => {
|
|
const launch = phaseGate<void, EventEmitter>();
|
|
const closing = phaseGate();
|
|
const order: string[] = [];
|
|
let firstCloseAttempts = 0;
|
|
const makeContext = (close = async () => {}) => {
|
|
const page = Object.assign(new EventEmitter(), {
|
|
url: () => "https://app.example.test/",
|
|
goto: async () => undefined,
|
|
waitForTimeout: async () => undefined,
|
|
});
|
|
const browser = { version: () => "Fixture Chromium" };
|
|
return Object.assign(new EventEmitter(), {
|
|
setDefaultTimeout: () => undefined,
|
|
setDefaultNavigationTimeout: () => undefined,
|
|
addCookies: async () => undefined,
|
|
browser: () => browser,
|
|
pages: () => [page],
|
|
close,
|
|
});
|
|
};
|
|
const lateContext = makeContext(async () => {
|
|
firstCloseAttempts += 1;
|
|
if (firstCloseAttempts === 1) {
|
|
await closing.hold();
|
|
throw new Error("injected late browser close failure");
|
|
}
|
|
order.push("prior context closed");
|
|
});
|
|
state.launchPersistentContext
|
|
.mockImplementationOnce(() => launch.hold())
|
|
.mockImplementation(async () => {
|
|
order.push("next launch");
|
|
return makeContext();
|
|
});
|
|
const openSession = vi.fn<BrowserScenarioSessionOpener>((input, options) =>
|
|
PlaywrightScenarioSession.open(input, {}, options),
|
|
);
|
|
const provider = new PlaywrightBrowserScenarioProvider(openSession);
|
|
const cancellation = new AbortController();
|
|
const first = provider.captureScenario(scenario, {
|
|
signal: cancellation.signal,
|
|
});
|
|
try {
|
|
await launch.reached(first, "first browser launch");
|
|
cancellation.abort();
|
|
const cancelled = await first;
|
|
if (cancelled.ok) throw new Error("Expected first capture cancellation");
|
|
expect(cancelled.error.cleanupIncomplete).toBe(true);
|
|
const primary = primaryAnalysisError(cancelled.error);
|
|
expect(primary).toBeInstanceOf(AnalysisCancelledError);
|
|
expect(primary.cause).toBe(cancellation.signal.reason);
|
|
|
|
launch.release(lateContext);
|
|
const next = provider.captureScenario(scenario);
|
|
await closing.reached(next, "late browser close");
|
|
await new Promise<void>((resolve) => setImmediate(resolve));
|
|
expect(openSession).toHaveBeenCalledOnce();
|
|
expect(cancelled.error.cleanupIncomplete).toBe(true);
|
|
closing.release();
|
|
|
|
const retried = await next;
|
|
if (!retried.ok) throw retried.error;
|
|
expect(retried.value.steps).toHaveLength(2);
|
|
expect(firstCloseAttempts).toBe(2);
|
|
expect(openSession).toHaveBeenCalledTimes(2);
|
|
expect(cancelled.error).toMatchObject({
|
|
cleanupIncomplete: false,
|
|
cleanupResources: [],
|
|
});
|
|
expect(order).toEqual(["prior context closed", "next launch"]);
|
|
} finally {
|
|
cancellation.abort();
|
|
launch.release(lateContext);
|
|
closing.release();
|
|
try {
|
|
await provider.close();
|
|
} finally {
|
|
state.launchPersistentContext.mockReset();
|
|
}
|
|
}
|
|
});
|
|
|
|
it("retains completed Evidence when provider shutdown fails after a successful capture", async () => {
|
|
const savedExitCode = process.exitCode;
|
|
const provider = new PlaywrightBrowserScenarioProvider(
|
|
async () => new RetrySession(0),
|
|
);
|
|
const captured = await provider.captureScenario(scenario);
|
|
if (!captured.ok) throw captured.error;
|
|
const evidence = createBrowserScenarioEvidence(
|
|
scenario,
|
|
{ source: jsonValueSchema.parse(captured.value), facts: captured.value },
|
|
provider.identity(),
|
|
);
|
|
const close = vi.fn().mockRejectedValue(
|
|
new BrowserObservationError("capture_browser_scenario", "cleanup_failed", {
|
|
cleanup: {
|
|
reason: "injected shutdown failure",
|
|
resources: ["browser_profile"],
|
|
},
|
|
}),
|
|
);
|
|
state.provider = {
|
|
identity: () => provider.identity(),
|
|
captureScenario: async () => ok(captured.value),
|
|
close,
|
|
};
|
|
try {
|
|
const result = await serveScenario();
|
|
expect(result.processExitCode).toBe(1);
|
|
expect(result.output).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
details: { resources: ["browser_profile"] },
|
|
});
|
|
const details = jsonObjectSchema.parse(result.output.details);
|
|
expect(parseEvidence(details.partial_observation)).toEqual(evidence);
|
|
expect(close).toHaveBeenCalledTimes(1);
|
|
} finally {
|
|
await provider.close();
|
|
state.provider = undefined;
|
|
process.exitCode = savedExitCode;
|
|
}
|
|
});
|
|
|
|
it("preserves cancellation diagnostics while retrying retained cleanup", async () => {
|
|
const savedExitCode = process.exitCode;
|
|
const session = new RetrySession();
|
|
vi.spyOn(session, "capture").mockRejectedValue(
|
|
new AnalysisCancelledError("capture_browser_scenario"),
|
|
);
|
|
const provider = new PlaywrightBrowserScenarioProvider(async () => session);
|
|
state.provider = provider;
|
|
try {
|
|
const result = await serveScenario();
|
|
expect(result.output).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "cancelled",
|
|
details: {
|
|
cleanup: "incomplete",
|
|
diagnostics: {
|
|
primary_error: {
|
|
code: "cleanup_incomplete",
|
|
details: {
|
|
diagnostics: {
|
|
primary_error: { code: "cancelled", category: "cancelled" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
partial_observation: { kind: "browser-scenario-observation" },
|
|
},
|
|
});
|
|
expect(session.closeBrowserCalls).toBe(2);
|
|
expect(session.profileRemovalCalls).toBe(1);
|
|
} finally {
|
|
await provider.close();
|
|
state.provider = undefined;
|
|
process.exitCode = savedExitCode;
|
|
}
|
|
});
|
|
|
|
it("preserves a thrown capture error when provider shutdown also rejects", async () => {
|
|
const savedExitCode = process.exitCode;
|
|
const provider = new PlaywrightBrowserScenarioProvider(
|
|
async () => new RetrySession(0),
|
|
);
|
|
const primary = new AnalysisTimeoutError("capture_browser_scenario", 123);
|
|
const close = vi
|
|
.fn()
|
|
.mockRejectedValue(new Error("secondary shutdown failure"));
|
|
state.provider = {
|
|
identity: () => provider.identity(),
|
|
captureScenario: async () => {
|
|
throw primary;
|
|
},
|
|
close,
|
|
};
|
|
try {
|
|
const result = await serveScenario();
|
|
expect(result.output).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "timeout",
|
|
details: {
|
|
execution_failure: "provider_timeout",
|
|
diagnostics: {
|
|
primary_error: { code: "provider_timeout", category: "timeout" },
|
|
cleanup_error: {
|
|
details: { diagnostics: { reason: "secondary shutdown failure" } },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
expect(close).toHaveBeenCalledTimes(1);
|
|
} finally {
|
|
await provider.close();
|
|
state.provider = undefined;
|
|
process.exitCode = savedExitCode;
|
|
}
|
|
});
|