@indigoai-us/hq-cloud 5.25.0 → 5.27.0

package/src/sync/logger.test.ts

@@ -0,0 +1,241 @@
+/**
+ * US-011 — unit tests for the pino logger factory + the 3-log diagnostic
+ * chain's CLIENT-side correlated fields.
+ *
+ * The PRD requires three correlated logs sharing the same `sequenceNumber`:
+ *   1. `watcher.emit`    — client push (US-008 PushEventEmitter)   [client]
+ *   2. `push.receive`    — server (hq-pro)                          [server]
+ *   3. `fanout.receive`  — client fanout-receive (US-009 receiver)  [client]
+ *
+ * This package owns the two CLIENT-side links. These tests prove:
+ *   - `createLogger` stamps the `component` tag on every line and respects
+ *     level + injected destination.
+ *   - the watcher emits `event=watcher.emit` carrying `sequenceNumber`.
+ *   - the receiver emits `event=fanout.receive` carrying the SAME
+ *     `sequenceNumber` → an operator can join the two client links (and the
+ *     server `push.receive` line, which carries the same key) end-to-end.
+ */
+
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Writable } from "node:stream";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { createLogger } from "./logger.js";
+import { encodePushEvent, type PushEvent } from "./push-event.js";
+import { NoopPushTransport } from "./push-transport.js";
+import { StaticFlagProvider } from "./feature-flags.js";
+import {
+  SqsPushReceiver,
+  type SqsClientLike,
+  type SqsMessageLike,
+} from "./push-receiver.js";
+import { PushEventEmitter, type TreeChangeBatch } from "../watcher.js";
+
+const TENANT = "tenant-indigo";
+
+// ── Capture stream + JSON line reader ─────────────────────────────────────────
+
+function captureStream(): { stream: Writable; lines: () => Array<Record<string, unknown>> } {
+  const chunks: string[] = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) {
+      chunks.push(
+        typeof chunk === "string" ? chunk : (chunk as Buffer).toString("utf8"),
+      );
+      cb();
+    },
+  });
+  return {
+    stream,
+    lines: () =>
+      chunks
+        .join("")
+        .split("\n")
+        .filter((s) => s.length > 0)
+        .map((s) => JSON.parse(s) as Record<string, unknown>),
+  };
+}
+
+async function until(predicate: () => boolean, timeoutMs = 1000): Promise<void> {
+  const start = Date.now();
+  while (!predicate()) {
+    if (Date.now() - start > timeoutMs) throw new Error("until() timed out");
+    await new Promise((r) => setTimeout(r, 5));
+  }
+}
+
+function makeEvent(overrides: Partial<PushEvent> = {}): PushEvent {
+  return {
+    relativePath: "companies/indigo/notes.md",
+    contentHash:
+      "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    mtime: "2026-05-21T12:34:56.000Z",
+    originDeviceId: "device-A",
+    originTenantId: TENANT,
+    sequenceNumber: 1,
+    eventTimestamp: "2026-05-21T12:34:56.000Z",
+    ...overrides,
+  };
+}
+
+class OneBatchSqs implements SqsClientLike {
+  private batch: SqsMessageLike[] | null;
+  constructor(messages: SqsMessageLike[]) {
+    this.batch = messages;
+  }
+  async receiveMessage(args: {
+    queueUrl: string;
+    maxMessages: number;
+    waitTimeSeconds: number;
+    signal: AbortSignal;
+  }): Promise<{ messages: SqsMessageLike[] }> {
+    if (this.batch) {
+      const b = this.batch;
+      this.batch = null;
+      return { messages: b };
+    }
+    return new Promise((resolve) => {
+      if (args.signal.aborted) return resolve({ messages: [] });
+      const t = setTimeout(() => resolve({ messages: [] }), 5);
+      (t as { unref?: () => void }).unref?.();
+      args.signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve({ messages: [] });
+        },
+        { once: true },
+      );
+    });
+  }
+  async deleteMessage(): Promise<void> {
+    /* no-op */
+  }
+}
+
+// ── createLogger ──────────────────────────────────────────────────────────────
+
+describe("createLogger", () => {
+  it("stamps the `component` tag on every line", () => {
+    const { stream, lines } = captureStream();
+    const log = createLogger({
+      component: "sync-watcher",
+      destination: stream,
+      level: "info",
+    });
+    log.info({ event: "x" }, "hello");
+    log.warn({ event: "y" }, "world");
+    const out = lines();
+    expect(out).toHaveLength(2);
+    expect(out.every((l) => l.component === "sync-watcher")).toBe(true);
+  });
+
+  it("respects the injected level (debug below info is dropped at info)", () => {
+    const { stream, lines } = captureStream();
+    const log = createLogger({
+      component: "c",
+      destination: stream,
+      level: "info",
+    });
+    log.debug({ event: "d" }, "dropped");
+    log.info({ event: "i" }, "kept");
+    const out = lines();
+    expect(out).toHaveLength(1);
+    expect(out[0]!.event).toBe("i");
+  });
+});
+
+// ── 3-log chain: client-side correlated fields share sequenceNumber ───────────
+
+describe("3-log diagnostic chain (client links share sequenceNumber)", () => {
+  let tmp: string | undefined;
+  let receiver: SqsPushReceiver | undefined;
+
+  afterEach(async () => {
+    if (receiver) {
+      await receiver.dispose();
+      receiver = undefined;
+    }
+    if (tmp) {
+      await rm(tmp, { recursive: true, force: true });
+      tmp = undefined;
+    }
+  });
+
+  it("watcher.emit and fanout.receive carry the SAME sequenceNumber", async () => {
+    const SEQ = 4242;
+
+    // ── Link 1: watcher.emit (client push side) ──────────────────────────
+    tmp = await mkdtemp(join(tmpdir(), "us011-logger-"));
+    const absPath = join(tmp, "notes.md");
+    await writeFile(absPath, "hello world", "utf8");
+
+    const watcherCap = captureStream();
+    const watcherLog = createLogger({
+      component: "sync-watcher",
+      destination: watcherCap.stream,
+      level: "info",
+    });
+
+    const emitter = new PushEventEmitter({
+      originTenantId: TENANT,
+      originDeviceId: "device-A",
+      transport: new NoopPushTransport(),
+      flagProvider: new StaticFlagProvider([TENANT]),
+      getSequenceNumber: () => SEQ,
+      logger: watcherLog,
+    });
+
+    const batch: TreeChangeBatch = {
+      paths: new Map([[absPath, "companies/indigo/notes.md"]]),
+    };
+    await emitter.emitForBatch(batch);
+
+    const emitLine = watcherCap
+      .lines()
+      .find((l) => l.event === "watcher.emit");
+    expect(emitLine).toBeDefined();
+    expect(emitLine!.sequenceNumber).toBe(SEQ);
+    expect(emitLine!.component).toBe("sync-watcher");
+
+    // ── Link 3: fanout.receive (client receive side) ─────────────────────
+    const receiverCap = captureStream();
+    const receiverLog = createLogger({
+      component: "sync-receiver",
+      destination: receiverCap.stream,
+      level: "info",
+    });
+    const event = makeEvent({ sequenceNumber: SEQ });
+
+    receiver = new SqsPushReceiver({
+      tenantId: TENANT,
+      queueUrl: "https://sqs.local/q",
+      sqs: new OneBatchSqs([{ Body: encodePushEvent(event), ReceiptHandle: "rh" }]),
+      syncFn: async () => {
+        /* success */
+      },
+      enabled: true,
+      logger: receiverLog,
+      // Inject a no-op metric so no real AWS is touched.
+      publishMetric: async () => {},
+    });
+
+    await receiver.start();
+    await until(() =>
+      receiverCap.lines().some((l) => l.event === "fanout.receive"),
+    );
+
+    const recvLine = receiverCap
+      .lines()
+      .find((l) => l.event === "fanout.receive");
+    expect(recvLine).toBeDefined();
+    expect(recvLine!.sequenceNumber).toBe(SEQ);
+    expect(recvLine!.component).toBe("sync-receiver");
+
+    // ── The join key matches across both client links ────────────────────
+    expect(emitLine!.sequenceNumber).toBe(recvLine!.sequenceNumber);
+  });
+});

package/src/sync/logger.ts

@@ -0,0 +1,79 @@
+/**
+ * Component-tagged logger factory for the hq-cloud sync subsystem
+ * (project event-driven-sync-menubar US-011).
+ *
+ * Every log line emitted from a sync module SHOULD carry a `component` field
+ * so operators can grep / route by subsystem in the aggregated JSON stream.
+ * `createLogger({ component: "sync-watcher" })` is the canonical entry point —
+ * modules call this once at module-load time and use the returned logger for
+ * the lifetime of the process.
+ *
+ * The 3-log diagnostic chain (US-011)
+ * ───────────────────────────────────
+ * Three correlated log lines share a single `sequenceNumber` join key so an
+ * operator can walk one event end-to-end:
+ *   1. `event=watcher.emit`    — client push side (US-008 PushEventEmitter)
+ *   2. `event=push.receive`    — server side (hq-pro; context only here)
+ *   3. `event=fanout.receive`  — client fanout-receive side (US-009 receiver)
+ * The watcher.emit + fanout.receive halves live in this client package; the
+ * push.receive half lives server-side in hq-pro. All three stamp the same
+ * `sequenceNumber` for log-chain correlation.
+ *
+ * Output format: pino's default newline-delimited JSON. No transports, no
+ * pretty-printing — the daemon consumes the raw JSON stream. (Operators who
+ * want pretty output pipe through `pino-pretty` themselves.)
+ *
+ * Destination injection: tests pass a `destination` stream so they can capture
+ * log lines and assert on them. Production callers omit it and pino defaults
+ * to `process.stdout`.
+ *
+ * Adapted from indigoai-us/hq-pro PR #112 (src/sync/logger.ts) into
+ * @indigoai-us/hq-cloud (Path B).
+ */
+
+import {
+  pino,
+  type DestinationStream,
+  type Level,
+  type Logger,
+  type LoggerOptions,
+} from "pino";
+
+export interface CreateLoggerOptions {
+  /**
+   * Component tag stamped on every log line as `"component": <value>`.
+   * Required so daemon / watcher / receiver lines never appear in the stream
+   * untagged.
+   */
+  component: string;
+  /**
+   * Optional pino level. Default: pino's own default (`info`). Set via
+   * `LOG_LEVEL` env var, command-line flag, or test injection.
+   */
+  level?: Level;
+  /**
+   * Optional pino destination. Default: `process.stdout`. Tests inject a
+   * memory stream here to capture lines for assertion.
+   */
+  destination?: DestinationStream;
+}
+
+/**
+ * Build a pino logger pre-bound to a `component` tag.
+ *
+ * Use this — not a bare `pino()` call — so every sync module's log lines carry
+ * the tag uniformly. Adding more bound fields (e.g. `deviceId`, `tenantId`) is
+ * a `logger.child({ ... })` call away.
+ */
+export function createLogger(opts: CreateLoggerOptions): Logger {
+  const { component, level, destination } = opts;
+  const pinoOpts: LoggerOptions = {
+    base: { component },
+    ...(level === undefined ? {} : { level }),
+  };
+  return destination === undefined
+    ? pino(pinoOpts)
+    : pino(pinoOpts, destination);
+}
+
+export type { Logger } from "pino";

package/src/sync/metrics.test.ts

@@ -0,0 +1,380 @@
+/**
+ * US-011 — unit tests for `src/sync/metrics.ts` + the receive-success-path
+ * metric emission wired into {@link SqsPushReceiver}.
+ *
+ * Mirrors the hq-pro PR #112 metrics test:
+ *   - mock the CloudWatchClient via `aws-sdk-client-mock`
+ *   - inject the mocked client via the `_setSyncCloudWatchClient` test seam
+ *   - assert namespace, metric name, unit, dimensions, value
+ *   - assert SDK errors are CAUGHT (the receive loop must never crash on a
+ *     CloudWatch outage)
+ *
+ * Plus the US-011-specific receiver wiring:
+ *   - on the receive-SUCCESS path, the receiver publishes exactly one latency
+ *     datum carrying the event's tenantId + sequenceNumber (mocked publish seam
+ *     — no real AWS)
+ *   - a failing publish seam does NOT crash the receiver loop
+ */
+
+import { Writable } from "node:stream";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mockClient } from "aws-sdk-client-mock";
+import {
+  CloudWatchClient,
+  PutMetricDataCommand,
+} from "@aws-sdk/client-cloudwatch";
+
+import {
+  SYNC_LATENCY_METRIC_NAME,
+  SYNC_METRIC_NAMESPACE,
+  _setSyncCloudWatchClient,
+  publishSyncLatencyMetric,
+  type SyncLatencyMetric,
+} from "./metrics.js";
+import { createLogger } from "./logger.js";
+import { encodePushEvent, type PushEvent } from "./push-event.js";
+import {
+  SqsPushReceiver,
+  type PublishMetricFn,
+  type SqsClientLike,
+  type SqsMessageLike,
+} from "./push-receiver.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeMetric(overrides: Partial<SyncLatencyMetric> = {}): SyncLatencyMetric {
+  return {
+    tenantId: "tenant-A",
+    relativePath: "docs/overview.md",
+    sequenceNumber: 42,
+    latencySeconds: 1.234,
+    timestamp: new Date("2026-05-19T12:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+function captureStream(): { stream: Writable; lines: () => unknown[] } {
+  const chunks: string[] = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) {
+      chunks.push(
+        typeof chunk === "string" ? chunk : (chunk as Buffer).toString("utf8"),
+      );
+      cb();
+    },
+  });
+  return {
+    stream,
+    lines: () =>
+      chunks
+        .join("")
+        .split("\n")
+        .filter((s) => s.length > 0)
+        .map((s) => JSON.parse(s) as unknown),
+  };
+}
+
+const TENANT = "tenant-indigo";
+const QUEUE_URL =
+  "https://sqs.us-east-1.amazonaws.com/123456789012/sync-push-indigo-deviceB";
+
+function makeEvent(overrides: Partial<PushEvent> = {}): PushEvent {
+  return {
+    relativePath: "companies/indigo/notes.md",
+    contentHash:
+      "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    mtime: "2026-05-21T12:34:56.000Z",
+    originDeviceId: "device-A",
+    originTenantId: TENANT,
+    sequenceNumber: 7,
+    eventTimestamp: "2026-05-21T12:34:56.000Z",
+    ...overrides,
+  };
+}
+
+/** Minimal fake SQS that drains one batch then idles until abort. */
+class OneBatchSqs implements SqsClientLike {
+  private batch: SqsMessageLike[] | null;
+  readonly deleted: string[] = [];
+
+  constructor(messages: SqsMessageLike[]) {
+    this.batch = messages;
+  }
+
+  async receiveMessage(args: {
+    queueUrl: string;
+    maxMessages: number;
+    waitTimeSeconds: number;
+    signal: AbortSignal;
+  }): Promise<{ messages: SqsMessageLike[] }> {
+    if (this.batch) {
+      const b = this.batch;
+      this.batch = null;
+      return { messages: b };
+    }
+    return new Promise((resolve) => {
+      if (args.signal.aborted) return resolve({ messages: [] });
+      const t = setTimeout(() => resolve({ messages: [] }), 5);
+      (t as { unref?: () => void }).unref?.();
+      args.signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve({ messages: [] });
+        },
+        { once: true },
+      );
+    });
+  }
+
+  async deleteMessage(args: {
+    queueUrl: string;
+    receiptHandle: string;
+  }): Promise<void> {
+    this.deleted.push(args.receiptHandle);
+  }
+}
+
+/** Wait until `predicate()` is true (polling), or throw after `timeoutMs`. */
+async function until(
+  predicate: () => boolean,
+  timeoutMs = 1000,
+): Promise<void> {
+  const start = Date.now();
+  while (!predicate()) {
+    if (Date.now() - start > timeoutMs) {
+      throw new Error("until() timed out");
+    }
+    await new Promise((r) => setTimeout(r, 5));
+  }
+}
+
+// ── publishSyncLatencyMetric (CloudWatch contract) ───────────────────────────
+
+const cwMock = mockClient(CloudWatchClient);
+
+describe("publishSyncLatencyMetric", () => {
+  beforeEach(() => {
+    cwMock.reset();
+    _setSyncCloudWatchClient(cwMock as unknown as CloudWatchClient);
+  });
+
+  it("sends a single PutMetricData with the documented namespace + metric name", async () => {
+    cwMock.on(PutMetricDataCommand).resolves({});
+
+    await publishSyncLatencyMetric(makeMetric());
+
+    const calls = cwMock.commandCalls(PutMetricDataCommand);
+    expect(calls).toHaveLength(1);
+
+    const input = calls[0]!.args[0].input;
+    expect(input.Namespace).toBe(SYNC_METRIC_NAMESPACE);
+    expect(input.Namespace).toBe("HQPro/Sync");
+    expect(input.MetricData).toHaveLength(1);
+    expect(input.MetricData![0].MetricName).toBe(SYNC_LATENCY_METRIC_NAME);
+    expect(input.MetricData![0].MetricName).toBe(
+      "hq-cloud.sync.p95_latency_seconds",
+    );
+  });
+
+  it("uses Unit=Seconds and stamps the supplied timestamp", async () => {
+    cwMock.on(PutMetricDataCommand).resolves({});
+
+    const ts = new Date("2026-05-19T07:00:00.000Z");
+    await publishSyncLatencyMetric(makeMetric({ timestamp: ts }));
+
+    const datum = cwMock.commandCalls(PutMetricDataCommand)[0]!.args[0].input
+      .MetricData![0];
+    expect(datum.Unit).toBe("Seconds");
+    expect(datum.Timestamp).toEqual(ts);
+  });
+
+  it("publishes the observed latencySeconds value verbatim", async () => {
+    cwMock.on(PutMetricDataCommand).resolves({});
+
+    await publishSyncLatencyMetric(makeMetric({ latencySeconds: 2.71828 }));
+
+    const datum = cwMock.commandCalls(PutMetricDataCommand)[0]!.args[0].input
+      .MetricData![0];
+    expect(datum.Value).toBe(2.71828);
+  });
+
+  it("attaches a `TenantId` dimension carrying the tenantId", async () => {
+    cwMock.on(PutMetricDataCommand).resolves({});
+
+    await publishSyncLatencyMetric(makeMetric({ tenantId: "tenant-prs_xyz" }));
+
+    const datum = cwMock.commandCalls(PutMetricDataCommand)[0]!.args[0].input
+      .MetricData![0];
+    expect(datum.Dimensions).toEqual([
+      { Name: "TenantId", Value: "tenant-prs_xyz" },
+    ]);
+  });
+
+  it("does not throw when the CloudWatch SDK rejects (sync loop must not crash)", async () => {
+    cwMock
+      .on(PutMetricDataCommand)
+      .rejects(new Error("CloudWatch unavailable"));
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    await expect(
+      publishSyncLatencyMetric(makeMetric()),
+    ).resolves.toBeUndefined();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Failed to publish sync latency metric to CloudWatch:",
+      "CloudWatch unavailable",
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it("routes SDK failures through the supplied pino logger when provided", async () => {
+    cwMock.on(PutMetricDataCommand).rejects(new Error("ThrottlingException"));
+    const { stream, lines } = captureStream();
+    const logger = createLogger({
+      component: "metrics-test",
+      destination: stream,
+      level: "debug",
+    });
+
+    await publishSyncLatencyMetric(
+      makeMetric({ sequenceNumber: 99, relativePath: "a.md" }),
+      { logger },
+    );
+
+    const failureLine = (lines() as Array<{ event?: string }>).find(
+      (l) => l.event === "sync.metric.publish_failed",
+    );
+    expect(failureLine).toBeDefined();
+    expect(failureLine).toMatchObject({
+      event: "sync.metric.publish_failed",
+      tenantId: "tenant-A",
+      relativePath: "a.md",
+      sequenceNumber: 99,
+    });
+  });
+
+  it("accepts a per-call client override (does not call the singleton)", async () => {
+    cwMock
+      .on(PutMetricDataCommand)
+      .rejects(new Error("singleton should not be used"));
+
+    const overrideMock = mockClient(CloudWatchClient);
+    overrideMock.on(PutMetricDataCommand).resolves({});
+
+    await publishSyncLatencyMetric(makeMetric(), {
+      client: overrideMock as unknown as CloudWatchClient,
+    });
+
+    expect(overrideMock.commandCalls(PutMetricDataCommand)).toHaveLength(1);
+    expect(cwMock.commandCalls(PutMetricDataCommand)).toHaveLength(0);
+
+    overrideMock.restore();
+  });
+});
+
+// ── Receive-success-path metric emission (US-011 AC: "metric emission unit-
+//    tested on the receive success path") ──────────────────────────────────
+
+describe("SqsPushReceiver metric emission on the receive-success path", () => {
+  let receiver: SqsPushReceiver | undefined;
+
+  afterEach(async () => {
+    if (receiver) {
+      await receiver.dispose();
+      receiver = undefined;
+    }
+  });
+
+  it("publishes exactly one latency datum per processed event (mocked publish, no real AWS)", async () => {
+    const published: SyncLatencyMetric[] = [];
+    const publishMetric: PublishMetricFn = async (m) => {
+      published.push(m);
+    };
+    const event = makeEvent({ sequenceNumber: 7 });
+
+    receiver = new SqsPushReceiver({
+      tenantId: TENANT,
+      queueUrl: QUEUE_URL,
+      sqs: new OneBatchSqs([{ Body: encodePushEvent(event), ReceiptHandle: "rh-7" }]),
+      syncFn: async () => {
+        /* successful pull */
+      },
+      enabled: true,
+      publishMetric,
+      // Fake clock: start measured at T, success at T+1500ms → 1.5s latency.
+      now: (() => {
+        let t = Date.parse(event.eventTimestamp);
+        return () => {
+          const cur = t;
+          t += 1500;
+          return cur;
+        };
+      })(),
+    });
+
+    await receiver.start();
+    await until(() => published.length >= 1);
+
+    expect(published).toHaveLength(1);
+    expect(published[0]).toMatchObject({
+      tenantId: TENANT,
+      relativePath: event.relativePath,
+      sequenceNumber: 7,
+    });
+    expect(published[0]!.latencySeconds).toBeGreaterThanOrEqual(0);
+    expect(Number.isFinite(published[0]!.latencySeconds)).toBe(true);
+  });
+
+  it("does NOT publish a metric when the syncFn throws (failures don't skew p95)", async () => {
+    const published: SyncLatencyMetric[] = [];
+    const event = makeEvent({ sequenceNumber: 8 });
+
+    receiver = new SqsPushReceiver({
+      tenantId: TENANT,
+      queueUrl: QUEUE_URL,
+      sqs: new OneBatchSqs([{ Body: encodePushEvent(event), ReceiptHandle: "rh-8" }]),
+      syncFn: async () => {
+        throw new Error("pull failed");
+      },
+      enabled: true,
+      publishMetric: async (m) => {
+        published.push(m);
+      },
+    });
+
+    await receiver.start();
+    // Give the loop a few ticks to process the message + (not) publish.
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(published).toHaveLength(0);
+    expect(receiver.processedCount).toBe(0);
+  });
+
+  it("a throwing publish seam does not crash the receiver loop", async () => {
+    const event = makeEvent({ sequenceNumber: 9 });
+    let synced = false;
+
+    receiver = new SqsPushReceiver({
+      tenantId: TENANT,
+      queueUrl: QUEUE_URL,
+      sqs: new OneBatchSqs([{ Body: encodePushEvent(event), ReceiptHandle: "rh-9" }]),
+      syncFn: async () => {
+        synced = true;
+      },
+      enabled: true,
+      publishMetric: async () => {
+        throw new Error("metric backend down");
+      },
+    });
+
+    await receiver.start();
+    await until(() => synced);
+
+    // The sync still completed and the receiver is still alive (connected).
+    expect(receiver.processedCount).toBe(1);
+    expect(receiver.connected).toBe(true);
+  });
+});