Track HiveGrid Cloud planning reference
This commit is contained in:
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);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user