@indigoai-us/hq-cloud 6.3.0 → 6.3.2

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

@@ -0,0 +1,533 @@
+/**
+ * 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 {
+  EVENT_SYNC_ROLLOUT_EMAILS,
+  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";
+
+const ENROLLED = "hassaan@getindigo.ai";
+
+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 — exact-email rollout gate", () => {
+  it("enrolls exactly the allowlisted address (case-insensitive, trimmed)", () => {
+    expect(EVENT_SYNC_ROLLOUT_EMAILS.has(ENROLLED)).toBe(true);
+    expect(resolveEventSync(ENROLLED, undefined)).toBe(true);
+    expect(resolveEventSync("HASSAAN@GetIndigo.AI", undefined)).toBe(true);
+    expect(resolveEventSync(`  ${ENROLLED}  `, undefined)).toBe(true);
+  });
+
+  it("never matches look-alikes — exact full address, not suffix/superset", () => {
+    expect(resolveEventSync("xhassaan@getindigo.ai", undefined)).toBe(false);
+    expect(resolveEventSync("hassaan@getindigo.ai.evil.com", undefined)).toBe(
+      false,
+    );
+    expect(resolveEventSync("hassaan@evil-getindigo.ai", undefined)).toBe(
+      false,
+    );
+    expect(resolveEventSync("corey@getindigo.ai", undefined)).toBe(false);
+    expect(resolveEventSync(undefined, undefined)).toBe(false);
+    expect(resolveEventSync("", undefined)).toBe(false);
+  });
+
+  it.each(["1", "true", "yes", "on", " ON "])(
+    "override %j forces ON for unenrolled accounts",
+    (o) => {
+      expect(resolveEventSync("nobody@example.com", o)).toBe(true);
+      expect(resolveEventSync(undefined, o)).toBe(true);
+    },
+  );
+
+  it.each(["0", "false", "no", "off"])(
+    "override %j forces OFF even for the enrolled account",
+    (o) => {
+      expect(resolveEventSync(ENROLLED, o)).toBe(false);
+    },
+  );
+
+  it("unset/blank/garbage override falls through to the email check", () => {
+    expect(resolveEventSync(ENROLLED, undefined)).toBe(true);
+    expect(resolveEventSync(ENROLLED, "")).toBe(true);
+    expect(resolveEventSync(ENROLLED, "maybe")).toBe(true);
+    expect(resolveEventSync("nobody@example.com", "maybe")).toBe(false);
+  });
+});
+
+// ─── 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",
+    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,
+    );
+
+    await handles!.dispose();
+  });
+
+  it("returns null (poll-only) when subscribe fails — never throws", 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("returns null (poll-only) when tenant 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.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();
+  });
+});