chore: import upstream snapshot with attribution

2026-07-13 13:32:57 +08:00
commit cd420f9332
4811 changed files with 884702 additions and 0 deletions
@@ -0,0 +1,174 @@
+import { redisTest } from "@internal/testcontainers";
+import { setTimeout as sleep } from "node:timers/promises";
+import { describe, expect, it, vi } from "vitest";
+import {
+  type ChangeRecord,
+  decodeChangeRecord,
+  encodeChangeRecord,
+  RunChangeNotifier,
+} from "~/services/realtime/runChangeNotifier.server";
+
+function toRedisOptions(redisOptions: { host?: string; port?: number; password?: string }) {
+  return {
+    host: redisOptions.host,
+    port: redisOptions.port,
+    password: redisOptions.password,
+    tlsDisabled: true,
+    clusterMode: false,
+  };
+}
+
+// Time for a SUBSCRIBE to register server-side before we publish.
+const SUBSCRIBE_SETTLE_MS = 250;
+
+describe("RunChangeNotifier", () => {
+  redisTest(
+    "delivers a published change to an env subscriber",
+    { timeout: 30_000 },
+    async ({ redisOptions }) => {
+      const notifier = new RunChangeNotifier({ redis: toRedisOptions(redisOptions) });
+      try {
+        const received: ChangeRecord[] = [];
+        const unsubscribe = notifier.subscribeToEnv("env_1", (records) =>
+          received.push(...records)
+        );
+        expect(notifier.activeSubscriptionCount).toBe(1);
+
+        await sleep(SUBSCRIBE_SETTLE_MS);
+        notifier.publish({ runId: "run_1", envId: "env_1", tags: ["a"], batchId: "batch_1" });
+
+        await vi.waitFor(() => expect(received.some((r) => r.runId === "run_1")).toBe(true), {
+          timeout: 5_000,
+          interval: 50,
+        });
+        const got = received.find((r) => r.runId === "run_1")!;
+        expect(got.tags).toEqual(["a"]);
+        expect(got.batchId).toBe("batch_1");
+
+        unsubscribe();
+        // Cleanup is deferred until Redis confirms UNSUBSCRIBE, so the count converges to 0.
+        await vi.waitFor(() => expect(notifier.activeSubscriptionCount).toBe(0), {
+          timeout: 5_000,
+          interval: 50,
+        });
+      } finally {
+        await notifier.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "does not deliver a change for a different env",
+    { timeout: 30_000 },
+    async ({ redisOptions }) => {
+      const notifier = new RunChangeNotifier({ redis: toRedisOptions(redisOptions) });
+      try {
+        const received: ChangeRecord[] = [];
+        notifier.subscribeToEnv("env_a", (records) => received.push(...records));
+
+        await sleep(SUBSCRIBE_SETTLE_MS);
+        notifier.publish({ runId: "run_1", envId: "env_b", tags: [] }); // different env
+        await sleep(500);
+
+        expect(received).toHaveLength(0);
+      } finally {
+        await notifier.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "coalesces a burst of env publishes into far fewer batches than publishes (lossless)",
+    { timeout: 30_000 },
+    async ({ redisOptions }) => {
+      const notifier = new RunChangeNotifier({
+        redis: toRedisOptions(redisOptions),
+        envWakeCoalesceWindowMs: 100,
+      });
+      try {
+        let batches = 0;
+        const runIds = new Set<string>();
+        notifier.subscribeToEnv("env_burst", (records) => {
+          batches++;
+          for (const r of records) runIds.add(r.runId);
+        });
+
+        await sleep(SUBSCRIBE_SETTLE_MS);
+        let pubs = 0;
+        const end = Date.now() + 1_000;
+        while (Date.now() < end) {
+          notifier.publish({ runId: `r${pubs++}`, envId: "env_burst", tags: [] });
+          await sleep(5);
+        }
+        await sleep(300);
+
+        expect(pubs).toBeGreaterThan(100);
+        expect(batches).toBeGreaterThanOrEqual(1);
+        // Leading-edge throttle: far fewer deliveries than publishes...
+        expect(batches).toBeLessThan(pubs / 4);
+        // ...but lossless — the batch accumulates every run that changed in the window.
+        expect(runIds.size).toBeGreaterThan(pubs / 2);
+      } finally {
+        await notifier.quit();
+      }
+    }
+  );
+
+  // Sharded pub/sub (SSUBSCRIBE/SPUBLISH/smessage) wiring — validated end to end on a
+  // single node (Redis 7.2 accepts these and delivers same-node). Multi-shard ROUTING
+  // needs a real cluster (the cluster fixture covers that); this proves the command path.
+  redisTest(
+    "delivers via sharded pub/sub on the env channel",
+    { timeout: 30_000 },
+    async ({ redisOptions }) => {
+      const notifier = new RunChangeNotifier({
+        redis: toRedisOptions(redisOptions),
+        shardedPubSub: true,
+      });
+      try {
+        const received: ChangeRecord[] = [];
+        notifier.subscribeToEnv("env_sharded", (records) => received.push(...records));
+
+        await sleep(SUBSCRIBE_SETTLE_MS);
+        notifier.publish({ runId: "run_1", envId: "env_sharded", tags: ["a"] });
+
+        await vi.waitFor(() => expect(received.some((r) => r.runId === "run_1")).toBe(true), {
+          timeout: 5_000,
+          interval: 50,
+        });
+      } finally {
+        await notifier.quit();
+      }
+    }
+  );
+
+  describe("ChangeRecord codec", () => {
+    it("round-trips a full record (tags with a separator survive)", () => {
+      const encoded = encodeChangeRecord({
+        v: 1,
+        runId: "run_1",
+        envId: "env_1",
+        tags: ["a", "b,c"],
+        batchId: "batch_1",
+      });
+      expect(decodeChangeRecord(encoded)).toMatchObject({
+        v: 1,
+        runId: "run_1",
+        envId: "env_1",
+        tags: ["a", "b,c"],
+        batchId: "batch_1",
+      });
+    });
+
+    it("decodes a bare runId to a partial record (tags undefined)", () => {
+      // A bare/legacy frame: the consumer falls back to hydrate-to-classify.
+      const decoded = decodeChangeRecord("run_3");
+      expect(decoded.runId).toBe("run_3");
+      expect(decoded.tags).toBeUndefined();
+    });
+
+    it("falls back to a bare runId on an unparseable message", () => {
+      expect(decodeChangeRecord("{not json").runId).toBe("{not json");
+    });
+  });
+});