agent-messenger 2.2.0 → 2.4.0

package/src/platforms/webex/commands/member.test.ts

@@ -1,65 +1,74 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
-import { WebexClient } from '../client'
 import { WebexError } from '../types'
+
+const mockHandleError = mock((err: Error) => {
+  throw err
+})
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: mockHandleError,
+}))
+
+const mockMembers = [
+  {
+    id: 'mem-1',
+    roomId: 'room-1',
+    personId: 'person-1',
+    personEmail: 'alice@example.com',
+    personDisplayName: 'Alice',
+    isModerator: true,
+    created: '2024-01-01T00:00:00.000Z',
+  },
+  {
+    id: 'mem-2',
+    roomId: 'room-1',
+    personId: 'person-2',
+    personEmail: 'bob@example.com',
+    personDisplayName: 'Bob',
+    isModerator: false,
+    created: '2024-01-02T00:00:00.000Z',
+  },
+]
+
+const mockListMemberships = mock(() => Promise.resolve(mockMembers))
+const mockLogin = mock(() => Promise.resolve({ listMemberships: mockListMemberships }))
+
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
+
 import { listAction } from './member'
 
+afterAll(() => {
+  mock.restore()
+})
+
 describe('member commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
-  let consoleErrorSpy: ReturnType<typeof spyOn>
-  let processExitSpy: ReturnType<typeof spyOn>
-  let stderrOutput: string
-  let origStderrWrite: typeof process.stderr.write
-  const mockMembers = [
-    {
-      id: 'mem-1',
-      roomId: 'room-1',
-      personId: 'person-1',
-      personEmail: 'alice@example.com',
-      personDisplayName: 'Alice',
-      isModerator: true,
-      created: '2024-01-01T00:00:00.000Z',
-    },
-    {
-      id: 'mem-2',
-      roomId: 'room-1',
-      personId: 'person-2',
-      personEmail: 'bob@example.com',
-      personDisplayName: 'Bob',
-      isModerator: false,
-      created: '2024-01-02T00:00:00.000Z',
-    },
-  ]
 
   beforeEach(() => {
-    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
-    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-      throw new Error(`process.exit(${_code})`)
+    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
+    mockLogin.mockReset().mockImplementation(() =>
+      Promise.resolve({ listMemberships: mockListMemberships }),
+    )
+    mockHandleError.mockReset().mockImplementation((err: Error) => {
+      throw err
     })
-    stderrOutput = ''
-    origStderrWrite = process.stderr.write
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
-      return true
-    }) as typeof process.stderr.write
-    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
-    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers)
+
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
-    process.stderr.write = origStderrWrite
-    mock.restore()
+    consoleSpy.mockRestore()
   })
 
   test('listAction calls listMemberships with spaceId and outputs mapped members', async () => {
-    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
-      mockMembers,
-    )
-
     await listAction('room-1', {})
 
-    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: undefined })
+    expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: undefined })
     expect(consoleSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
@@ -83,30 +92,28 @@ describe('member commands', () => {
   })
 
   test('listAction passes limit option to listMemberships', async () => {
-    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
-      mockMembers,
-    )
-
     await listAction('room-1', { limit: 25 })
 
-    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: 25 })
+    expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: 25 })
   })
 
   test('listAction handles not-authenticated case', async () => {
-    spyOn(WebexClient.prototype, 'login').mockRejectedValue(
-      new WebexError('No Webex credentials found.', 'no_credentials'),
-    )
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   test('listAction handles API error', async () => {
-    spyOn(WebexClient.prototype, 'listMemberships').mockRejectedValue(new Error('API failure'))
+    mockListMemberships.mockImplementation(async () => {
+      throw new Error('API failure')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('API failure')
 
-    expect(processExitSpy).toHaveBeenCalledWith(1)
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
   })
 })

package/src/platforms/webex/commands/message.test.ts

@@ -1,18 +1,14 @@
-import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { afterAll, afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
 
-import { WebexClient } from '../client'
 import { WebexError } from '../types'
-import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
-let clientSendMessageSpy: ReturnType<typeof spyOn>
-let clientSendDirectMessageSpy: ReturnType<typeof spyOn>
-let clientListMessagesSpy: ReturnType<typeof spyOn>
-let clientGetMessageSpy: ReturnType<typeof spyOn>
-let clientDeleteMessageSpy: ReturnType<typeof spyOn>
-let clientEditMessageSpy: ReturnType<typeof spyOn>
-let clientLoginSpy: ReturnType<typeof spyOn>
-const originalConsoleLog = console.log
-const originalConsoleError = console.error
+const mockHandleError = mock((err: Error) => {
+  throw err
+})
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: mockHandleError,
+}))
 
 const mockMessage = {
   id: 'msg_123',
@@ -34,202 +30,163 @@ const mockMessage2 = {
   created: '2025-01-29T10:01:00.000Z',
 }
 
-beforeEach(() => {
-  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+const mockSendMessage = mock(() => Promise.resolve(mockMessage))
+const mockSendDirectMessage = mock(() => Promise.resolve(mockMessage))
+const mockListMessages = mock(() => Promise.resolve([mockMessage, mockMessage2]))
+const mockGetMessage = mock(() => Promise.resolve(mockMessage))
+const mockDeleteMessage = mock(() => Promise.resolve(undefined))
+const mockEditMessage = mock(() => Promise.resolve({ ...mockMessage, text: 'Updated message' }))
+
+const mockClient = {
+  sendMessage: mockSendMessage,
+  sendDirectMessage: mockSendDirectMessage,
+  listMessages: mockListMessages,
+  getMessage: mockGetMessage,
+  deleteMessage: mockDeleteMessage,
+  editMessage: mockEditMessage,
+}
 
-  clientSendMessageSpy = spyOn(WebexClient.prototype, 'sendMessage').mockResolvedValue(mockMessage)
+const mockLogin = mock(() => Promise.resolve(mockClient))
 
-  clientSendDirectMessageSpy = spyOn(WebexClient.prototype, 'sendDirectMessage').mockResolvedValue(mockMessage)
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
 
-  clientListMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue([
-    mockMessage,
-    mockMessage2,
-  ])
+import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
-  clientGetMessageSpy = spyOn(WebexClient.prototype, 'getMessage').mockResolvedValue(mockMessage)
+afterAll(() => {
+  mock.restore()
+})
 
-  clientDeleteMessageSpy = spyOn(WebexClient.prototype, 'deleteMessage').mockResolvedValue(
-    undefined,
-  )
+let consoleLogSpy: ReturnType<typeof spyOn>
 
-  clientEditMessageSpy = spyOn(WebexClient.prototype, 'editMessage').mockResolvedValue({
-    ...mockMessage,
-    text: 'Updated message',
+beforeEach(() => {
+  mockSendMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
+  mockSendDirectMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
+  mockListMessages.mockReset().mockImplementation(() => Promise.resolve([mockMessage, mockMessage2]))
+  mockGetMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
+  mockDeleteMessage.mockReset().mockImplementation(() => Promise.resolve(undefined))
+  mockEditMessage.mockReset().mockImplementation(() => Promise.resolve({ ...mockMessage, text: 'Updated message' }))
+  mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
+  mockHandleError.mockReset().mockImplementation((err: Error) => {
+    throw err
   })
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
-  clientLoginSpy?.mockRestore()
-  clientSendMessageSpy?.mockRestore()
-  clientSendDirectMessageSpy?.mockRestore()
-  clientListMessagesSpy?.mockRestore()
-  clientGetMessageSpy?.mockRestore()
-  clientDeleteMessageSpy?.mockRestore()
-  clientEditMessageSpy?.mockRestore()
-  console.log = originalConsoleLog
-  console.error = originalConsoleError
+  consoleLogSpy.mockRestore()
 })
 
 test('send: calls sendMessage with correct args and outputs result', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await sendAction('space_456', 'Hello world', { pretty: false })
 
-  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', 'Hello world', {
+  expect(mockSendMessage).toHaveBeenCalledWith('space_456', 'Hello world', {
     markdown: undefined,
   })
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('msg_123')
   expect(output).toContain('space_456')
   expect(output).toContain('user@example.com')
 })
 
 test('send: with --markdown passes markdown option', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await sendAction('space_456', '**bold**', { markdown: true, pretty: false })
 
-  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', '**bold**', { markdown: true })
+  expect(mockSendMessage).toHaveBeenCalledWith('space_456', '**bold**', { markdown: true })
 })
 
 test('send: not authenticated shows error', async () => {
-  clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
-
-  let stderrOutput = ''
-  const origWrite = process.stderr.write
-  process.stderr.write = ((chunk: string | Uint8Array) => {
-    stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
-    return true
-  }) as typeof process.stderr.write
+  mockLogin.mockImplementation(async () => {
+    throw new WebexError('No Webex credentials found.', 'no_credentials')
+  })
 
-  const originalExit = process.exit
-  process.exit = mock((_code?: number) => {
-    throw new Error('process.exit called')
-  }) as never
+  await expect(sendAction('space_456', 'Hello', { pretty: false })).rejects.toThrow('No Webex credentials found.')
 
-  try {
-    await sendAction('space_456', 'Hello', { pretty: false })
-  } catch {
-  } finally {
-    process.exit = originalExit
-    process.stderr.write = origWrite
-  }
-
-  expect(stderrOutput).toContain('No Webex credentials found')
+  expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
 })
 
 test('dm: calls sendDirectMessage with email and text', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await dmAction('alice@example.com', 'Hello!', { pretty: false })
 
-  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', 'Hello!', {
+  expect(mockSendDirectMessage).toHaveBeenCalledWith('alice@example.com', 'Hello!', {
     markdown: undefined,
   })
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('msg_123')
 })
 
 test('dm: with --markdown passes markdown option', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await dmAction('alice@example.com', '**bold**', { markdown: true, pretty: false })
 
-  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', '**bold**', {
+  expect(mockSendDirectMessage).toHaveBeenCalledWith('alice@example.com', '**bold**', {
     markdown: true,
   })
 })
 
 test('list: calls listMessages with limit and outputs array', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await listAction('space_456', { limit: 50, pretty: false })
 
-  expect(clientListMessagesSpy).toHaveBeenCalledWith('space_456', { max: 50 })
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(mockListMessages).toHaveBeenCalledWith('space_456', { max: 50 })
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('msg_123')
   expect(output).toContain('msg_124')
 })
 
 test('get: calls getMessage with correct id and outputs result', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await getAction('msg_123', { pretty: false })
 
-  expect(clientGetMessageSpy).toHaveBeenCalledWith('msg_123')
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(mockGetMessage).toHaveBeenCalledWith('msg_123')
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('msg_123')
   expect(output).toContain('user@example.com')
 })
 
 test('delete: with --force calls deleteMessage and outputs deleted id', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await deleteAction('msg_123', { force: true, pretty: false })
 
-  expect(clientDeleteMessageSpy).toHaveBeenCalledWith('msg_123')
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(mockDeleteMessage).toHaveBeenCalledWith('msg_123')
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('deleted')
   expect(output).toContain('msg_123')
 })
 
 test('delete: without --force shows warning and does not delete', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
-  const originalExit = process.exit
-  process.exit = mock((_code?: number) => {
-    throw new Error('process.exit called')
-  }) as never
-
   try {
     await deleteAction('msg_123', { force: false, pretty: false })
-  } catch {
-  } finally {
-    process.exit = originalExit
-  }
-
-  expect(clientDeleteMessageSpy).not.toHaveBeenCalled()
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  } catch {}
+
+  expect(mockDeleteMessage).not.toHaveBeenCalled()
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('warning')
   expect(output).toContain('--force')
 })
 
 test('edit: calls editMessage with roomId in args and outputs result', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await editAction('msg_123', 'space_456', 'Updated message', { pretty: false })
 
-  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', 'Updated message', {
+  expect(mockEditMessage).toHaveBeenCalledWith('msg_123', 'space_456', 'Updated message', {
     markdown: undefined,
   })
-  expect(consoleSpy).toHaveBeenCalled()
-  const output = consoleSpy.mock.calls[0][0]
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = consoleLogSpy.mock.calls[0][0]
   expect(output).toContain('msg_123')
   expect(output).toContain('Updated message')
 })
 
 test('edit: with --markdown passes markdown option', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  console.log = consoleSpy
-
   await editAction('msg_123', 'space_456', '**updated**', { markdown: true, pretty: false })
 
-  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', '**updated**', {
+  expect(mockEditMessage).toHaveBeenCalledWith('msg_123', 'space_456', '**updated**', {
     markdown: true,
   })
 })

package/src/platforms/webex/commands/snapshot.test.ts

@@ -1,44 +1,67 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
-import { WebexClient } from '../client'
+import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 import { WebexError } from '../types'
-import { snapshotAction } from './snapshot'
 
-describe('snapshot command', () => {
-  let consoleSpy: ReturnType<typeof spyOn>
-  let consoleErrorSpy: ReturnType<typeof spyOn>
-  let stderrOutput: string
-  let origStderrWrite: typeof process.stderr.write
+const mockHandleError = mock((err: Error) => {
+  throw err
+})
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: mockHandleError,
+}))
 
-  const mockSpaces = [
-    { id: 'space-1', title: 'General', type: 'group', isLocked: false, lastActivity: '2024-01-15T00:00:00.000Z', created: '2024-01-01T00:00:00.000Z', creatorId: 'person-1' },
-  ]
+const mockSpaces = [
+  { id: 'space-1', title: 'General', type: 'group', isLocked: false, lastActivity: '2024-01-15T00:00:00.000Z', created: '2024-01-01T00:00:00.000Z', creatorId: 'person-1' },
+]
 
-  const mockMessages = [
-    { id: 'msg-1', roomId: 'space-1', roomType: 'group', text: 'Hello', personId: 'person-1', personEmail: 'alice@example.com', created: '2024-01-15T00:00:00.000Z' },
-  ]
+const mockMessages = [
+  { id: 'msg-1', roomId: 'space-1', roomType: 'group', text: 'Hello', personId: 'person-1', personEmail: 'alice@example.com', created: '2024-01-15T00:00:00.000Z' },
+]
 
-  const mockMembers = [
-    { id: 'mem-1', roomId: 'space-1', personId: 'person-1', personEmail: 'alice@example.com', personDisplayName: 'Alice', isModerator: true, created: '2024-01-01T00:00:00.000Z' },
-  ]
+const mockMembers = [
+  { id: 'mem-1', roomId: 'space-1', personId: 'person-1', personEmail: 'alice@example.com', personDisplayName: 'Alice', isModerator: true, created: '2024-01-01T00:00:00.000Z' },
+]
+
+const mockListSpaces = mock(() => Promise.resolve(mockSpaces as any))
+const mockListMessages = mock(() => Promise.resolve(mockMessages as any))
+const mockListMemberships = mock(() => Promise.resolve(mockMembers as any))
+
+const mockClient = {
+  listSpaces: mockListSpaces,
+  listMessages: mockListMessages,
+  listMemberships: mockListMemberships,
+}
+
+const mockLogin = mock(() => Promise.resolve(mockClient))
+
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
+
+import { snapshotAction } from './snapshot'
+
+afterAll(() => {
+  mock.restore()
+})
+
+describe('snapshot command', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
+    mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces as any))
+    mockListMessages.mockReset().mockImplementation(() => Promise.resolve(mockMessages as any))
+    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers as any))
+    mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
+    mockHandleError.mockReset().mockImplementation((err: Error) => {
+      throw err
+    })
+
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
-    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    stderrOutput = ''
-    origStderrWrite = process.stderr.write
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
-      return true
-    }) as typeof process.stderr.write
-    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
-    spyOn(WebexClient.prototype, 'listSpaces').mockResolvedValue(mockSpaces as any)
-    spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue(mockMessages as any)
-    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers as any)
   })
 
   afterEach(() => {
-    process.stderr.write = origStderrWrite
-    mock.restore()
+    consoleSpy.mockRestore()
   })
 
   test('full snapshot includes spaces, recent_messages, members', async () => {
@@ -78,28 +101,18 @@ describe('snapshot command', () => {
   })
 
   test('not authenticated outputs error', async () => {
-    spyOn(WebexClient.prototype, 'login').mockRejectedValue(
-      new WebexError('No Webex credentials found.', 'no_credentials'),
-    )
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    const originalExit = process.exit
-    process.exit = mock((_code?: number) => { throw new Error('process.exit called') }) as never
+    await expect(snapshotAction({})).rejects.toThrow('No Webex credentials found.')
 
-    try {
-      await snapshotAction({})
-    } catch {
-    } finally {
-      process.exit = originalExit
-    }
-
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   test('passes limit option to listMessages', async () => {
-    const listMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue(mockMessages as any)
-
     await snapshotAction({ limit: 5 })
 
-    expect(listMessagesSpy).toHaveBeenCalledWith('space-1', { max: 5 })
+    expect(mockListMessages).toHaveBeenCalledWith('space-1', { max: 5 })
   })
 })