// 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(); status = "wait"; closed = false; constructor(private readonly broker?: { subscriber: RedisClientDouble }) { super(); } async publish(channel: string, message: string): Promise { 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 { 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; quit: () => Promise }; 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 { 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); }); });