@indigoai-us/hq-cloud 6.14.50 → 6.15.1

package/src/sync/event-sync.test.ts

@@ -1,594 +0,0 @@
-/**
- * Phase 3 event-sync tests (US-017/US-018/US-019).
- *
- * - resolveEventSync: exact-email gate semantics + env-override precedence.
- * - subscribeSyncReceive: request shape, response validation, failure surface.
- * - sqsClientFromAwsSdk: command mapping + abort-signal forwarding.
- * - createRefreshingSqsClient: proactive skew refresh, reactive retry-once on
- *   expiry-class errors, non-expiry errors propagate, concurrent refresh
- *   collapse.
- * - startEventSync: happy-path handle wiring (self-echo filter, publish leg),
- *   poll-only degradation on subscribe/tenant failure.
- */
-
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  resolveEventSync,
-  subscribeSyncReceive,
-  sqsClientFromAwsSdk,
-  createRefreshingSqsClient,
-  startEventSync,
-  type SubscribeSyncResponse,
-} from "./event-sync.js";
-import type { SqsClientLike, PushReceiverContext } from "./push-receiver.js";
-import type { PushEvent } from "./push-event.js";
-
-function subscribeResponse(
-  overrides: Partial<SubscribeSyncResponse["credentials"]> = {},
-  queueUrl = "https://sqs.us-east-1.amazonaws.com/000000000000/sync-push-prs_t-dev1",
-): SubscribeSyncResponse {
-  return {
-    queueUrl,
-    region: "us-east-1",
-    credentials: {
-      accessKeyId: "AKIA-1",
-      secretAccessKey: "sec-1",
-      sessionToken: "tok-1",
-      expiration: "2026-06-10T13:00:00.000Z",
-      ...overrides,
-    },
-  };
-}
-
-// ─── resolveEventSync (US-019) ──────────────────────────────────────────────
-
-describe("resolveEventSync — local disable only", () => {
-  it.each(["0", "false", "no", "off"])(
-    "override %j keeps the event path dormant",
-    (override) => expect(resolveEventSync(override)).toBe(false),
-  );
-
-  it.each([undefined, "", "1", "true", "yes", "on", "indigo"])(
-    "override %j cannot grant authority",
-    (override) => expect(resolveEventSync(override)).toBe(true),
-  );
-});
-
-// ─── subscribeSyncReceive ───────────────────────────────────────────────────
-
-describe("subscribeSyncReceive", () => {
-  it("POSTs deviceId with a Bearer token and parses the response", async () => {
-    const calls: Array<{ url: string; init: Record<string, unknown> }> = [];
-    const resp = subscribeResponse();
-    const result = await subscribeSyncReceive({
-      apiUrl: "https://api.example.com/",
-      authToken: async () => "jwt-123",
-      deviceId: "dev1",
-      fetchImpl: async (url, init) => {
-        calls.push({ url, init: init as unknown as Record<string, unknown> });
-        return { ok: true, status: 200, text: async () => JSON.stringify(resp) };
-      },
-    });
-
-    expect(result).toEqual(resp);
-    expect(calls).toHaveLength(1);
-    expect(calls[0].url).toBe("https://api.example.com/v1/sync/subscribe");
-    const init = calls[0].init as {
-      headers: Record<string, string>;
-      body: string;
-    };
-    expect(init.headers.Authorization).toBe("Bearer jwt-123");
-    expect(JSON.parse(init.body)).toEqual({ deviceId: "dev1" });
-  });
-
-  it("throws with status + body excerpt on non-2xx", async () => {
-    await expect(
-      subscribeSyncReceive({
-        apiUrl: "https://api.example.com",
-        authToken: "jwt",
-        deviceId: "dev1",
-        fetchImpl: async () => ({
-          ok: false,
-          status: 503,
-          text: async () => "subscribe exploded",
-        }),
-      }),
-    ).rejects.toThrow(/503.*subscribe exploded/s);
-  });
-
-  it("rejects a response missing credentials (old server) loudly", async () => {
-    await expect(
-      subscribeSyncReceive({
-        apiUrl: "https://api.example.com",
-        authToken: "jwt",
-        deviceId: "dev1",
-        fetchImpl: async () => ({
-          ok: true,
-          status: 200,
-          text: async () =>
-            JSON.stringify({ queueUrl: "https://q", region: "us-east-1" }),
-        }),
-      }),
-    ).rejects.toThrow(/credentials\.accessKeyId/);
-  });
-});
-
-// ─── sqsClientFromAwsSdk ────────────────────────────────────────────────────
-
-describe("sqsClientFromAwsSdk", () => {
-  it("maps receive/delete onto SDK commands and forwards the abort signal", async () => {
-    const sent: Array<{ input: Record<string, unknown>; opts: unknown }> = [];
-    const fakeSdk = {
-      send: async (cmd: { input: Record<string, unknown> }, opts?: unknown) => {
-        sent.push({ input: cmd.input, opts });
-        return {
-          Messages: [{ Body: "b", ReceiptHandle: "rh", MessageId: "m1" }],
-        };
-      },
-    };
-    const adapted = sqsClientFromAwsSdk(
-      fakeSdk as unknown as Parameters<typeof sqsClientFromAwsSdk>[0],
-    );
-
-    const ac = new AbortController();
-    const out = await adapted.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 5,
-      waitTimeSeconds: 20,
-      signal: ac.signal,
-    });
-    expect(out.messages).toEqual([
-      { Body: "b", ReceiptHandle: "rh", MessageId: "m1" },
-    ]);
-    expect(sent[0].input).toMatchObject({
-      QueueUrl: "https://q",
-      MaxNumberOfMessages: 5,
-      WaitTimeSeconds: 20,
-    });
-    expect(sent[0].opts).toEqual({ abortSignal: ac.signal });
-
-    await adapted.deleteMessage({ queueUrl: "https://q", receiptHandle: "rh" });
-    expect(sent[1].input).toMatchObject({
-      QueueUrl: "https://q",
-      ReceiptHandle: "rh",
-    });
-  });
-
-  it("returns an empty list when the SDK omits Messages", async () => {
-    const adapted = sqsClientFromAwsSdk({
-      send: async () => ({}),
-    } as unknown as Parameters<typeof sqsClientFromAwsSdk>[0]);
-    const out = await adapted.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: new AbortController().signal,
-    });
-    expect(out.messages).toEqual([]);
-  });
-});
-
-// ─── createRefreshingSqsClient ──────────────────────────────────────────────
-
-function expiringError(name: string): Error {
-  const e = new Error(name);
-  e.name = name;
-  return e;
-}
-
-function recordingSqs(): SqsClientLike & { receives: number } {
-  const client = {
-    receives: 0,
-    async receiveMessage() {
-      client.receives += 1;
-      return { messages: [] };
-    },
-    async deleteMessage() {},
-  };
-  return client;
-}
-
-describe("createRefreshingSqsClient", () => {
-  const T0 = Date.parse("2026-06-10T12:00:00.000Z");
-
-  it("uses the initial client while creds are fresh (no refresh)", async () => {
-    const subscribe = vi.fn();
-    const built: SqsClientLike[] = [];
-    const client = createRefreshingSqsClient({
-      initial: subscribeResponse(), // expires 13:00
-      subscribe,
-      buildSqs: () => {
-        const c = recordingSqs();
-        built.push(c);
-        return c;
-      },
-      now: () => T0, // 60 min before expiry — outside the 2-min skew window
-    });
-    await client.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: new AbortController().signal,
-    });
-    expect(subscribe).not.toHaveBeenCalled();
-    expect(built).toHaveLength(1);
-  });
-
-  it("proactively re-vends inside the expiry skew window", async () => {
-    const subscribe = vi
-      .fn()
-      .mockResolvedValue(
-        subscribeResponse({ expiration: "2026-06-10T15:00:00.000Z" }),
-      );
-    const built: SqsClientLike[] = [];
-    const client = createRefreshingSqsClient({
-      initial: subscribeResponse(), // expires 13:00
-      subscribe,
-      buildSqs: () => {
-        const c = recordingSqs();
-        built.push(c);
-        return c;
-      },
-      now: () => Date.parse("2026-06-10T12:59:30.000Z"), // inside 2-min skew
-    });
-    await client.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: new AbortController().signal,
-    });
-    expect(subscribe).toHaveBeenCalledTimes(1);
-    expect(built).toHaveLength(2); // initial + rebuilt
-  });
-
-  it("reactively re-vends ONCE on an expiry-class error, then retries", async () => {
-    const subscribe = vi
-      .fn()
-      .mockResolvedValue(
-        subscribeResponse({ expiration: "2026-06-10T15:00:00.000Z" }),
-      );
-    const failing: SqsClientLike = {
-      async receiveMessage() {
-        throw expiringError("ExpiredTokenException");
-      },
-      async deleteMessage() {},
-    };
-    const fresh = recordingSqs();
-    let builds = 0;
-    const client = createRefreshingSqsClient({
-      initial: subscribeResponse(),
-      subscribe,
-      // First build (construction) returns the always-failing client; the
-      // refresh-triggered rebuild returns the fresh one.
-      buildSqs: () => (builds++ === 0 ? failing : fresh),
-      now: () => T0,
-    });
-    const out = await client.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: new AbortController().signal,
-    });
-    expect(out.messages).toEqual([]);
-    expect(subscribe).toHaveBeenCalledTimes(1);
-    expect(fresh.receives).toBe(1);
-  });
-
-  it("non-expiry errors propagate untouched (receiver backoff owns them)", async () => {
-    const subscribe = vi.fn();
-    const client = createRefreshingSqsClient({
-      initial: subscribeResponse(),
-      subscribe,
-      buildSqs: () => ({
-        async receiveMessage() {
-          throw expiringError("AccessDeniedException");
-        },
-        async deleteMessage() {},
-      }),
-      now: () => T0,
-    });
-    await expect(
-      client.receiveMessage({
-        queueUrl: "https://q",
-        maxMessages: 1,
-        waitTimeSeconds: 1,
-        signal: new AbortController().signal,
-      }),
-    ).rejects.toThrow("AccessDeniedException");
-    expect(subscribe).not.toHaveBeenCalled();
-  });
-
-  it("collapses concurrent refreshes onto one subscribe call", async () => {
-    // Indirection object (not a nullable local) so TS doesn't narrow the
-    // callback assignment from inside the promise executor to `never`.
-    const sub: { resolve?: (r: SubscribeSyncResponse) => void } = {};
-    const subscribe = vi.fn(
-      () =>
-        new Promise<SubscribeSyncResponse>((res) => {
-          sub.resolve = res;
-        }),
-    );
-    const client = createRefreshingSqsClient({
-      initial: subscribeResponse(),
-      subscribe,
-      buildSqs: () => recordingSqs(),
-      now: () => Date.parse("2026-06-10T13:30:00.000Z"), // past expiry
-    });
-    const sig = new AbortController().signal;
-    const p1 = client.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: sig,
-    });
-    const p2 = client.receiveMessage({
-      queueUrl: "https://q",
-      maxMessages: 1,
-      waitTimeSeconds: 1,
-      signal: sig,
-    });
-    // Let both calls hit ensureFresh before resolving the vend.
-    await new Promise((r) => setTimeout(r, 0));
-    sub.resolve?.(subscribeResponse({ expiration: "2026-06-10T15:00:00.000Z" }));
-    await Promise.all([p1, p2]);
-    expect(subscribe).toHaveBeenCalledTimes(1);
-  });
-});
-
-// ─── startEventSync ─────────────────────────────────────────────────────────
-
-function pushEvent(overrides: Partial<PushEvent> = {}): PushEvent {
-  return {
-    relativePath: "companies/indigo/docs/a.md",
-    kind: "upsert",
-    contentHash: `sha256:${"a".repeat(64)}`,
-    mtime: "2026-06-10T12:00:00.000Z",
-    originDeviceId: "peer-device",
-    originTenantId: "prs_tenant",
-    sequenceNumber: 1,
-    eventTimestamp: "2026-06-10T12:00:00.000Z",
-    ...overrides,
-  };
-}
-
-describe("startEventSync", () => {
-  function happyOpts(syncCalls: PushEvent[]) {
-    return {
-      hqRoot: "/tmp/hq",
-      apiUrl: "https://api.example.com",
-      authToken: async () => "jwt",
-      deviceId: "this-device",
-      resolveTenantId: async () => "prs_tenant",
-      syncFn: async (ctx: PushReceiverContext) => {
-        syncCalls.push(ctx.event);
-      },
-      subscribe: async () => subscribeResponse(),
-      buildSqs: () =>
-        ({
-          // Parks the receiver's poll loop, but honors the abort signal (the
-          // SqsClientLike contract) so dispose() doesn't block on the drain
-          // deadline.
-          receiveMessage: ({ signal }: { signal: AbortSignal }) =>
-            new Promise<{ messages: [] }>((resolve) => {
-              signal.addEventListener("abort", () => resolve({ messages: [] }), {
-                once: true,
-              });
-            }),
-          deleteMessage: async () => {},
-        }) as SqsClientLike,
-      log: () => {},
-    };
-  }
-
-  it("brings up publish + receive and self-echo-filters the receiver", async () => {
-    const syncCalls: PushEvent[] = [];
-    const opts = happyOpts(syncCalls);
-
-    // The wrapped syncFn is private to the receiver — exercise the filter
-    // through a receiver-visible seam instead: deliver one own-device and one
-    // peer message through the (fake) queue.
-    const delivered: string[] = [];
-    let deliverNext: ((body: string) => void) | null = null;
-    const queueSqs: SqsClientLike = {
-      receiveMessage: ({ signal }) =>
-        new Promise((resolve) => {
-          signal.addEventListener("abort", () => resolve({ messages: [] }), {
-            once: true,
-          });
-          deliverNext = (body: string) => {
-            deliverNext = null; // consumed — re-armed on the next poll
-            delivered.push(body);
-            resolve({ messages: [{ Body: body, ReceiptHandle: "rh" }] });
-          };
-        }),
-      deleteMessage: async () => {},
-    };
-    const handles = await startEventSync({
-      ...opts,
-      buildSqs: () => queueSqs,
-    });
-    expect(handles).not.toBeNull();
-    expect(handles!.ownDeviceId).toBe("this-device");
-
-    const waitForPoll = () =>
-      vi.waitFor(() => {
-        if (!deliverNext) throw new Error("receiver not polling yet");
-      });
-
-    // Own-device event → filtered out (no syncFn call).
-    await waitForPoll();
-    deliverNext!(JSON.stringify(pushEvent({ originDeviceId: "this-device" })));
-    await vi.waitFor(() => expect(delivered).toHaveLength(1));
-
-    // Peer event → bridged into syncFn.
-    await waitForPoll();
-    deliverNext!(
-      JSON.stringify(
-        pushEvent({ originDeviceId: "peer-device", sequenceNumber: 2 }),
-      ),
-    );
-    await vi.waitFor(() => expect(syncCalls).toHaveLength(1));
-    expect(syncCalls[0].originDeviceId).toBe("peer-device");
-    // The own-device event was delivered but never bridged.
-    expect(syncCalls.every((e) => e.originDeviceId === "peer-device")).toBe(
-      true,
-    );
-
-    // Peer delete tombstone → bridged into syncFn. The runner handles safety by
-    // running a targeted pull; it does not unlink directly from this payload.
-    await waitForPoll();
-    deliverNext!(
-      JSON.stringify({
-        relativePath: "companies/indigo/deleted.md",
-        kind: "delete",
-        originDeviceId: "peer-device",
-        originTenantId: "prs_tenant",
-        sequenceNumber: 3,
-        eventTimestamp: "2026-06-10T12:01:00.000Z",
-      } satisfies PushEvent),
-    );
-    await vi.waitFor(() => expect(syncCalls).toHaveLength(2));
-    expect(syncCalls[1]).toMatchObject({
-      kind: "delete",
-      relativePath: "companies/indigo/deleted.md",
-    });
-
-    await handles!.dispose();
-  });
-
-  it("R-F18: disables receive metrics when subscribe omits CloudWatch credentials", async () => {
-    const oldMetricEnv = {
-      region: process.env.HQ_SYNC_CLOUDWATCH_REGION,
-      accessKeyId: process.env.HQ_SYNC_CLOUDWATCH_ACCESS_KEY_ID,
-      secretAccessKey: process.env.HQ_SYNC_CLOUDWATCH_SECRET_ACCESS_KEY,
-      sessionToken: process.env.HQ_SYNC_CLOUDWATCH_SESSION_TOKEN,
-    };
-    delete process.env.HQ_SYNC_CLOUDWATCH_REGION;
-    delete process.env.HQ_SYNC_CLOUDWATCH_ACCESS_KEY_ID;
-    delete process.env.HQ_SYNC_CLOUDWATCH_SECRET_ACCESS_KEY;
-    delete process.env.HQ_SYNC_CLOUDWATCH_SESSION_TOKEN;
-
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    const syncCalls: PushEvent[] = [];
-    let deliverNext: ((body: string) => void) | null = null;
-    const queueSqs: SqsClientLike = {
-      receiveMessage: ({ signal }) =>
-        new Promise((resolve) => {
-          signal.addEventListener("abort", () => resolve({ messages: [] }), {
-            once: true,
-          });
-          deliverNext = (body: string) => {
-            deliverNext = null;
-            resolve({ messages: [{ Body: body, ReceiptHandle: "rh" }] });
-          };
-        }),
-      deleteMessage: async () => {},
-    };
-
-    let handles: Awaited<ReturnType<typeof startEventSync>> = null;
-    try {
-      handles = await startEventSync({
-        ...happyOpts(syncCalls),
-        buildSqs: () => queueSqs,
-      });
-      expect(handles).not.toBeNull();
-
-      await vi.waitFor(() => {
-        if (!deliverNext) throw new Error("receiver not polling yet");
-      });
-      deliverNext!(
-        JSON.stringify(pushEvent({ originDeviceId: "peer-device" })),
-      );
-      await vi.waitFor(() => expect(syncCalls).toHaveLength(1));
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(consoleSpy).not.toHaveBeenCalled();
-    } finally {
-      await handles?.dispose();
-      consoleSpy.mockRestore();
-      if (oldMetricEnv.region === undefined) {
-        delete process.env.HQ_SYNC_CLOUDWATCH_REGION;
-      } else {
-        process.env.HQ_SYNC_CLOUDWATCH_REGION = oldMetricEnv.region;
-      }
-      if (oldMetricEnv.accessKeyId === undefined) {
-        delete process.env.HQ_SYNC_CLOUDWATCH_ACCESS_KEY_ID;
-      } else {
-        process.env.HQ_SYNC_CLOUDWATCH_ACCESS_KEY_ID = oldMetricEnv.accessKeyId;
-      }
-      if (oldMetricEnv.secretAccessKey === undefined) {
-        delete process.env.HQ_SYNC_CLOUDWATCH_SECRET_ACCESS_KEY;
-      } else {
-        process.env.HQ_SYNC_CLOUDWATCH_SECRET_ACCESS_KEY =
-          oldMetricEnv.secretAccessKey;
-      }
-      if (oldMetricEnv.sessionToken === undefined) {
-        delete process.env.HQ_SYNC_CLOUDWATCH_SESSION_TOKEN;
-      } else {
-        process.env.HQ_SYNC_CLOUDWATCH_SESSION_TOKEN =
-          oldMetricEnv.sessionToken;
-      }
-    }
-  });
-
-  it("does not create live handles when authenticated legacy inventory fails", async () => {
-    const logged: string[] = [];
-    const handles = await startEventSync({
-      ...happyOpts([]),
-      subscribe: async () => {
-        throw new Error("subscribe 503");
-      },
-      log: (m) => logged.push(m),
-    });
-    expect(handles).toBeNull();
-    expect(logged.join("\n")).toContain("poll-only");
-    expect(logged.join("\n")).toContain("subscribe 503");
-  });
-
-  it("does not create live handles when identity resolution fails", async () => {
-    const logged: string[] = [];
-    const handles = await startEventSync({
-      ...happyOpts([]),
-      resolveTenantId: async () => {
-        throw new Error("no canonical person entity for this account");
-      },
-      log: (m) => logged.push(m),
-    });
-    expect(handles).toBeNull();
-    expect(logged.join("\n")).toContain("no canonical person entity");
-  });
-
-  it("publishBatch ships one event per changed path AFTER being invoked (publish leg)", async () => {
-    const published: PushEvent[] = [];
-    const fakeTransport = {
-      connected: true,
-      start: async () => {},
-      dispose: async () => {},
-      publish: async (e: PushEvent) => {
-        published.push(e);
-      },
-    };
-    const handles = await startEventSync({
-      ...happyOpts([]),
-      transport: fakeTransport as never,
-      now: () => 1765372800000,
-    });
-    expect(handles).not.toBeNull();
-
-    // NOTE: paths must exist for content hashing — use this test file itself.
-    const abs = new URL(import.meta.url).pathname;
-    handles!.publishBatch({ paths: new Map([[abs, "docs/self.ts"]]) });
-    await vi.waitFor(() => expect(published).toHaveLength(1));
-    const ev = published[0];
-    expect(ev.relativePath).toBe("docs/self.ts");
-    expect(ev.kind).toBe("upsert");
-    expect(ev.originDeviceId).toBe("this-device");
-    expect(ev.originTenantId).toBe("prs_tenant");
-    // Wall-clock sequence numbers (restart-safe monotonicity).
-    expect(ev.sequenceNumber).toBe(1765372800000);
-    expect(ev.contentHash).toMatch(/^sha256:[0-9a-f]{64}$/);
-
-    await handles!.dispose();
-  });
-});