feat(FN-4222): complete Step 3 — finalize service

Fusion-Task-Id: FN-4222
Fusion-Task-Lineage: 7de6b18c-36d5-49e8-bbd7-084707e88d6a

packages/engine/src/__tests__/experiment-finalize-service.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ExperimentSession, ExperimentSessionRecord } from "@fusion/core";
+import { ExperimentFinalizeService, __activeFinalizeLocksForTesting } from "../experiment/finalize-service.js";
+import {
+  ExperimentFinalizeBranchExistsError,
+  ExperimentFinalizeCherryPickConflictError,
+  ExperimentFinalizeNoKeptRunsError,
+  ExperimentFinalizeStateError,
+} from "../experiment/finalize-types.js";
+
+function createSession(overrides: Partial<ExperimentSession> = {}): ExperimentSession {
+  return {
+    id: "EXP-1",
+    name: "Experiment",
+    status: "active",
+    metric: { name: "score", direction: "maximize" },
+    currentSegment: 1,
+    keptRunIds: ["r1", "r2"],
+    tags: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function runRecord(id: string, seq: number, status: "keep" | "discard" = "keep", commit?: string): ExperimentSessionRecord {
+  return {
+    id,
+    sessionId: "EXP-1",
+    segment: 1,
+    seq,
+    type: "run",
+    payload: { status, commit, primaryMetric: 1, secondaryMetrics: [] },
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+describe("ExperimentFinalizeService", () => {
+  const records = [runRecord("r1", 1, "keep", "c1"), runRecord("r2", 2, "keep", "c2"), runRecord("r3", 3, "discard")];
+  let session: ExperimentSession;
+  let store: any;
+  let git: any;
+
+  beforeEach(() => {
+    __activeFinalizeLocksForTesting.clear();
+    session = createSession();
+    store = {
+      getSession: vi.fn(() => session),
+      listRecords: vi.fn(() => records),
+      updateSession: vi.fn((_id, patch) => {
+        session = { ...session, ...patch };
+        return session;
+      }),
+      appendRecord: vi.fn(() => ({ id: "fin-1" })),
+    };
+    git = {
+      currentBranch: vi.fn(async () => "main"),
+      head: vi.fn(async () => "head-sha"),
+      mergeBase: vi.fn(async () => "merge-base"),
+      branchExists: vi.fn(async () => false),
+      createBranch: vi.fn(async () => undefined),
+      checkout: vi.fn(async () => undefined),
+      cherryPick: vi.fn(async () => undefined),
+      deleteBranch: vi.fn(async () => undefined),
+    };
+  });
+
+  it("finalizes happy path and appends finalize record", async () => {
+    const service = new ExperimentFinalizeService({ store, git });
+
+    const result = await service.finalize({ sessionId: "EXP-1" });
+
+    expect(result.branches).toHaveLength(1);
+    expect(store.updateSession).toHaveBeenNthCalledWith(1, "EXP-1", { status: "finalizing" });
+    expect(store.updateSession).toHaveBeenLastCalledWith("EXP-1", { status: "finalized" });
+    expect(store.appendRecord).toHaveBeenCalledWith(
+      "EXP-1",
+      expect.objectContaining({ type: "finalize", payload: expect.objectContaining({ keptRunIds: ["r1", "r2"], discardedRunIds: ["r3"] }) }),
+    );
+  });
+
+  it("previewPlan is read-only", async () => {
+    const service = new ExperimentFinalizeService({ store, git });
+
+    const plan = await service.previewPlan({ sessionId: "EXP-1" });
+
+    expect(plan.sessionId).toBe("EXP-1");
+    expect(store.updateSession).not.toHaveBeenCalled();
+    expect(git.createBranch).not.toHaveBeenCalled();
+  });
+
+  it("throws no-kept-runs and keeps session active", async () => {
+    session = createSession({ keptRunIds: [] });
+    const service = new ExperimentFinalizeService({ store, git });
+
+    await expect(service.finalize({ sessionId: "EXP-1" })).rejects.toBeInstanceOf(ExperimentFinalizeNoKeptRunsError);
+    expect(store.updateSession).not.toHaveBeenCalled();
+  });
+
+  it("rejects concurrent finalization with lock", async () => {
+    __activeFinalizeLocksForTesting.add("EXP-1");
+    const service = new ExperimentFinalizeService({ store, git });
+
+    await expect(service.finalize({ sessionId: "EXP-1" })).rejects.toBeInstanceOf(ExperimentFinalizeStateError);
+  });
+
+  it("rolls back when branch already exists", async () => {
+    git.branchExists = vi.fn(async () => true);
+    const service = new ExperimentFinalizeService({ store, git });
+
+    await expect(service.finalize({ sessionId: "EXP-1" })).rejects.toBeInstanceOf(ExperimentFinalizeBranchExistsError);
+    expect(git.deleteBranch).not.toHaveBeenCalled();
+    expect(git.checkout).toHaveBeenCalledWith("main");
+    expect(session.status).toBe("finalizing");
+  });
+
+  it("rolls back branch on cherry-pick conflict", async () => {
+    git.cherryPick = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new ExperimentFinalizeCherryPickConflictError("conflict", { groupId: "segment:1", commit: "c2", stderr: "boom" }));
+
+    const service = new ExperimentFinalizeService({ store, git });
+
+    await expect(service.finalize({ sessionId: "EXP-1" })).rejects.toBeInstanceOf(ExperimentFinalizeCherryPickConflictError);
+    expect(git.deleteBranch).toHaveBeenCalledWith(expect.any(String), { force: true });
+    expect(git.checkout).toHaveBeenCalledWith("main");
+  });
+
+  it("restores detached HEAD by sha", async () => {
+    git.currentBranch = vi.fn(async () => null);
+    git.head = vi.fn(async () => "detached-sha");
+    const service = new ExperimentFinalizeService({ store, git });
+
+    await service.finalize({ sessionId: "EXP-1" });
+
+    expect(git.checkout).toHaveBeenCalledWith("detached-sha");
+  });
+
+  it.each([
+    [new ExperimentFinalizeStateError("x"), "state_error"],
+    [new ExperimentFinalizeNoKeptRunsError("x"), "no_kept_runs"],
+    [new ExperimentFinalizeBranchExistsError("x"), "branch_exists"],
+    [new ExperimentFinalizeCherryPickConflictError("x", { groupId: "g", commit: "c", stderr: "e" }), "cherry_pick_conflict"],
+  ])("error code literal %s", (error: any, expectedCode: string) => {
+    expect(error.code).toBe(expectedCode);
+  });
+});