agent-messenger 2.10.1 → 2.11.0

package/src/platforms/teams/commands/team.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
@@ -60,7 +60,7 @@ afterEach(() => {
   credManagerSaveConfigSpy?.mockRestore()
 })
 
-test('list: returns teams with current marker', async () => {
+it('list: returns teams with current marker', async () => {
   // given: credential manager with teams
   const credManager = new TeamsCredentialManager()
   const config = await credManager.loadConfig()
@@ -75,7 +75,7 @@ test('list: returns teams with current marker', async () => {
   expect(account.teams['team-2']).toBeDefined()
 })
 
-test('list: marks current team', async () => {
+it('list: marks current team', async () => {
   // given: credential manager with current team set
   const credManager = new TeamsCredentialManager()
   const config = await credManager.loadConfig()
@@ -88,7 +88,7 @@ test('list: marks current team', async () => {
   expect(config!.accounts.work.current_team).toBe('team-1')
 })
 
-test('info: returns team details', async () => {
+it('info: returns team details', async () => {
   // given: teams client with team data
   const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
   const team = await client.getTeam('team-1')
@@ -102,7 +102,7 @@ test('info: returns team details', async () => {
   expect(team.description).toBe('First team')
 })
 
-test('info: throws error for non-existent team', async () => {
+it('info: throws error for non-existent team', async () => {
   // given: teams client
   const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
 
@@ -116,7 +116,7 @@ test('info: throws error for non-existent team', async () => {
   }
 })
 
-test('switch: updates current team', async () => {
+it('switch: updates current team', async () => {
   // given: credential manager
   const credManager = new TeamsCredentialManager()
 
@@ -127,7 +127,7 @@ test('switch: updates current team', async () => {
   expect(credManager.setCurrentTeam).toHaveBeenCalledWith('team-2', 'Team Two')
 })
 
-test('current: returns current team info', async () => {
+it('current: returns current team info', async () => {
   // given: credential manager with current team
   const credManager = new TeamsCredentialManager()
   const config = await credManager.loadConfig()
@@ -140,7 +140,7 @@ test('current: returns current team info', async () => {
   expect(config!.accounts.work.current_team).toBe('team-1')
 })
 
-test('remove: removes team from config', async () => {
+it('remove: removes team from config', async () => {
   // given: credential manager with teams
   const credManager = new TeamsCredentialManager()
   const config = await credManager.loadConfig()

package/src/platforms/teams/commands/user.test.ts

@@ -1,4 +1,4 @@
-import { expect, mock, test } from 'bun:test'
+import { expect, mock, it } from 'bun:test'
 
 // Mock TeamsClient
 const mockClient = {
@@ -28,7 +28,7 @@ const mockClient = {
   ]),
 }
 
-test('me returns current user info', async () => {
+it('me returns current user info', async () => {
   // given: authenticated user
   const user = await mockClient.testAuth()
 
@@ -46,7 +46,7 @@ test('me returns current user info', async () => {
   expect(result.email).toBe('test@example.com')
 })
 
-test('info returns user details by id', async () => {
+it('info returns user details by id', async () => {
   // given: user id
   const userId = 'user123'
 
@@ -64,7 +64,7 @@ test('info returns user details by id', async () => {
   expect(result.displayName).toBe('Test User')
 })
 
-test('list returns team members', async () => {
+it('list returns team members', async () => {
   // given: team id
   const teamId = 'team123'
 

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

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { TeamsClient } from '@/platforms/teams/client'
 import { whoamiAction, whoamiCommand } from '@/platforms/teams/commands/whoami'
@@ -33,19 +33,19 @@ afterEach(() => {
   processExitSpy?.mockRestore()
 })
 
-test('whoami command is defined with correct name and description', () => {
+it('whoami command is defined with correct name and description', () => {
   expect(whoamiCommand).toBeDefined()
   expect(whoamiCommand.name()).toBe('whoami')
   expect(whoamiCommand.description()).toBe('Show current authenticated user')
 })
 
-test('whoami command has --pretty option', () => {
+it('whoami command has --pretty option', () => {
   const options = whoamiCommand.options
   const hasPretty = options.some((opt: { long?: string }) => opt.long === '--pretty')
   expect(hasPretty).toBe(true)
 })
 
-test('whoami outputs id and displayName', async () => {
+it('whoami outputs id and displayName', async () => {
   await whoamiAction({})
 
   expect(consoleLogSpy).toHaveBeenCalledWith(
@@ -56,7 +56,7 @@ test('whoami outputs id and displayName', async () => {
   )
 })
 
-test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+it('whoami outputs pretty-printed JSON when pretty is true', async () => {
   await whoamiAction({ pretty: true })
 
   expect(consoleLogSpy).toHaveBeenCalledWith(
@@ -71,7 +71,7 @@ test('whoami outputs pretty-printed JSON when pretty is true', async () => {
   )
 })
 
-test('whoami exits with error when not authenticated', async () => {
+it('whoami exits with error when not authenticated', async () => {
   credManagerSpy.mockResolvedValue(null)
 
   await whoamiAction({})

package/src/platforms/teams/credential-manager.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, describe, expect, test } from 'bun:test'
+import { afterAll, describe, expect, it } from 'bun:test'
 import { existsSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -19,14 +19,14 @@ afterAll(() => {
 })
 
 describe('TeamsCredentialManager', () => {
-  test('loadConfig returns null when file does not exist', async () => {
+  it('loadConfig returns null when file does not exist', async () => {
     const manager = setup()
     const config = await manager.loadConfig()
 
     expect(config).toBeNull()
   })
 
-  test('saveConfig creates config file with correct permissions', async () => {
+  it('saveConfig creates config file with correct permissions', async () => {
     const testConfigDir = join(
       import.meta.dir,
       `.test-teams-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
@@ -58,13 +58,13 @@ describe('TeamsCredentialManager', () => {
     expect(loaded).toEqual(config)
   })
 
-  test('getToken returns null when not authenticated', async () => {
+  it('getToken returns null when not authenticated', async () => {
     const manager = setup()
     const token = await manager.getToken()
     expect(token).toBeNull()
   })
 
-  test('setToken saves token to config', async () => {
+  it('setToken saves token to config', async () => {
     const manager = setup()
     await manager.setToken('test-token-123', 'work')
 
@@ -72,7 +72,7 @@ describe('TeamsCredentialManager', () => {
     expect(token).toBe('test-token-123')
   })
 
-  test('setToken saves token with expiry', async () => {
+  it('setToken saves token with expiry', async () => {
     const manager = setup()
     const expiresAt = '2025-12-31T23:59:59Z'
     await manager.setToken('test-token-123', 'work', expiresAt)
@@ -82,13 +82,13 @@ describe('TeamsCredentialManager', () => {
     expect(config?.accounts?.work?.token_expires_at).toBe(expiresAt)
   })
 
-  test('getCurrentTeam returns null when not set', async () => {
+  it('getCurrentTeam returns null when not set', async () => {
     const manager = setup()
     const team = await manager.getCurrentTeam()
     expect(team).toBeNull()
   })
 
-  test('getTokenWithExpiry includes region', async () => {
+  it('getTokenWithExpiry includes region', async () => {
     const manager = setup()
     await manager.saveConfig({
       current_account: 'work',
@@ -113,7 +113,7 @@ describe('TeamsCredentialManager', () => {
     })
   })
 
-  test('getCurrentTeam returns null when current_team is set but team not in teams record', async () => {
+  it('getCurrentTeam returns null when current_team is set but team not in teams record', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work')
     const config = await manager.loadConfig()
@@ -126,7 +126,7 @@ describe('TeamsCredentialManager', () => {
     expect(team).toBeNull()
   })
 
-  test('setCurrentTeam saves team info', async () => {
+  it('setCurrentTeam saves team info', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work')
     await manager.setCurrentTeam('team-456', 'My Team')
@@ -135,7 +135,7 @@ describe('TeamsCredentialManager', () => {
     expect(team).toEqual({ team_id: 'team-456', team_name: 'My Team' })
   })
 
-  test('setCurrentTeam updates existing team', async () => {
+  it('setCurrentTeam updates existing team', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work')
     await manager.setCurrentTeam('team-1', 'Team One')
@@ -149,7 +149,7 @@ describe('TeamsCredentialManager', () => {
     expect(config?.accounts?.work?.teams['team-2']).toEqual({ team_id: 'team-2', team_name: 'Team Two' })
   })
 
-  test('clearCredentials removes all credentials', async () => {
+  it('clearCredentials removes all credentials', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work', '2025-12-31T23:59:59Z')
     await manager.setCurrentTeam('team-123', 'Test Team')
@@ -160,13 +160,13 @@ describe('TeamsCredentialManager', () => {
     expect(config).toBeNull()
   })
 
-  test('isTokenExpired returns true when no config exists', async () => {
+  it('isTokenExpired returns true when no config exists', async () => {
     const manager = setup()
     const expired = await manager.isTokenExpired()
     expect(expired).toBe(true)
   })
 
-  test('isTokenExpired returns true when no token_expires_at is set', async () => {
+  it('isTokenExpired returns true when no token_expires_at is set', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work')
 
@@ -174,7 +174,7 @@ describe('TeamsCredentialManager', () => {
     expect(expired).toBe(true)
   })
 
-  test('isTokenExpired returns true when token is expired', async () => {
+  it('isTokenExpired returns true when token is expired', async () => {
     const manager = setup()
     const pastDate = new Date(Date.now() - 60000).toISOString()
     await manager.setToken('test-token', 'work', pastDate)
@@ -183,7 +183,7 @@ describe('TeamsCredentialManager', () => {
     expect(expired).toBe(true)
   })
 
-  test('isTokenExpired returns false when token is not expired', async () => {
+  it('isTokenExpired returns false when token is not expired', async () => {
     const manager = setup()
     const futureDate = new Date(Date.now() + 3600000).toISOString()
     await manager.setToken('test-token', 'work', futureDate)
@@ -192,7 +192,7 @@ describe('TeamsCredentialManager', () => {
     expect(expired).toBe(false)
   })
 
-  test('multiple operations preserve existing data', async () => {
+  it('multiple operations preserve existing data', async () => {
     const manager = setup()
     await manager.setToken('token-1', 'work', '2025-12-31T23:59:59Z')
     await manager.setCurrentTeam('team-1', 'Team One')

package/src/platforms/teams/ensure-auth.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test'
 
 import { TeamsClient } from './client'
 import { TeamsCredentialManager } from './credential-manager'
@@ -16,7 +16,7 @@ beforeEach(() => {
   loadConfigSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
 
   extractSpy = spyOn(TeamsTokenExtractor.prototype, 'extract').mockResolvedValue([
-    { token: 'test-teams-token', accountType: 'work' },
+    { token: 'test-teams-token', accountType: 'work', accountTypeKnown: true },
   ])
 
   testAuthSpy = spyOn(TeamsClient.prototype, 'testAuth').mockResolvedValue({
@@ -44,7 +44,7 @@ afterEach(() => {
 })
 
 describe('ensureTeamsAuth', () => {
-  test('skips extraction when token exists and not expired', async () => {
+  it('skips extraction when token exists and not expired', async () => {
     // given
     loadConfigSpy.mockResolvedValue({
       current_account: 'work',
@@ -66,7 +66,7 @@ describe('ensureTeamsAuth', () => {
     expect(extractSpy).not.toHaveBeenCalled()
   })
 
-  test('extracts when no config exists', async () => {
+  it('extracts when no config exists', async () => {
     // given
     loadConfigSpy.mockResolvedValue(null)
 
@@ -94,7 +94,7 @@ describe('ensureTeamsAuth', () => {
     )
   })
 
-  test('re-extracts when token is expired', async () => {
+  it('re-extracts when token is expired', async () => {
     // given
     loadConfigSpy.mockResolvedValue({
       current_account: 'work',
@@ -124,7 +124,7 @@ describe('ensureTeamsAuth', () => {
     )
   })
 
-  test('sets first team as current', async () => {
+  it('sets first team as current', async () => {
     // when
     await ensureTeamsAuth()
 
@@ -138,7 +138,7 @@ describe('ensureTeamsAuth', () => {
     )
   })
 
-  test('saves token_expires_at', async () => {
+  it('saves token_expires_at', async () => {
     // when
     const before = Date.now()
     await ensureTeamsAuth()
@@ -151,7 +151,7 @@ describe('ensureTeamsAuth', () => {
     expect(expiresAt).toBeLessThanOrEqual(after + 60 * 60 * 1000 + 1)
   })
 
-  test('does not save when extraction returns null', async () => {
+  it('does not save when extraction returns null', async () => {
     // given
     extractSpy.mockResolvedValue([])
 
@@ -163,7 +163,7 @@ describe('ensureTeamsAuth', () => {
     expect(saveConfigSpy).not.toHaveBeenCalled()
   })
 
-  test('does not save when no teams found', async () => {
+  it('does not save when no teams found', async () => {
     // given
     listTeamsSpy.mockResolvedValue([])
 
@@ -174,7 +174,7 @@ describe('ensureTeamsAuth', () => {
     expect(saveConfigSpy).not.toHaveBeenCalled()
   })
 
-  test('silently handles extraction failure', async () => {
+  it('silently handles extraction failure', async () => {
     // given
     extractSpy.mockRejectedValue(new Error('Teams not found'))
 
@@ -185,7 +185,7 @@ describe('ensureTeamsAuth', () => {
     expect(saveConfigSpy).not.toHaveBeenCalled()
   })
 
-  test('silently handles auth validation failure', async () => {
+  it('silently handles auth validation failure', async () => {
     // given
     testAuthSpy.mockRejectedValue(new Error('401 Unauthorized'))
 
@@ -196,11 +196,11 @@ describe('ensureTeamsAuth', () => {
     expect(saveConfigSpy).not.toHaveBeenCalled()
   })
 
-  test('extracts and saves multiple accounts', async () => {
+  it('extracts and saves multiple accounts', async () => {
     // given
     extractSpy.mockResolvedValue([
-      { token: 'work-token', accountType: 'work' },
-      { token: 'personal-token', accountType: 'personal' },
+      { token: 'work-token', accountType: 'work', accountTypeKnown: true },
+      { token: 'personal-token', accountType: 'personal', accountTypeKnown: true },
     ])
 
     testAuthSpy
@@ -226,11 +226,11 @@ describe('ensureTeamsAuth', () => {
     )
   })
 
-  test('skips failed account but saves successful ones', async () => {
+  it('skips failed account but saves successful ones', async () => {
     // given
     extractSpy.mockResolvedValue([
-      { token: 'work-token', accountType: 'work' },
-      { token: 'bad-token', accountType: 'personal' },
+      { token: 'work-token', accountType: 'work', accountTypeKnown: true },
+      { token: 'bad-token', accountType: 'personal', accountTypeKnown: true },
     ])
 
     testAuthSpy
@@ -248,7 +248,58 @@ describe('ensureTeamsAuth', () => {
     expect(savedConfig.accounts.personal).toBeUndefined()
   })
 
-  test('re-extracts when token is empty string', async () => {
+  // Regression for #163: browser-sourced tokens arrive with accountTypeKnown=false and
+  // a guessed accountType of 'work'. If the work endpoint rejects them, we must probe
+  // the personal endpoint before giving up — otherwise personal accounts logged in via
+  // browser would always fail validation.
+  it('reclassifies browser-sourced token from work to personal when work probe fails', async () => {
+    // given: extractor returns a token guessed as work but with unknown flag
+    extractSpy.mockResolvedValue([{ token: 'browser-token', accountType: 'work', accountTypeKnown: false }])
+
+    // first testAuth call (work) fails, second (personal) succeeds
+    testAuthSpy
+      .mockRejectedValueOnce(new Error('HTTP 403'))
+      .mockResolvedValueOnce({ id: 'user-p', displayName: 'Personal User' })
+
+    listTeamsSpy.mockResolvedValueOnce([{ id: 'team-p', name: 'Personal Chat' }])
+
+    // when
+    await ensureTeamsAuth()
+
+    // then: saved under 'personal', not 'work'
+    const savedConfig = saveConfigSpy.mock.calls[0][0]
+    expect(savedConfig.accounts.personal).toBeDefined()
+    expect(savedConfig.accounts.personal.account_type).toBe('personal')
+    expect(savedConfig.accounts.personal.token).toBe('browser-token')
+    expect(savedConfig.accounts.work).toBeUndefined()
+  })
+
+  // Regression for #163: when a known-type desktop token and an unknown-type browser
+  // token are both extracted, the loop must not overwrite the desktop account's data.
+  it('does not overwrite existing account when a later token reclassifies to same type', async () => {
+    // given: desktop personal token and browser token that probes to personal
+    extractSpy.mockResolvedValue([
+      { token: 'desktop-personal-token', accountType: 'personal', accountTypeKnown: true },
+      { token: 'browser-token', accountType: 'work', accountTypeKnown: false },
+    ])
+
+    testAuthSpy
+      .mockResolvedValueOnce({ id: 'user-p', displayName: 'Desktop Personal' })
+      .mockRejectedValueOnce(new Error('HTTP 403'))
+      .mockResolvedValueOnce({ id: 'user-p', displayName: 'Browser Personal' })
+
+    listTeamsSpy.mockResolvedValueOnce([{ id: 'team-p', name: 'Personal' }])
+
+    // when
+    await ensureTeamsAuth()
+
+    // then: desktop token wins; browser token is skipped because personal already exists
+    const savedConfig = saveConfigSpy.mock.calls[0][0]
+    expect(savedConfig.accounts.personal.token).toBe('desktop-personal-token')
+    expect(savedConfig.accounts.work).toBeUndefined()
+  })
+
+  it('re-extracts when token is empty string', async () => {
     // given
     loadConfigSpy.mockResolvedValue({
       current_account: 'work',

package/src/platforms/teams/ensure-auth.ts

@@ -3,7 +3,7 @@ import { warn } from '@/shared/utils/stderr'
 import { TeamsClient } from './client'
 import { TeamsCredentialManager } from './credential-manager'
 import { TeamsTokenExtractor } from './token-extractor'
-import type { TeamsAccount, TeamsConfig } from './types'
+import type { TeamsAccount, TeamsAccountType, TeamsConfig } from './types'
 
 export async function ensureTeamsAuth(): Promise<void> {
   try {
@@ -20,15 +20,14 @@ export async function ensureTeamsAuth(): Promise<void> {
       current_account: config?.current_account ?? null,
       accounts: { ...config?.accounts },
     }
+    const addedTypes = new Set<TeamsAccountType>()
 
-    for (const { token, accountType } of extracted) {
+    for (const { token, accountType: extractedType, accountTypeKnown } of extracted) {
       try {
-        const client = await new TeamsClient().login({
-          token,
-          accountType,
-          region: config?.accounts[accountType]?.region,
-        })
-        await client.testAuth()
+        const resolved = await resolveAccountType(token, extractedType, accountTypeKnown, config)
+        const { client, accountType } = resolved
+
+        if (addedTypes.has(accountType)) continue
 
         const teams = await client.listTeams()
         if (accountType !== 'personal' && teams.length === 0) continue
@@ -38,23 +37,24 @@ export async function ensureTeamsAuth(): Promise<void> {
           teamMap[team.id] = { team_id: team.id, team_name: team.name }
         }
 
-        const existing = newConfig.accounts[accountType]
+        const existing: TeamsAccount | undefined = newConfig.accounts[accountType]
         const account: TeamsAccount = {
           token,
           token_expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
           region: client.getRegion(),
           account_type: accountType,
           user_name: existing?.user_name,
-          current_team: existing?.current_team ?? teams[0].id,
+          current_team: existing?.current_team ?? teams[0]?.id ?? null,
           teams: teamMap,
         }
 
         newConfig.accounts[accountType] = account
+        addedTypes.add(accountType)
         if (!newConfig.current_account) {
           newConfig.current_account = accountType
         }
       } catch (error) {
-        warn(`[agent-teams] Skipping ${accountType} account: ${(error as Error).message}`)
+        warn(`[agent-teams] Skipping ${extractedType} account: ${(error as Error).message}`)
       }
     }
 
@@ -64,6 +64,34 @@ export async function ensureTeamsAuth(): Promise<void> {
   } catch {}
 }
 
+async function resolveAccountType(
+  token: string,
+  extractedType: TeamsAccountType,
+  accountTypeKnown: boolean,
+  config: TeamsConfig | null,
+): Promise<{ client: TeamsClient; accountType: TeamsAccountType }> {
+  const candidates: TeamsAccountType[] = [extractedType]
+  if (!accountTypeKnown) {
+    candidates.push(extractedType === 'work' ? 'personal' : 'work')
+  }
+
+  let lastError: Error | null = null
+  for (const candidate of candidates) {
+    try {
+      const client = await new TeamsClient().login({
+        token,
+        accountType: candidate,
+        region: config?.accounts[candidate]?.region,
+      })
+      await client.testAuth()
+      return { client, accountType: candidate }
+    } catch (error) {
+      lastError = error as Error
+    }
+  }
+  throw lastError ?? new Error('Token validation failed')
+}
+
 function hasValidToken(config: TeamsConfig): boolean {
   const key = TeamsCredentialManager.accountOverride ?? config.current_account
   if (!key) return false

package/src/platforms/teams/index.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'bun:test'
+import { expect, it } from 'bun:test'
 
 import {
   TeamsAccountSchema,
@@ -17,58 +17,58 @@ import {
   TeamsUserSchema,
 } from '@/platforms/teams/index'
 
-test('TeamsClient is exported from barrel', () => {
+it('TeamsClient is exported from barrel', () => {
   expect(typeof TeamsClient).toBe('function')
 })
 
-test('TeamsError is exported from barrel', () => {
+it('TeamsError is exported from barrel', () => {
   expect(typeof TeamsError).toBe('function')
 })
 
-test('TeamsCredentialManager is exported from barrel', () => {
+it('TeamsCredentialManager is exported from barrel', () => {
   expect(typeof TeamsCredentialManager).toBe('function')
 })
 
-test('TeamsTeamSchema is exported from barrel', () => {
+it('TeamsTeamSchema is exported from barrel', () => {
   expect(typeof TeamsTeamSchema.parse).toBe('function')
 })
 
-test('TeamsChannelSchema is exported from barrel', () => {
+it('TeamsChannelSchema is exported from barrel', () => {
   expect(typeof TeamsChannelSchema.parse).toBe('function')
 })
 
-test('TeamsMessageSchema is exported from barrel', () => {
+it('TeamsMessageSchema is exported from barrel', () => {
   expect(typeof TeamsMessageSchema.parse).toBe('function')
 })
 
-test('TeamsUserSchema is exported from barrel', () => {
+it('TeamsUserSchema is exported from barrel', () => {
   expect(typeof TeamsUserSchema.parse).toBe('function')
 })
 
-test('TeamsReactionSchema is exported from barrel', () => {
+it('TeamsReactionSchema is exported from barrel', () => {
   expect(typeof TeamsReactionSchema.parse).toBe('function')
 })
 
-test('TeamsFileSchema is exported from barrel', () => {
+it('TeamsFileSchema is exported from barrel', () => {
   expect(typeof TeamsFileSchema.parse).toBe('function')
 })
 
-test('TeamsCredentialsSchema is exported from barrel', () => {
+it('TeamsCredentialsSchema is exported from barrel', () => {
   expect(typeof TeamsCredentialsSchema.parse).toBe('function')
 })
 
-test('TeamsAccountTypeSchema is exported from barrel', () => {
+it('TeamsAccountTypeSchema is exported from barrel', () => {
   expect(typeof TeamsAccountTypeSchema.parse).toBe('function')
 })
 
-test('TeamsAccountSchema is exported from barrel', () => {
+it('TeamsAccountSchema is exported from barrel', () => {
   expect(typeof TeamsAccountSchema.parse).toBe('function')
 })
 
-test('TeamsConfigSchema is exported from barrel', () => {
+it('TeamsConfigSchema is exported from barrel', () => {
   expect(typeof TeamsConfigSchema.parse).toBe('function')
 })
 
-test('TeamsConfigLegacySchema is exported from barrel', () => {
+it('TeamsConfigLegacySchema is exported from barrel', () => {
   expect(typeof TeamsConfigLegacySchema.parse).toBe('function')
 })