@indigoai-us/hq-cloud 6.15.82 → 6.15.83

package/dist/bin/sync-runner.test.js

@@ -4067,6 +4067,238 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
     });
 });
 describe("runRunnerWithLoop — event-push wiring", () => {
+    it("parallel coordinator activates every event surface after a partial completed full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        const previousFullReconcileMs = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "60000";
+        const watcher = makeWatcherStub();
+        const receiver = {
+            connected: false,
+            start: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const scheduler = {
+            signal: vi.fn(),
+            checkHighWater: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const sleep = makeSteppableSleep();
+        let now = 0;
+        let triggerShutdown = () => { };
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn(() => receiver);
+        const startRealtimeScheduler = vi.fn().mockResolvedValue(scheduler);
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome(PARTIAL_SYNC_EXIT));
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            getIdTokenClaims: () => null,
+            getAccessToken: async () => "jwt-test",
+            monotonicNow: () => now,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).toHaveBeenCalledTimes(1);
+            expect(createReceiver).toHaveBeenCalledTimes(1);
+            expect(receiver.start).toHaveBeenCalledTimes(1);
+            expect(startRealtimeScheduler).toHaveBeenCalledTimes(1);
+            expect(startEventSync).toHaveBeenCalledTimes(1);
+            // A partial RunnerPassOutcome is a completed legacy-equivalent pass, so
+            // its completion must restart the configured full-reconcile cadence.
+            now = 1;
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expect(runPass).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+            if (previousFullReconcileMs === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = previousFullReconcileMs;
+        }
+    });
+    it("parallel coordinator activates event surfaces and advances cadence after a numeric-zero full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        const previousFullReconcileMs = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "60000";
+        const watcher = makeWatcherStub();
+        const receiver = {
+            connected: false,
+            start: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const scheduler = {
+            signal: vi.fn(),
+            checkHighWater: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const sleep = makeSteppableSleep();
+        let now = 0;
+        let triggerShutdown = () => { };
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn(() => receiver);
+        const startRealtimeScheduler = vi.fn().mockResolvedValue(scheduler);
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            getIdTokenClaims: () => null,
+            getAccessToken: async () => "jwt-test",
+            monotonicNow: () => now,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).toHaveBeenCalledTimes(1);
+            expect(createReceiver).toHaveBeenCalledTimes(1);
+            expect(receiver.start).toHaveBeenCalledTimes(1);
+            expect(startRealtimeScheduler).toHaveBeenCalledTimes(1);
+            expect(startEventSync).toHaveBeenCalledTimes(1);
+            // The accepted numeric success seam must advance cadence, preventing an
+            // immediate second full reconcile before the configured interval.
+            now = 1;
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expect(runPass).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+            if (previousFullReconcileMs === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = previousFullReconcileMs;
+        }
+    });
+    it("parallel coordinator keeps event surfaces off for an auth-required full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        const watcher = makeWatcherStub();
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn();
+        const startRealtimeScheduler = vi.fn();
+        const startEventSync = vi.fn();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(AUTH_REQUIRED_PASS_EXIT),
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).not.toHaveBeenCalled();
+            expect(createReceiver).not.toHaveBeenCalled();
+            expect(startRealtimeScheduler).not.toHaveBeenCalled();
+            expect(startEventSync).not.toHaveBeenCalled();
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+        }
+    });
+    it("parallel coordinator keeps event surfaces off when no RunnerPassOutcome completed", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        const watcher = makeWatcherStub();
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn();
+        const startRealtimeScheduler = vi.fn();
+        const startEventSync = vi.fn();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            // A bare nonzero status represents a chore that did not produce the
+            // post-repair runner outcome needed to prove completion.
+            runPass: vi.fn().mockResolvedValue(PARTIAL_SYNC_EXIT),
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).not.toHaveBeenCalled();
+            expect(createReceiver).not.toHaveBeenCalled();
+            expect(startRealtimeScheduler).not.toHaveBeenCalled();
+            expect(startEventSync).not.toHaveBeenCalled();
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+        }
+    });
     it("keeps a healthy watcher through repeated poll cycles and the periodic full reconcile", async () => {
         const sleep = makeSteppableSleep();
         const watchers = [];