refactor(evidence): extract TypeScript lifecycle (#32)

backend/test/workspaces/evidence/preprocessing.test.ts

@@ -0,0 +1,161 @@
+import { expect, test, vi } from "vitest";
+import {
+  continueEvidencePreprocessing,
+  preprocessEvidence,
+  type EvidenceJobState,
+  type EvidencePreprocessingDependencies,
+} from "../../../src/workspaces/evidence/preprocessing.js";
+import type { WorkspaceDescriptor } from "../../../src/workspaces/schema.js";
+
+type EvidenceConfig = NonNullable<WorkspaceDescriptor["evidence"]>;
+
+const filesystemEvidence = {
+  source: { type: "filesystem", uri: "research/evidence" },
+} as EvidenceConfig;
+
+const privateHttpEvidence = {
+  source: {
+    type: "http",
+    uris: ["http://127.0.0.1/private.md"],
+    authentication: "none",
+    connect_timeout_ms: 1000,
+    read_timeout_ms: 2000,
+    max_bytes: 100,
+    max_redirects: 0,
+    allow_private_hosts: true,
+    max_cache_bytes: 100,
+  },
+} as EvidenceConfig;
+
+function job(overrides: Partial<EvidenceJobState> = {}): EvidenceJobState {
+  return {
+    runId: "a".repeat(32),
+    childRuns: {},
+    completedStages: [],
+    ...overrides,
+  };
+}
+
+function dependencies(payload: Record<string, unknown> = {}): EvidencePreprocessingDependencies & {
+  runStage: ReturnType<typeof vi.fn>;
+  persistJob: ReturnType<typeof vi.fn>;
+  semanticPreflight: ReturnType<typeof vi.fn>;
+} {
+  return {
+    runStage: vi.fn(async () => payload),
+    persistJob: vi.fn(),
+    semanticPreflight: vi.fn(async () => ({ ok: true as const })),
+    requireRunId(value) {
+      if (typeof value !== "string" || !/^[0-9a-f]{32}$/.test(value)) {
+        throw new Error("child run id is invalid");
+      }
+      return value;
+    },
+    numberRecord(value) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+      return Object.fromEntries(
+        Object.entries(value as Record<string, unknown>).map(([key, nested]) => [key, Number(nested)]),
+      );
+    },
+  };
+}
+
+test("owns the standalone Evidence stage argv and mutation order", async () => {
+  const state = job({ childRuns: { evidence: "b".repeat(32) } });
+  const deps = dependencies({ run_id: "c".repeat(32), counts: { added: 2 } });
+
+  const result = await preprocessEvidence(
+    { evidence: filesystemEvidence, job: state, dryRun: false },
+    deps,
+  );
+
+  expect(deps.semanticPreflight).toHaveBeenCalledOnce();
+  expect(deps.runStage).toHaveBeenCalledWith([
+    "preprocess", "evidence", "--resume", "b".repeat(32), "--json", "-c", "/dev/fd/3",
+  ]);
+  expect(deps.persistJob).toHaveBeenCalledOnce();
+  expect(state).toMatchObject({
+    childRuns: { evidence: "c".repeat(32) },
+    completedStages: ["evidence"],
+  });
+  expect(result).toEqual({
+    status: "succeeded",
+    code: "ok",
+    runId: "a".repeat(32),
+    childRuns: { evidence: "c".repeat(32) },
+    completedStages: ["evidence"],
+    counts: { added: 2 },
+  });
+});
+
+test("owns Evidence egress refusal before shared semantic infrastructure", async () => {
+  const deps = dependencies();
+
+  const result = await preprocessEvidence(
+    {
+      evidence: privateHttpEvidence,
+      job: job(),
+      httpPrivateHostAllowlist: ["metadata.internal"],
+    },
+    deps,
+  );
+
+  expect(result).toEqual({ status: "failed", code: "egress_policy_refused" });
+  expect(deps.semanticPreflight).not.toHaveBeenCalled();
+  expect(deps.runStage).not.toHaveBeenCalled();
+  expect(deps.persistJob).not.toHaveBeenCalled();
+});
+
+test("projects aggregate no-Evidence and completed-stage outcomes without rerunning", async () => {
+  const deps = dependencies();
+  const noEvidence = await continueEvidencePreprocessing(
+    {
+      evidence: undefined,
+      job: job({ completedStages: ["dwh", "schema_index"] }),
+      priorCounts: { added: 2 },
+    },
+    deps,
+  );
+  const completed = await continueEvidencePreprocessing(
+    {
+      evidence: filesystemEvidence,
+      job: job({ completedStages: ["dwh", "schema_index", "evidence"] }),
+    },
+    deps,
+  );
+
+  expect(noEvidence).toMatchObject({
+    status: "succeeded",
+    code: "ok",
+    warnings: ["workspace has no Evidence source"],
+    counts: { added: 2 },
+  });
+  expect(completed).toMatchObject({
+    status: "unchanged",
+    code: "ok",
+    completedStages: ["dwh", "schema_index", "evidence"],
+  });
+  expect(deps.runStage).not.toHaveBeenCalled();
+  expect(deps.persistJob).not.toHaveBeenCalled();
+});
+
+test("preserves the narrow standalone projection for an already completed Evidence stage", async () => {
+  const deps = dependencies();
+
+  const result = await preprocessEvidence(
+    {
+      evidence: filesystemEvidence,
+      job: job({ childRuns: { evidence: "b".repeat(32) }, completedStages: ["evidence"] }),
+    },
+    deps,
+  );
+
+  expect(result).toEqual({
+    status: "unchanged",
+    code: "ok",
+    runId: "a".repeat(32),
+    completedStages: ["evidence"],
+  });
+  expect(deps.runStage).not.toHaveBeenCalled();
+  expect(deps.persistJob).not.toHaveBeenCalled();
+});