agent-messenger 2.18.0 → 2.19.0

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

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockMembers = [
   {
@@ -32,30 +27,29 @@ const mockMembers = [
 ]
 
 const mockListMemberships = mock(() => Promise.resolve(mockMembers))
-const mockLogin = mock(() => Promise.resolve({ listMemberships: mockListMemberships }))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
 
 import { listAction } from './member'
 
 describe('member commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
+  let loginSpy: ReturnType<typeof spyOn>
+  let handleErrorSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve({ listMemberships: mockListMemberships }))
-    mockHandleError.mockReset().mockImplementation((err: Error) => {
+    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
       throw err
     })
 
+    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+      Object.assign(new WebexClient(), { listMemberships: mockListMemberships }),
+    )
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
+    loginSpy.mockRestore()
+    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
   })
 
@@ -92,13 +86,13 @@ describe('member commands', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   it('throws on API error', async () => {
@@ -108,6 +102,6 @@ describe('member commands', () => {
 
     await expect(listAction('room-1', {})).rejects.toThrow('API failure')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(Error))
   })
 })

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

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockMessage = {
   id: 'msg_123',
@@ -46,17 +41,11 @@ const mockClient = {
   editMessage: mockEditMessage,
 }
 
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
 let consoleLogSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let handleErrorSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   mockSendMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
@@ -65,15 +54,17 @@ beforeEach(() => {
   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) => {
+  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
     throw err
   })
 
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
+  loginSpy.mockRestore()
+  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
 })
 
@@ -97,13 +88,13 @@ it('passes markdown option when --markdown flag is set on send', async () => {
 })
 
 it('throws when not authenticated on send', async () => {
-  mockLogin.mockImplementation(async () => {
+  loginSpy.mockImplementation(async () => {
     throw new WebexError('No Webex credentials found.', 'no_credentials')
   })
 
   await expect(sendAction('space_456', 'Hello', { pretty: false })).rejects.toThrow('No Webex credentials found.')
 
-  expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+  expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
 })
 
 it('calls sendDirectMessage with email and text', async () => {

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

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockSpaces = [
   {
@@ -51,31 +46,27 @@ const mockClient = {
   listMyMemberships: mockListMyMemberships,
 }
 
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 import { snapshotAction } from './snapshot'
 
 describe('snapshot command', () => {
   let consoleSpy: ReturnType<typeof spyOn>
+  let loginSpy: ReturnType<typeof spyOn>
+  let handleErrorSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces as any))
     mockListMyMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMyMemberships as any))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
-    mockHandleError.mockReset().mockImplementation((err: Error) => {
+    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
       throw err
     })
 
+    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
+    loginSpy.mockRestore()
+    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
   })
 
@@ -113,12 +104,12 @@ describe('snapshot command', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(snapshotAction({})).rejects.toThrow('No Webex credentials found.')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })

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

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockSpaces = [
   {
@@ -44,32 +39,29 @@ const mockSpace = {
 
 const mockListSpaces = mock(() => Promise.resolve(mockSpaces))
 const mockGetSpace = mock(() => Promise.resolve(mockSpace))
-const mockLogin = mock(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
 
 import { infoAction, listAction } from './space'
 
 let consoleLogSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let handleErrorSpy: ReturnType<typeof spyOn>
 
 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) => {
+  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
     throw err
   })
 
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+    Object.assign(new WebexClient(), { listSpaces: mockListSpaces, getSpace: mockGetSpace }),
+  )
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
+  loginSpy.mockRestore()
+  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
 })
 
@@ -138,14 +130,14 @@ describe('listAction', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(listAction({})).rejects.toThrow('No Webex credentials found.')
 
     expect(mockListSpaces).not.toHaveBeenCalled()
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })
 
@@ -201,13 +193,13 @@ describe('infoAction', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(infoAction('space-1', {})).rejects.toThrow('No Webex credentials found.')
 
     expect(mockGetSpace).not.toHaveBeenCalled()
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
-import * as clientModule from '../client'
+import { WebexClient } from '../client'
 import { WebexError } from '../types'
 import { whoamiCommand } from './whoami'
 
@@ -17,27 +17,21 @@ const mockUser = {
   created: '2024-01-01T00:00:00.000Z',
 }
 
-const makeFakeClient = () => ({
-  login: async function (this: unknown) {
-    return this
-  },
-  testAuth: async () => mockUser,
-})
-
-let webexClientSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let testAuthSpy: ReturnType<typeof spyOn>
 let consoleLogSpy: ReturnType<typeof spyOn>
 let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  webexClientSpy = spyOn(clientModule, 'WebexClient').mockImplementation(
-    makeFakeClient as unknown as typeof clientModule.WebexClient,
-  )
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+  testAuthSpy = spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockUser)
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
   processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
-  webexClientSpy?.mockRestore()
+  loginSpy?.mockRestore()
+  testAuthSpy?.mockRestore()
   consoleLogSpy?.mockRestore()
   processExitSpy?.mockRestore()
 })
@@ -102,15 +96,7 @@ it('whoami outputs pretty-printed JSON when --pretty flag is passed', async () =
 
 it('whoami exits with code 1 when not authenticated', async () => {
   // given: no credentials
-  webexClientSpy.mockImplementation(
-    () =>
-      ({
-        login: async () => {
-          throw new WebexError('No Webex credentials found.', 'no_credentials')
-        },
-        testAuth: async () => mockUser,
-      }) as unknown as clientModule.WebexClient,
-  )
+  loginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
   // when: running whoami
   await whoamiCommand.parseAsync([], { from: 'user' })

package/src/shared/chromium/browsers.ts

@@ -75,7 +75,7 @@ export function discoverBrowserProfileDirs(browserBase: string): string[] {
   dirs.push(join(browserBase, 'Default'))
   if (!existsSync(browserBase)) return dirs
   try {
-    const entries = readdirSync(browserBase, { withFileTypes: true })
+    const entries = readdirSync(browserBase, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
     for (const entry of entries) {
       if (!entry.isDirectory()) continue
       if (!/^Profile \d+$/i.test(entry.name)) continue

package/src/test-setup.ts

@@ -0,0 +1,5 @@
+import { afterEach, mock } from 'bun:test'
+
+afterEach(() => {
+  mock.restore()
+})

package/tsconfig.json

@@ -38,5 +38,5 @@
     "noFallthroughCasesInSwitch": true
   },
   "include": ["src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*-test.ts"]
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*-test.ts", "src/test-setup.ts"]
 }