agent-messenger 2.3.0 → 2.5.0

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

@@ -1,18 +1,14 @@
 import { 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,159 @@ const mockMessage2 = {
   created: '2025-01-29T10:01:00.000Z',
 }
 
-beforeEach(() => {
-  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
-
-  clientSendMessageSpy = spyOn(WebexClient.prototype, 'sendMessage').mockResolvedValue(mockMessage)
+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,
+}
 
-  clientSendDirectMessageSpy = spyOn(WebexClient.prototype, 'sendDirectMessage').mockResolvedValue(mockMessage)
+const mockLogin = mock(() => Promise.resolve(mockClient))
 
-  clientListMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue([
-    mockMessage,
-    mockMessage2,
-  ])
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
 
-  clientGetMessageSpy = spyOn(WebexClient.prototype, 'getMessage').mockResolvedValue(mockMessage)
+import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
-  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/message.ts

@@ -83,7 +83,7 @@ export async function deleteAction(
       console.log(
         formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty),
       )
-      process.exit(0)
+      return process.exit(0)
     }
 
     const client = await new WebexClient().login()

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

@@ -1,44 +1,63 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
-import { WebexClient } from '../client'
 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 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 mockListSpaces = mock(() => Promise.resolve(mockSpaces as any))
+const mockListMessages = mock(() => Promise.resolve(mockMessages as any))
+const mockListMemberships = mock(() => Promise.resolve(mockMembers as any))
 
-  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 mockClient = {
+  listSpaces: mockListSpaces,
+  listMessages: mockListMessages,
+  listMemberships: mockListMemberships,
+}
 
-  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 mockLogin = mock(() => Promise.resolve(mockClient))
 
-  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' },
-  ]
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
+
+import { snapshotAction } from './snapshot'
+
+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 +97,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 })
   })
 })

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

@@ -1,8 +1,14 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
-import { WebexClient } from '../client'
 import { WebexError } from '../types'
-import { infoAction, listAction } from './space'
+
+const mockHandleError = mock((err: Error) => {
+  throw err
+})
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: mockHandleError,
+}))
 
 const mockSpaces = [
   {
@@ -36,54 +42,42 @@ const mockSpace = {
   creatorId: 'person-1',
 }
 
-let clientLoginSpy: ReturnType<typeof spyOn>
-let clientListSpacesSpy: ReturnType<typeof spyOn>
-let clientGetSpaceSpy: ReturnType<typeof spyOn>
-let consoleLogSpy: ReturnType<typeof spyOn>
-let consoleErrorSpy: ReturnType<typeof spyOn>
-let processExitSpy: ReturnType<typeof spyOn>
-let stderrOutput: string
-let origStderrWrite: typeof process.stderr.write
-
-beforeEach(() => {
-  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
-    new WebexClient() as InstanceType<typeof WebexClient>,
-  )
+const mockListSpaces = mock(() => Promise.resolve(mockSpaces))
+const mockGetSpace = mock(() => Promise.resolve(mockSpace))
+const mockLogin = mock(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
 
-  clientListSpacesSpy = spyOn(WebexClient.prototype, 'listSpaces').mockResolvedValue(mockSpaces)
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
 
-  clientGetSpaceSpy = spyOn(WebexClient.prototype, 'getSpace').mockResolvedValue(mockSpace)
+import { infoAction, listAction } from './space'
 
-  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
-  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+let consoleLogSpy: ReturnType<typeof spyOn>
 
-  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-    throw new Error(`process.exit(${_code})`)
+beforeEach(() => {
+  mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces))
+  mockGetSpace.mockReset().mockImplementation(() => Promise.resolve(mockSpace))
+  mockLogin.mockReset().mockImplementation(() =>
+    Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }),
+  )
+  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
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
-  process.stderr.write = origStderrWrite
-  clientLoginSpy?.mockRestore()
-  clientListSpacesSpy?.mockRestore()
-  clientGetSpaceSpy?.mockRestore()
-  consoleLogSpy?.mockRestore()
-  consoleErrorSpy?.mockRestore()
-  processExitSpy?.mockRestore()
+  consoleLogSpy.mockRestore()
 })
 
 describe('listAction', () => {
   test('calls listSpaces and outputs mapped array', async () => {
     await listAction({})
 
-    expect(clientListSpacesSpy).toHaveBeenCalled()
+    expect(mockListSpaces).toHaveBeenCalled()
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
@@ -107,13 +101,13 @@ describe('listAction', () => {
   test('passes type and limit options to listSpaces', async () => {
     await listAction({ type: 'group', limit: 10 })
 
-    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: 'group', max: 10 })
+    expect(mockListSpaces).toHaveBeenCalledWith({ type: 'group', max: 10 })
   })
 
   test('passes undefined type and limit when not provided', async () => {
     await listAction({})
 
-    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: undefined, max: undefined })
+    expect(mockListSpaces).toHaveBeenCalledWith({ type: undefined, max: undefined })
   })
 
   test('outputs pretty-printed JSON when pretty is true', async () => {
@@ -144,12 +138,14 @@ describe('listAction', () => {
   })
 
   test('not authenticated: outputs error and exits', async () => {
-    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    await expect(listAction({})).rejects.toThrow('process.exit(1)')
+    await expect(listAction({})).rejects.toThrow('No Webex credentials found.')
 
-    expect(clientListSpacesSpy).not.toHaveBeenCalled()
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockListSpaces).not.toHaveBeenCalled()
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })
 
@@ -157,7 +153,7 @@ describe('infoAction', () => {
   test('calls getSpace with spaceId and outputs space details', async () => {
     await infoAction('space-1', {})
 
-    expect(clientGetSpaceSpy).toHaveBeenCalledWith('space-1')
+    expect(mockGetSpace).toHaveBeenCalledWith('space-1')
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify({
         id: 'space-1',
@@ -173,8 +169,7 @@ describe('infoAction', () => {
   })
 
   test('outputs null for teamId when not present', async () => {
-    const spaceWithoutTeam = { ...mockSpace, teamId: undefined }
-    clientGetSpaceSpy.mockResolvedValue(spaceWithoutTeam)
+    mockGetSpace.mockImplementation(() => Promise.resolve({ ...mockSpace, teamId: undefined }))
 
     await infoAction('space-1', {})
 
@@ -206,11 +201,13 @@ describe('infoAction', () => {
   })
 
   test('not authenticated: outputs error and exits', async () => {
-    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    await expect(infoAction('space-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(infoAction('space-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(clientGetSpaceSpy).not.toHaveBeenCalled()
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockGetSpace).not.toHaveBeenCalled()
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })