Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,348 @@
// RedisAdapter unit tests use `ioredis-mock` as a stand-in for a real
// Redis server. The mock implements every command exercised here (GET,
// SET with EX/NX, INCR/INCRBY, EXPIRE, MGET, SCAN, ZADD, ZREMRANGEBYSCORE,
// ZCARD, PUBSUB, EVAL/EVALSHA). Integration against a real Redis is
// covered by the manual smoke test recipe in README.md and will be wired
// into CI alongside task #38.
import { EventEmitter } from "node:events";
import RedisMock from "ioredis-mock";
import { afterEach, beforeEach, describe, expect, test } from "vitest";
import { RedisAdapter } from "./redis.js";
type RedisClient = import("ioredis").Redis;
function buildAdapter() {
const adapter = new RedisAdapter({
clientFactory: () => new RedisMock() as unknown as RedisClient,
});
return adapter;
}
class RedisClientDouble extends EventEmitter {
readonly subscribedChannels = new Set<string>();
status = "wait";
closed = false;
constructor(private readonly broker?: { subscriber: RedisClientDouble }) {
super();
}
async publish(channel: string, message: string): Promise<number> {
const subscriber = this.broker?.subscriber;
if (!subscriber || subscriber.closed || !subscriber.subscribedChannels.has(channel)) {
return 0;
}
subscriber.emit("message", channel, message);
return 1;
}
async subscribe(channel: string): Promise<"OK"> {
this.subscribedChannels.add(channel);
return "OK";
}
async unsubscribe(channel: string): Promise<number> {
const removed = this.subscribedChannels.delete(channel);
return removed ? 1 : 0;
}
async quit(): Promise<"OK"> {
this.closed = true;
this.subscribedChannels.clear();
return "OK";
}
disconnect(): void {
this.closed = true;
this.subscribedChannels.clear();
}
}
function buildLifecycleHarness(primaryStatus = "wait") {
const primary = new RedisClientDouble();
const subscriber = new RedisClientDouble();
const publisher = new RedisClientDouble({ subscriber });
primary.status = primaryStatus;
const adapter = new RedisAdapter({
clientFactory: (role) => {
if (role === "primary") return primary as unknown as RedisClient;
if (role === "subscriber") return subscriber as unknown as RedisClient;
return publisher as unknown as RedisClient;
},
});
return { adapter, primary, subscriber };
}
const adapters: RedisAdapter[] = [];
beforeEach(async () => {
// ioredis-mock shares a process-wide keyspace across `new RedisMock()`
// instances; flush before each test so we start with a clean slate.
const flush = new RedisMock() as unknown as { flushall: () => Promise<unknown>; quit: () => Promise<void> };
await flush.flushall();
await flush.quit();
});
afterEach(async () => {
while (adapters.length > 0) {
const adapter = adapters.pop();
if (adapter) {
await adapter.close().catch(() => undefined);
}
}
});
function track(adapter: RedisAdapter): RedisAdapter {
adapters.push(adapter);
return adapter;
}
async function waitForFanout(): Promise<void> {
await new Promise((resolve) => setTimeout(resolve, 0));
}
describe("RedisAdapter — kv operations", () => {
test("set and get round-trip a value", async () => {
const adapter = track(buildAdapter());
await adapter.set("k", "v");
expect(await adapter.get("k")).toBe("v");
});
test("set NX rejects when the key already exists", async () => {
const adapter = track(buildAdapter());
expect(await adapter.set("k", "first", { nx: true })).toBe(true);
expect(await adapter.set("k", "second", { nx: true })).toBe(false);
expect(await adapter.get("k")).toBe("first");
});
test("set with TTL expires the key", async () => {
const adapter = track(buildAdapter());
await adapter.set("k", "v", { ttlSeconds: 1 });
await new Promise((resolve) => setTimeout(resolve, 1_100));
expect(await adapter.get("k")).toBeNull();
});
test("incr creates and increments the counter", async () => {
const adapter = track(buildAdapter());
expect(await adapter.incr("c")).toBe(1);
expect(await adapter.incr("c", 5)).toBe(6);
});
test("expire applies a ttl to an existing key", async () => {
const adapter = track(buildAdapter());
await adapter.set("k", "v");
expect(await adapter.expire("k", 1)).toBe(true);
expect(await adapter.expire("missing", 1)).toBe(false);
});
test("mget returns values in input order", async () => {
const adapter = track(buildAdapter());
await adapter.set("a", "1");
await adapter.set("c", "3");
expect(await adapter.mget(["a", "b", "c"])).toEqual(["1", null, "3"]);
});
test("mget with an empty list short-circuits", async () => {
const adapter = track(buildAdapter());
expect(await adapter.mget([])).toEqual([]);
});
test("del removes the key and returns the count", async () => {
const adapter = track(buildAdapter());
await adapter.set("k", "v");
expect(await adapter.del("k")).toBe(1);
expect(await adapter.del("k")).toBe(0);
});
});
describe("RedisAdapter — scan", () => {
test("yields keys matching the pattern across multiple cursor pages", async () => {
const adapter = track(buildAdapter());
for (let i = 0; i < 25; i += 1) {
await adapter.set(`user:${i}`, String(i));
}
await adapter.set("other:1", "n");
const collected: string[] = [];
for await (const key of adapter.scan("user:*", { count: 5 })) {
collected.push(key);
}
expect(collected.length).toBe(25);
expect(collected.every((key) => key.startsWith("user:"))).toBe(true);
});
});
describe("RedisAdapter — sorted sets", () => {
test("zAdd reports new vs updated members and zCard counts them", async () => {
const adapter = track(buildAdapter());
expect(await adapter.zAdd("k", 1, "a")).toBe(1);
expect(await adapter.zAdd("k", 2, "a")).toBe(0);
expect(await adapter.zAdd("k", 5, "b")).toBe(1);
expect(await adapter.zCard("k")).toBe(2);
});
test("zRemRangeByScore trims the window", async () => {
const adapter = track(buildAdapter());
await adapter.zAdd("k", 1, "a");
await adapter.zAdd("k", 2, "b");
await adapter.zAdd("k", 10, "c");
expect(await adapter.zRemRangeByScore("k", 0, 5)).toBe(2);
expect(await adapter.zCard("k")).toBe(1);
});
});
describe("RedisAdapter — pub/sub", () => {
test("publish delivers to subscribers and unsubscribe stops further delivery", async () => {
const adapter = track(buildAdapter());
const received: string[] = [];
const unsubscribe = await adapter.subscribe("ch", (msg) => {
received.push(msg);
});
await adapter.publish("ch", "hi");
await new Promise((resolve) => setTimeout(resolve, 25));
expect(received).toContain("hi");
await unsubscribe();
await adapter.publish("ch", "ignored");
await new Promise((resolve) => setTimeout(resolve, 25));
expect(received).not.toContain("ignored");
});
test("multiple handlers on a single channel all fire and tear down independently", async () => {
const adapter = track(buildAdapter());
const a: string[] = [];
const b: string[] = [];
const stopA = await adapter.subscribe("ch", (m) => {
a.push(m);
});
await adapter.subscribe("ch", (m) => {
b.push(m);
});
await adapter.publish("ch", "m1");
await new Promise((resolve) => setTimeout(resolve, 25));
expect(a).toEqual(["m1"]);
expect(b).toEqual(["m1"]);
await stopA();
await adapter.publish("ch", "m2");
await new Promise((resolve) => setTimeout(resolve, 25));
expect(a).toEqual(["m1"]);
expect(b).toEqual(["m1", "m2"]);
});
test("handler errors are swallowed so remaining subscribers still receive the message", async () => {
const { adapter } = buildLifecycleHarness();
track(adapter);
const received: string[] = [];
await adapter.subscribe("ch", () => {
throw new Error("subscriber failed");
});
await adapter.subscribe("ch", async () => {
throw new Error("async subscriber failed");
});
await adapter.subscribe("ch", (message) => {
received.push(message);
});
expect(await adapter.publish("ch", "still-delivered")).toBe(1);
await waitForFanout();
expect(received).toEqual(["still-delivered"]);
});
});
describe("RedisAdapter — eval", () => {
test("runs and caches lua scripts", async () => {
const adapter = track(buildAdapter());
const script = "return ARGV[1]";
const result = await adapter.eval(script, [], ["hello"]);
expect(String(result)).toBe("hello");
// Second invocation hits the SHA cache.
const cached = await adapter.eval(script, [], ["world"]);
expect(String(cached)).toBe("world");
});
});
describe("RedisAdapter — lifecycle", () => {
test("close blocks further operations", async () => {
const adapter = buildAdapter();
await adapter.close();
await expect(adapter.get("k")).rejects.toThrow(/closed/);
});
test("ping returns true when the client is healthy", async () => {
const adapter = track(buildAdapter());
expect(await adapter.ping()).toBe(true);
});
test("onReconnect ignores the initial ready event and fires on later ready events", async () => {
const { adapter, primary } = buildLifecycleHarness();
track(adapter);
const reconnects: string[] = [];
adapter.onReconnect(() => {
reconnects.push("reconnected");
});
primary.emit("ready");
await waitForFanout();
expect(reconnects).toEqual([]);
primary.emit("ready");
await waitForFanout();
expect(reconnects).toEqual(["reconnected"]);
});
test("onReconnect treats an already-ready client as connected when registered", async () => {
const { adapter, primary } = buildLifecycleHarness("ready");
track(adapter);
let reconnects = 0;
adapter.onReconnect(() => {
reconnects += 1;
});
primary.emit("ready");
await waitForFanout();
expect(reconnects).toBe(1);
});
test("onReconnect swallows handler errors and continues fanout", async () => {
const { adapter, primary } = buildLifecycleHarness("ready");
track(adapter);
const calls: string[] = [];
adapter.onReconnect(() => {
calls.push("bad");
throw new Error("reconnect handler failed");
});
adapter.onReconnect(async () => {
calls.push("async-bad");
throw new Error("async reconnect handler failed");
});
adapter.onReconnect(() => {
calls.push("good");
});
primary.emit("ready");
await waitForFanout();
expect(calls).toEqual(["bad", "async-bad", "good"]);
});
test("close prevents later subscriber events and reconnect events from fanning out", async () => {
const { adapter, primary, subscriber } = buildLifecycleHarness("ready");
const received: string[] = [];
let reconnects = 0;
await adapter.subscribe("ch", (message) => {
received.push(message);
});
adapter.onReconnect(() => {
reconnects += 1;
});
await adapter.close();
subscriber.emit("message", "ch", "ignored");
primary.emit("ready");
await waitForFanout();
expect(received).toEqual([]);
expect(reconnects).toBe(0);
});
});