miravo 0.4.0 → 0.6.0

package/src/lib/admin-platform-stream.test.ts

@@ -0,0 +1,434 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import type { EventLog } from "@miravo/core";
+import * as adminPlatformRoutes from "./admin-platform-routes.ts";
+import { handleApplyStream, handleCleanupStream } from "./admin-platform-stream.ts";
+import * as leApply from "./le/le-apply.ts";
+import * as leCleanup from "./le/le-cleanup.ts";
+import { LEClient } from "./le/le-client.ts";
+import type { LEDeviceHub } from "./le/le-devicehub.ts";
+import type { LEDigitalTwins } from "./le/le-digital-twins.ts";
+import type { LEEnvironment } from "./le/le-environments.ts";
+import * as leEnvironments from "./le/le-environments.ts";
+import type { ApplyPlan, PlanEntry } from "./le/le-plan.ts";
+import type { PlatformOperationRecord } from "./le/le-platform-operations.ts";
+import * as leOperations from "./le/le-platform-operations.ts";
+
+type ApplyContext = {
+  readonly req: {
+    readonly environmentId: string;
+    readonly template?: string;
+    readonly model?: string;
+    readonly area?: string;
+    readonly line?: string;
+    readonly instance?: string;
+    readonly ifUnmanaged?: "fail" | "skip";
+    readonly scope?: readonly string[];
+  };
+  readonly env: LEEnvironment;
+  readonly templateId: string;
+  readonly hub: LEDeviceHub;
+  readonly dt: LEDigitalTwins;
+  readonly desired: {
+    readonly devices: readonly unknown[];
+    readonly models: readonly unknown[];
+    readonly instances: readonly unknown[];
+  };
+};
+
+type TrackerSummary = {
+  readonly successCount: number;
+  readonly failedCount: number;
+  readonly blockedCount: number;
+  readonly progressCount: number;
+  readonly error?: string | undefined;
+};
+
+type ParsedSSEEvent = {
+  readonly event: string;
+  readonly data: Record<string, unknown>;
+};
+
+const APPLY_PLAN_ATTEMPTS = [
+  createPlan("le-host", "miravo-host", [
+    { action: "create", resourceType: "device", name: "dev-1" },
+    { action: "create", resourceType: "device", name: "dev-2" },
+  ]),
+  createPlan("le-host", "miravo-host", [
+    { action: "create", resourceType: "device", name: "dev-2" },
+  ]),
+] as const;
+
+const CLEANUP_PLAN_ATTEMPTS = [
+  createPlan("le-host", undefined, [
+    { action: "delete", resourceType: "device", name: "dev-1" },
+    { action: "delete", resourceType: "device", name: "dev-2" },
+  ]),
+  createPlan("le-host", undefined, [{ action: "delete", resourceType: "device", name: "dev-2" }]),
+] as const;
+
+afterEach(() => {
+  mock.restore();
+});
+
+describe("admin-platform-stream retry accounting", () => {
+  test("apply complete persists cumulative counts across retries", async () => {
+    let applyBuildCallCount = 0;
+    let applyExecuteCallCount = 0;
+    const appendedOperations: Array<PlatformOperationRecord & TrackerSummary> = [];
+
+    using resolveApplyContextSpy = spyOn(
+      adminPlatformRoutes,
+      "resolveApplyContext",
+    ).mockResolvedValue({
+      req: {
+        environmentId: "env-1",
+        template: "smart-factory",
+        ifUnmanaged: "fail",
+        scope: [],
+      },
+      env: {
+        id: "env-1",
+        platformId: leEnvironments.DEFAULT_PLATFORM_ID,
+        label: "Detroit",
+        hostname: "le-host",
+        apiToken: "token",
+        sourceHostname: "miravo-host",
+      },
+      templateId: "smart-factory",
+      hub: {} as unknown as LEDeviceHub,
+      dt: {} as unknown as LEDigitalTwins,
+      desired: { devices: [], models: [], instances: [] },
+    } satisfies ApplyContext);
+    using buildApplyPlanSpy = spyOn(leApply, "buildApplyPlan").mockImplementation(async () => {
+      const plan = latestAttemptPlan(APPLY_PLAN_ATTEMPTS, applyBuildCallCount);
+      applyBuildCallCount++;
+      return { plan, snapshot: {} as never };
+    });
+    using executePlanSpy = spyOn(leApply, "executePlan").mockImplementation(
+      async (
+        _hub,
+        _dt,
+        plan,
+        _desired,
+        opts: { onResourceComplete?: ((progress: leApply.ResourceProgress) => void) | undefined },
+      ) => {
+        applyExecuteCallCount++;
+        if (applyExecuteCallCount === 1) {
+          opts.onResourceComplete?.({
+            phase: "device",
+            resourceType: "device",
+            name: "dev-1",
+            action: "create",
+            status: "success",
+            index: 1,
+            of: 2,
+          });
+          opts.onResourceComplete?.({
+            phase: "device",
+            resourceType: "device",
+            name: "dev-2",
+            action: "create",
+            status: "failed",
+            error: "transient failure",
+            index: 2,
+            of: 2,
+          });
+          return {
+            plan,
+            applied: 1,
+            failed: 1,
+            failedEntries: [],
+            error: "transient failure",
+          };
+        }
+
+        opts.onResourceComplete?.({
+          phase: "device",
+          resourceType: "device",
+          name: "dev-2",
+          action: "create",
+          status: "success",
+          index: 1,
+          of: 1,
+        });
+        return {
+          plan,
+          applied: 1,
+          failed: 0,
+          failedEntries: [],
+        };
+      },
+    );
+    using createTrackerSpy = spyOn(
+      leOperations,
+      "createPlatformOperationTracker",
+    ).mockImplementation(() => {
+      let progressCount = 0;
+      return {
+        onResourceComplete() {
+          progressCount++;
+        },
+        finalize(input) {
+          return buildOperationRecord(input, progressCount);
+        },
+      };
+    });
+    using appendOperationSpy = spyOn(leOperations, "appendPlatformOperation").mockImplementation(
+      async (record) => {
+        appendedOperations.push(record as PlatformOperationRecord & TrackerSummary);
+      },
+    );
+    using sleepSpy = spyOn(Bun, "sleep").mockResolvedValue(undefined);
+
+    const pushedEvents: unknown[] = [];
+    const eventLog = {
+      pushExternal(event: unknown) {
+        pushedEvents.push(event);
+      },
+    } as unknown as EventLog;
+
+    // Regression: retry completion must retain successes + failures from earlier attempts.
+    const response = handleApplyStream({}, eventLog);
+    const events = await readSSE(response);
+    const complete = events.find((event) => event.event === "complete");
+
+    expect(resolveApplyContextSpy).toHaveBeenCalledTimes(1);
+    expect(buildApplyPlanSpy).toHaveBeenCalledTimes(2);
+    expect(executePlanSpy).toHaveBeenCalledTimes(2);
+    expect(createTrackerSpy).toHaveBeenCalledTimes(1);
+    expect(appendOperationSpy).toHaveBeenCalledTimes(1);
+    expect(sleepSpy).toHaveBeenCalledTimes(1);
+    expect(complete?.data).toEqual(
+      expect.objectContaining({
+        applied: 2,
+        failed: 1,
+      }),
+    );
+    expect(pushedEvents).toHaveLength(4);
+    expect(pushedEvents.at(-1)).toEqual(
+      expect.objectContaining({
+        type: "platform:operation",
+        operationType: "apply",
+        applied: 2,
+        failed: 1,
+      }),
+    );
+    expect(appendedOperations).toEqual([
+      expect.objectContaining({
+        successCount: 2,
+        failedCount: 1,
+        blockedCount: 0,
+        progressCount: 3,
+      }),
+    ]);
+  });
+
+  test("cleanup complete persists cumulative counts across retries", async () => {
+    let cleanupBuildCallCount = 0;
+    let cleanupExecuteCallCount = 0;
+    const appendedOperations: Array<PlatformOperationRecord & TrackerSummary> = [];
+
+    using getEnvironmentSpy = spyOn(leEnvironments, "getEnvironment").mockResolvedValue({
+      id: "env-1",
+      platformId: leEnvironments.DEFAULT_PLATFORM_ID,
+      label: "Detroit",
+      hostname: "le-host",
+      apiToken: "token",
+      sourceHostname: "miravo-host",
+    });
+    using touchEnvironmentSpy = spyOn(leEnvironments, "touchEnvironment").mockResolvedValue();
+    using checkAuthSpy = spyOn(LEClient.prototype, "checkAuth").mockResolvedValue();
+    using buildCleanupPlanSpy = spyOn(leCleanup, "buildCleanupPlan").mockImplementation(
+      async () => {
+        const plan = latestAttemptPlan(CLEANUP_PLAN_ATTEMPTS, cleanupBuildCallCount);
+        cleanupBuildCallCount++;
+        return { plan, snapshot: {} as never };
+      },
+    );
+    using executeCleanupSpy = spyOn(leCleanup, "executeCleanup").mockImplementation(
+      async (
+        _hub,
+        _dt,
+        planResult,
+        opts: { onResourceComplete?: ((progress: leApply.ResourceProgress) => void) | undefined },
+      ) => {
+        cleanupExecuteCallCount++;
+        if (cleanupExecuteCallCount === 1) {
+          opts.onResourceComplete?.({
+            phase: "device",
+            resourceType: "device",
+            name: "dev-1",
+            action: "delete",
+            status: "success",
+            index: 1,
+            of: 2,
+          });
+          opts.onResourceComplete?.({
+            phase: "device",
+            resourceType: "device",
+            name: "dev-2",
+            action: "delete",
+            status: "failed",
+            error: "transient failure",
+            index: 2,
+            of: 2,
+          });
+          return {
+            plan: planResult.plan,
+            deleted: 1,
+            failed: 1,
+            failedEntries: [],
+            error: "transient failure",
+          };
+        }
+
+        opts.onResourceComplete?.({
+          phase: "device",
+          resourceType: "device",
+          name: "dev-2",
+          action: "delete",
+          status: "success",
+          index: 1,
+          of: 1,
+        });
+        return {
+          plan: planResult.plan,
+          deleted: 1,
+          failed: 0,
+          failedEntries: [],
+        };
+      },
+    );
+    using createTrackerSpy = spyOn(
+      leOperations,
+      "createPlatformOperationTracker",
+    ).mockImplementation(() => {
+      let progressCount = 0;
+      return {
+        onResourceComplete() {
+          progressCount++;
+        },
+        finalize(input) {
+          return buildOperationRecord(input, progressCount);
+        },
+      };
+    });
+    using appendOperationSpy = spyOn(leOperations, "appendPlatformOperation").mockImplementation(
+      async (record) => {
+        appendedOperations.push(record as PlatformOperationRecord & TrackerSummary);
+      },
+    );
+    using sleepSpy = spyOn(Bun, "sleep").mockResolvedValue(undefined);
+
+    const pushedEvents: unknown[] = [];
+    const eventLog = {
+      pushExternal(event: unknown) {
+        pushedEvents.push(event);
+      },
+    } as unknown as EventLog;
+
+    // Regression: cleanup completion must retain deletions + failures from earlier attempts.
+    const response = handleCleanupStream({ environmentId: "env-1", allManaged: true }, eventLog);
+    const events = await readSSE(response);
+    const complete = events.find((event) => event.event === "complete");
+
+    expect(getEnvironmentSpy).toHaveBeenCalledTimes(1);
+    expect(touchEnvironmentSpy).toHaveBeenCalledTimes(1);
+    expect(checkAuthSpy).toHaveBeenCalledTimes(1);
+    expect(buildCleanupPlanSpy).toHaveBeenCalledTimes(2);
+    expect(executeCleanupSpy).toHaveBeenCalledTimes(2);
+    expect(createTrackerSpy).toHaveBeenCalledTimes(1);
+    expect(appendOperationSpy).toHaveBeenCalledTimes(1);
+    expect(sleepSpy).toHaveBeenCalledTimes(1);
+    expect(complete?.data).toEqual(
+      expect.objectContaining({
+        deleted: 2,
+        failed: 1,
+      }),
+    );
+    expect(pushedEvents).toHaveLength(4);
+    expect(pushedEvents.at(-1)).toEqual(
+      expect.objectContaining({
+        type: "platform:operation",
+        operationType: "cleanup",
+        applied: 2,
+        failed: 1,
+      }),
+    );
+    expect(appendedOperations).toEqual([
+      expect.objectContaining({
+        successCount: 2,
+        failedCount: 1,
+        blockedCount: 0,
+        progressCount: 3,
+      }),
+    ]);
+  });
+});
+
+function createPlan(
+  targetHost: string,
+  sourceHostname: string | undefined,
+  entries: readonly Pick<PlanEntry, "action" | "resourceType" | "name">[],
+): ApplyPlan {
+  return {
+    sourceMode: sourceHostname ? "static" : "managed",
+    targetHost,
+    sourceHostname,
+    scope: [],
+    filters: {},
+    entries,
+  };
+}
+
+function latestAttemptPlan<T>(attempts: readonly T[], index: number): T {
+  const plan = attempts[index] ?? attempts.at(-1);
+  if (plan !== undefined) return plan;
+  throw new Error("Expected at least one retry plan.");
+}
+
+function buildOperationRecord(
+  input: Parameters<ReturnType<typeof leOperations.createPlatformOperationTracker>["finalize"]>[0],
+  progressCount: number,
+): PlatformOperationRecord & TrackerSummary {
+  return {
+    schemaVersion: 1,
+    operationId: "op-1",
+    operationType: "apply",
+    status: input.failedCount > 0 ? "partial" : "success",
+    templateId: "smart-factory",
+    environmentId: "env-1",
+    environmentLabel: "Detroit",
+    hostname: "le-host",
+    scope: [],
+    filters: {},
+    successCount: input.successCount,
+    failedCount: input.failedCount,
+    blockedCount: input.blockedCount ?? 0,
+    startedAt: 0,
+    completedAt: 0,
+    durationMs: 0,
+    resourceCounts: {
+      device: { create: 0, update: 0, replace: 0, delete: 0, failed: 0, total: 0 },
+      model: { create: 0, update: 0, replace: 0, delete: 0, failed: 0, total: 0 },
+      instance: { create: 0, update: 0, replace: 0, delete: 0, failed: 0, total: 0 },
+      "param-sync": { create: 0, update: 0, replace: 0, delete: 0, failed: 0, total: 0 },
+    },
+    progressCount,
+    ...(input.error ? { error: input.error } : {}),
+  };
+}
+
+async function readSSE(response: Response): Promise<readonly ParsedSSEEvent[]> {
+  const text = await response.text();
+  return text
+    .trim()
+    .split("\n\n")
+    .filter((chunk) => chunk.length > 0)
+    .map((chunk) => {
+      const lines = chunk.split("\n");
+      const event = lines.find((line) => line.startsWith("event: "))?.slice(7) ?? "";
+      const data = lines.find((line) => line.startsWith("data: "))?.slice(6) ?? "{}";
+      return { event, data: JSON.parse(data) as Record<string, unknown> };
+    });
+}