miravo 0.1.4 → 0.2.1

package/src/lib/shutdown.test.ts

@@ -11,9 +11,52 @@ import {
   lockLogger,
   logger,
   mqttLog,
+  opcuaLog,
   unlockLogger,
 } from "../logger.ts";
-import { installShutdownHandlers } from "./shutdown.ts";
+import { createShutdownController } from "./shutdown.ts";
+
+const noopReporter = { log() {} };
+
+function configureSummaryLogger(
+  options: { plain?: boolean; logFormat?: "pretty" | "json" } = {},
+): void {
+  unlockLogger();
+  configureLogger({
+    plain: options.plain ?? false,
+    logFormat: options.logFormat ?? "pretty",
+  });
+  for (const l of [
+    logger,
+    engineLog,
+    mqttLog,
+    opcuaLog,
+    configLog,
+    lifecycleLog,
+    faultLog,
+    controlLog,
+  ]) {
+    l.level = -999;
+    l.setReporters([noopReporter]);
+  }
+  lockLogger();
+}
+
+function setStdoutIsTTY(value: boolean): () => void {
+  const descriptor = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+  Object.defineProperty(process.stdout, "isTTY", {
+    configurable: true,
+    value,
+  });
+
+  return () => {
+    if (descriptor) {
+      Object.defineProperty(process.stdout, "isTTY", descriptor);
+      return;
+    }
+    delete (process.stdout as { isTTY?: boolean }).isTTY;
+  };
+}
 
 function createMockEngine(): Engine & { stopCalled: boolean; stopReason: string | undefined } {
   const metrics: EngineMetricsSnapshot = {
@@ -23,7 +66,7 @@ function createMockEngine(): Engine & { stopCalled: boolean; stopReason: string
       tickCount: 100,
       simulationTimeSeconds: 100,
       instanceCount: 5,
-      unsEntryCount: 25,
+      memberValueCount: 25,
       quarantinedInstanceCount: 0,
       engineErrorsCount: 0,
       tickOverrunsCount: 0,
@@ -53,31 +96,33 @@ function createMockEngine(): Engine & { stopCalled: boolean; stopReason: string
   return mock;
 }
 
-describe("installShutdownHandlers", () => {
-  let teardown: (() => void) | undefined;
+describe("createShutdownController", () => {
+  const teardowns: Array<() => void> = [];
 
   afterEach(() => {
-    teardown?.();
-    teardown = undefined;
+    while (teardowns.length > 0) {
+      teardowns.pop()?.();
+    }
+    muteAllLoggers();
   });
 
   test("first SIGINT calls engine.stop and exit(0)", async () => {
     const engine = createMockEngine();
     let exitCode: number | undefined;
 
-    teardown = installShutdownHandlers({
-      engine,
+    const controller = createShutdownController({
       seed: 42,
       seedExplicit: true,
       exit: (code) => {
         exitCode = code;
       },
     });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
 
     process.emit("SIGINT");
-
-    // Allow async shutdown to complete
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await controller.waitForShutdownRequest();
+    await controller.runShutdown();
 
     expect(engine.stopCalled).toBe(true);
     expect(engine.stopReason).toBe("user interrupt");
@@ -88,153 +133,236 @@ describe("installShutdownHandlers", () => {
     const engine = createMockEngine();
     const exitCodes: number[] = [];
 
-    // Make stop() slow so we can fire a second signal during shutdown
     (engine as unknown as Record<string, unknown>)["stop"] = () =>
       new Promise((resolve) => setTimeout(resolve, 200));
 
-    teardown = installShutdownHandlers({
-      engine,
+    const controller = createShutdownController({
       seed: 42,
-      seedExplicit: false,
+      seedExplicit: true,
       exit: (code) => {
         exitCodes.push(code);
       },
     });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
 
-    // First signal starts shutdown
     process.emit("SIGINT");
-    // Brief delay to let shuttingDown be set
+    await controller.waitForShutdownRequest();
+    const shutdownPromise = controller.runShutdown();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    // Second signal should force exit
     process.emit("SIGINT");
-
-    await new Promise((resolve) => setTimeout(resolve, 250));
+    await controller.completion;
+    await shutdownPromise;
 
     expect(exitCodes).toContain(1);
   });
 
-  test("engine.stop() throwing still exits 0", async () => {
+  test("shutdown request is inert until the owner runs shutdown", async () => {
     const engine = createMockEngine();
-    let exitCode: number | undefined;
+    let stopCallCount = 0;
 
-    // Make stop() throw
     (engine as unknown as Record<string, unknown>)["stop"] = async () => {
-      throw new Error("adapter disconnect");
+      stopCallCount++;
     };
 
-    teardown = installShutdownHandlers({
-      engine,
+    const controller = createShutdownController({
       seed: 1,
       seedExplicit: true,
-      exit: (code) => {
-        exitCode = code;
-      },
+      exit: () => {},
     });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
 
     process.emit("SIGINT");
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await controller.waitForShutdownRequest();
 
-    expect(exitCode).toBe(0);
+    expect(stopCallCount).toBe(0);
+
+    await controller.runShutdown();
+
+    expect(stopCallCount).toBe(1);
   });
 
-  test("concurrent SIGINT+SIGTERM only runs shutdown once", async () => {
+  test("teardown removes signal handlers", async () => {
     const engine = createMockEngine();
-    let stopCallCount = 0;
-
-    (engine as unknown as Record<string, unknown>)["stop"] = async () => {
-      stopCallCount++;
-    };
 
-    teardown = installShutdownHandlers({
-      engine,
+    const controller = createShutdownController({
       seed: 1,
       seedExplicit: true,
       exit: () => {},
     });
+    controller.setEngine(engine);
+    controller.teardown();
 
-    // Fire both signals nearly simultaneously
     process.emit("SIGINT");
-    process.emit("SIGTERM");
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    // The shuttingDown guard should prevent the second from starting a new shutdown
-    expect(stopCallCount).toBe(1);
+    expect(engine.stopCalled).toBe(false);
   });
 
-  test("teardown removes signal handlers", async () => {
+  test("runs cleanup before summary and exit", async () => {
     const engine = createMockEngine();
+    const steps: string[] = [];
+    configureSummaryLogger({ plain: false, logFormat: "pretty" });
 
-    teardown = installShutdownHandlers({
-      engine,
-      seed: 1,
+    const controller = createShutdownController({
+      seed: 42,
       seedExplicit: true,
-      exit: () => {},
+      writeFinalOutput: async () => {
+        steps.push("summary");
+      },
+      exit: () => {
+        steps.push("exit");
+      },
+    });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
+    controller.addTask("cleanup", "cleanup", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      steps.push("cleanup");
+    });
+    controller.addTask("finalize", "finalize", () => {
+      steps.push("finalize");
     });
 
-    // Remove handlers
-    teardown();
-    teardown = undefined;
-
-    // Fire SIGINT after teardown — our handler should NOT run.
-    // If handlers weren't removed, the mock engine would get stopped.
     process.emit("SIGINT");
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    expect(engine.stopCalled).toBe(false);
+    await controller.waitForShutdownRequest();
+    await controller.runShutdown();
+
+    expect(steps).toEqual(["cleanup", "summary", "finalize", "exit"]);
   });
 
-  test("prints top 5 error contexts in shutdown summary", async () => {
+  test("cleanup failure does not suppress the shutdown summary", async () => {
     const engine = createMockEngine();
     let exitCode: number | undefined;
-    const originalLog = console.log;
-    const calls: string[] = [];
-    console.log = (...args: unknown[]) => {
-      calls.push(args.map((arg) => String(arg)).join(" "));
-    };
+    const renders: string[] = [];
 
-    // Enable writeOutput (plain mode, not suppressed) so the shutdown summary
-    // flows through console.log where we can capture it. Then mute consola
-    // reporters so engineLog/mqttLog don't leak to stdout.
-    unlockLogger();
-    configureLogger({ plain: true });
-    const noopReporter = { log() {} };
-    for (const l of [logger, engineLog, mqttLog, configLog, lifecycleLog, faultLog, controlLog]) {
-      l.level = -999;
-      l.setReporters([noopReporter]);
-    }
-    lockLogger();
+    configureSummaryLogger({ plain: false, logFormat: "pretty" });
+
+    const controller = createShutdownController({
+      seed: 42,
+      seedExplicit: true,
+      writeFinalOutput: async (text) => {
+        renders.push(text);
+      },
+      exit: (code) => {
+        exitCode = code;
+      },
+    });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
+    controller.addTask("cleanup", "cleanup", () => {
+      throw new Error("cleanup failed");
+    });
+
+    process.emit("SIGINT");
+    await controller.waitForShutdownRequest();
+    await controller.runShutdown();
+
+    expect(exitCode).toBe(0);
+    expect(renders).toHaveLength(1);
+    expect(renders[0]?.includes("Shutdown Summary")).toBe(true);
+  });
+
+  test("renders the rounded shutdown box in pretty mode even when stdout is not a TTY", async () => {
+    const engine = createMockEngine();
+    let exitCode: number | undefined;
+    const renders: string[] = [];
+    const restoreTTY = setStdoutIsTTY(false);
+    configureSummaryLogger({ plain: false, logFormat: "pretty" });
 
     try {
-      teardown = installShutdownHandlers({
-        engine,
+      const controller = createShutdownController({
         seed: 42,
         seedExplicit: true,
-        errorContextCounts: new Map([
-          ["mqtt:publish", 9],
-          ["tick-overrun", 7],
-          ["mqtt:backpressure", 5],
-          ["mqtt:reconnect", 3],
-          ['circuit-breaker instance="pump-001"', 2],
-          ["mqtt:client", 1],
-        ]),
+        writeFinalOutput: async (text) => {
+          renders.push(text);
+        },
         exit: (code) => {
           exitCode = code;
         },
       });
+      teardowns.push(controller.teardown);
+      controller.setEngine(engine);
 
       process.emit("SIGINT");
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      await controller.waitForShutdownRequest();
+      await controller.runShutdown();
     } finally {
-      console.log = originalLog;
-      muteAllLoggers();
+      restoreTTY();
     }
 
     expect(exitCode).toBe(0);
-    expect(calls.some((line) => line.includes("Top error contexts:"))).toBe(true);
-    expect(calls.some((line) => line.includes("mqtt:publish"))).toBe(true);
-    expect(calls.some((line) => line.includes("tick-overrun"))).toBe(true);
-    expect(calls.some((line) => line.includes("mqtt:backpressure"))).toBe(true);
-    expect(calls.some((line) => line.includes("mqtt:reconnect"))).toBe(true);
-    expect(calls.some((line) => line.includes('circuit-breaker instance="pump-001"'))).toBe(true);
-    expect(calls.some((line) => line.includes("mqtt:client"))).toBe(false);
+    expect(renders).toHaveLength(1);
+    expect(renders[0]?.includes("Shutdown Summary")).toBe(true);
+    expect(renders[0]?.includes("╭")).toBe(true);
+    expect(renders[0]?.includes("╰")).toBe(true);
+  });
+
+  test("keeps shutdown output plain when --plain is enabled", async () => {
+    const engine = createMockEngine();
+    const renders: string[] = [];
+    configureSummaryLogger({ plain: true, logFormat: "pretty" });
+
+    const controller = createShutdownController({
+      seed: 42,
+      seedExplicit: true,
+      writeFinalOutput: async (text) => {
+        renders.push(text);
+      },
+      exit: () => {},
+    });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
+
+    process.emit("SIGINT");
+    await controller.waitForShutdownRequest();
+    await controller.runShutdown();
+
+    expect(renders).toHaveLength(1);
+    expect(renders[0]?.startsWith("Shutdown Summary\n")).toBe(true);
+    expect(renders[0]?.includes("╭")).toBe(false);
+  });
+
+  test("prints top 5 error contexts in shutdown summary", async () => {
+    const engine = createMockEngine();
+    let exitCode: number | undefined;
+    const renders: string[] = [];
+    configureSummaryLogger({ plain: true, logFormat: "pretty" });
+
+    const controller = createShutdownController({
+      seed: 42,
+      seedExplicit: true,
+      errorContextCounts: new Map([
+        ["mqtt:publish", 9],
+        ["tick-overrun", 7],
+        ["mqtt:backpressure", 5],
+        ["mqtt:reconnect", 3],
+        ['circuit-breaker instance="pump-001"', 2],
+        ["mqtt:client", 1],
+      ]),
+      writeFinalOutput: async (text) => {
+        renders.push(text);
+      },
+      exit: (code) => {
+        exitCode = code;
+      },
+    });
+    teardowns.push(controller.teardown);
+    controller.setEngine(engine);
+
+    process.emit("SIGINT");
+    await controller.waitForShutdownRequest();
+    await controller.runShutdown();
+
+    const output = renders[0] ?? "";
+    expect(exitCode).toBe(0);
+    expect(output.includes("Top errors")).toBe(true);
+    expect(output.includes("mqtt:publish")).toBe(true);
+    expect(output.includes("tick-overrun")).toBe(true);
+    expect(output.includes("mqtt:backpressure")).toBe(true);
+    expect(output.includes("mqtt:reconnect")).toBe(true);
+    expect(output.includes('circuit-breaker instance="pump-001"')).toBe(true);
+    expect(output.includes("mqtt:client")).toBe(false);
   });
 });