fix(testing): scope mock Redis listeners to the client that registered them

The listener registry outlived the spies: `vi.clearAllMocks()` and
`clearRedisMocks` reset call history but left handlers registered, so they
accumulated across tests and a later `emit` could reach handlers belonging to a
client the test under way never created.

Adds `removeAllListeners`, which real clients have, and drops listeners in
`clearRedisMocks` alongside spy history. Where one mock instance stands in for
every client a module constructs, the registry is now emptied per construction —
a real client starts with none, so binding listener lifetime to construction
makes the isolation automatic rather than something each test has to remember.

Covers the mock's event behavior in the testing package, where it lives.

Author: waleedlatif1

apps/sim/lib/core/config/redis.test.ts

@@ -18,13 +18,16 @@ const { mockEnv, MockRedisConstructor, mockLogger } = vi.hoisted(() => ({
 }))
 
 const mockRedisInstance = createMockRedis()
-MockRedisConstructor.mockImplementation(
-  class {
-    constructor() {
-      Object.assign(this, mockRedisInstance)
-    }
-  }
-)
+/** One mock instance stands in for every client the module constructs, so its
+ *  listener registry has to be emptied per construction — a real client starts
+ *  with none, and keeping them would let an `emit` reach handlers registered by
+ *  a client that no longer exists. */
+function newMockClient(this: object) {
+  mockRedisInstance.removeAllListeners()
+  Object.assign(this, mockRedisInstance)
+}
+
+MockRedisConstructor.mockImplementation(newMockClient)
 
 vi.unmock('@/lib/core/config/redis')
 vi.mock('@/lib/core/config/env', () => ({ env: mockEnv }))
@@ -60,13 +63,7 @@ describe('redis config', () => {
     mockRedisInstance.status = 'ready'
     mockEnv.REDIS_URL = 'redis://localhost:6379'
     mockEnv.REDIS_TLS_SERVERNAME = undefined
-    MockRedisConstructor.mockImplementation(
-      class {
-        constructor() {
-          Object.assign(this, mockRedisInstance)
-        }
-      }
-    )
+    MockRedisConstructor.mockImplementation(newMockClient)
   })
 
   afterEach(() => {

packages/testing/src/mocks/redis.mock.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from 'vitest'
+import { clearRedisMocks, createMockRedis } from './redis.mock'
+
+describe('createMockRedis events', () => {
+  it('dispatches an emitted event to its registered listeners', () => {
+    const redis = createMockRedis()
+    const onReady = vi.fn()
+    redis.on('ready', onReady)
+
+    expect(redis.emit('ready')).toBe(true)
+    expect(onReady).toHaveBeenCalledOnce()
+  })
+
+  it('reports no delivery when nothing is listening', () => {
+    expect(createMockRedis().emit('ready')).toBe(false)
+  })
+
+  it('stops delivering to a removed listener', () => {
+    const redis = createMockRedis()
+    const onReady = vi.fn()
+    redis.on('ready', onReady)
+    redis.removeListener('ready', onReady)
+
+    redis.emit('ready')
+    expect(onReady).not.toHaveBeenCalled()
+  })
+
+  it('lets a listener remove itself while the event is dispatching', () => {
+    const redis = createMockRedis()
+    const onReady = vi.fn(() => redis.removeListener('ready', onReady))
+    redis.on('ready', onReady)
+
+    expect(() => redis.emit('ready')).not.toThrow()
+    redis.emit('ready')
+    expect(onReady).toHaveBeenCalledOnce()
+  })
+
+  it('drops every listener on removeAllListeners', () => {
+    const redis = createMockRedis()
+    const onReady = vi.fn()
+    const onError = vi.fn()
+    redis.on('ready', onReady)
+    redis.on('error', onError)
+
+    redis.removeAllListeners()
+
+    redis.emit('ready')
+    redis.emit('error')
+    expect(onReady).not.toHaveBeenCalled()
+    expect(onError).not.toHaveBeenCalled()
+  })
+
+  it('drops only the named event when one is given', () => {
+    const redis = createMockRedis()
+    const onReady = vi.fn()
+    const onError = vi.fn()
+    redis.on('ready', onReady)
+    redis.on('error', onError)
+
+    redis.removeAllListeners('ready')
+
+    redis.emit('ready')
+    redis.emit('error')
+    expect(onReady).not.toHaveBeenCalled()
+    expect(onError).toHaveBeenCalledOnce()
+  })
+
+  it('clears listeners alongside spy history, not just spy history', () => {
+    // Handlers left behind would be invoked by a later emit on behalf of a
+    // client the test under way never created.
+    const redis = createMockRedis()
+    const onReady = vi.fn()
+    redis.on('ready', onReady)
+
+    clearRedisMocks(redis)
+
+    expect(redis.emit('ready')).toBe(false)
+    expect(onReady).not.toHaveBeenCalled()
+  })
+
+  it('keeps listeners scoped to the instance that registered them', () => {
+    const a = createMockRedis()
+    const b = createMockRedis()
+    const onA = vi.fn()
+    a.on('ready', onA)
+
+    b.emit('ready')
+    expect(onA).not.toHaveBeenCalled()
+  })
+})

packages/testing/src/mocks/redis.mock.ts

@@ -62,6 +62,12 @@ export function createMockRedis() {
     removeListener: vi.fn((event: string, listener: (...args: unknown[]) => void) => {
       listeners.get(event)?.delete(listener)
     }),
+    /** Listeners belong to a client, so a caller reusing this instance as a new
+     *  client clears them the way a real one starts empty. */
+    removeAllListeners: vi.fn((event?: string) => {
+      if (event === undefined) listeners.clear()
+      else listeners.delete(event)
+    }),
     /** Drives the lifecycle events a real client emits (`connect`, `ready`, `error`). */
     emit: vi.fn((event: string, ...args: unknown[]) => {
       const registered = listeners.get(event)
@@ -93,8 +99,13 @@ export type MockRedis = ReturnType<typeof createMockRedis>
 
 /**
  * Clears all Redis mock calls.
+ *
+ * Also drops registered listeners: spy history and the listener registry are
+ * separate state, and handlers left behind would be invoked by a later `emit`
+ * on behalf of a client the test under way never created.
  */
 export function clearRedisMocks(redis: MockRedis) {
+  redis.removeAllListeners()
   Object.values(redis).forEach((value) => {
     if (typeof value === 'function' && 'mockClear' in value) {
       value.mockClear()