@morscherlab/mint-sdk 1.3.0-beta.3 → 1.3.0-beta.5

package/src/__tests__/composables/useAuth.test.ts

@@ -1,290 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios from 'axios'
-
-vi.mock('axios')
-const mockedAxios = vi.mocked(axios, true)
-
-const unmountedCallbacks: Array<() => void> = []
-
-// Mock vue lifecycle hooks since we're not in a component
-vi.mock('vue', async () => {
-  const actual = await vi.importActual<typeof import('vue')>('vue')
-  return {
-    ...actual,
-    getCurrentInstance: vi.fn(() => ({})),
-    onMounted: vi.fn((cb: () => void) => cb()),
-    onUnmounted: vi.fn((cb: () => void) => {
-      unmountedCallbacks.push(cb)
-    }),
-  }
-})
-
-import { useAuth, _resetAuthStateForTesting } from '../../composables/useAuth'
-import { useAuthStore } from '../../stores/auth'
-import { useSettingsStore } from '../../stores/settings'
-
-describe('useAuth', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    vi.clearAllMocks()
-    vi.useFakeTimers()
-    unmountedCallbacks.length = 0
-    _resetAuthStateForTesting()
-
-    // Mock settings store
-    const settingsStore = useSettingsStore()
-    settingsStore.getApiBaseUrl = vi.fn(() => 'http://localhost:8000')
-
-    // Mock localStorage
-    const storage: Record<string, string> = {}
-    vi.stubGlobal('localStorage', {
-      getItem: vi.fn((key: string) => storage[key] ?? null),
-      setItem: vi.fn((key: string, val: string) => { storage[key] = val }),
-      removeItem: vi.fn((key: string) => { delete storage[key] }),
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-    vi.restoreAllMocks()
-  })
-
-  it('loads the PostgreSQL-only public auth contract', async () => {
-    mockedAxios.get.mockResolvedValueOnce({
-      data: {
-        auth_required: true,
-        passkey_enabled: true,
-        passkey_registered: false,
-        registration_enabled: true,
-        database_mode: 'postgresql',
-        access: { experiment_visibility_mode: 'restricted' },
-      },
-    })
-
-    const config = await useAuth().fetchAuthConfig()
-    const expected = {
-      authRequired: true,
-      passkeyEnabled: true,
-      passkeyRegistered: false,
-      registrationEnabled: true,
-      databaseMode: 'postgresql',
-      experimentVisibilityMode: 'restricted',
-    }
-
-    expect([config, useAuthStore().authConfig]).toEqual([expected, expected])
-  })
-
-  describe('login', () => {
-    it('should set token on successful login', async () => {
-      mockedAxios.post.mockResolvedValueOnce({
-        data: { access_token: 'test-token', expires_in: 3600, token_type: 'bearer' },
-      })
-      mockedAxios.get.mockResolvedValueOnce({
-        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
-      })
-
-      const { login } = useAuth()
-      const result = await login('test', 'password')
-
-      expect(result).toBe(true)
-      const authStore = useAuthStore()
-      expect(authStore.token).toBe('test-token')
-    })
-
-    it('should return false on failed login', async () => {
-      mockedAxios.post.mockRejectedValueOnce({
-        isAxiosError: true,
-        response: { data: { detail: 'Invalid credentials' }, status: 401 },
-      })
-      // @ts-expect-error -- vitest mock assignment
-      mockedAxios.isAxiosError = vi.fn(() => true)
-
-      const { login } = useAuth()
-      const result = await login('test', 'wrong')
-
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('logout', () => {
-    it('should clear token on logout', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('test-token', 3600)
-
-      const { logout } = useAuth()
-      logout()
-
-      expect(authStore.token).toBeNull()
-    })
-  })
-
-  describe('storage fallback', () => {
-    it('keeps auth usable when localStorage operations throw', () => {
-      vi.stubGlobal('localStorage', {
-        getItem: vi.fn(() => { throw new Error('blocked') }),
-        setItem: vi.fn(() => { throw new Error('blocked') }),
-        removeItem: vi.fn(() => { throw new Error('blocked') }),
-      })
-
-      const authStore = useAuthStore()
-
-      expect(() => authStore.initialize()).not.toThrow()
-
-      authStore.setToken('memory-token', 3600)
-      expect(authStore.token).toBe('memory-token')
-
-      authStore.clearToken()
-      expect(authStore.token).toBeNull()
-    })
-  })
-
-  describe('refreshToken - race condition', () => {
-    it('should deduplicate concurrent refresh calls', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('old-token', 3600)
-
-      let resolveRefresh: (value: unknown) => void
-      const refreshPromise = new Promise((resolve) => {
-        resolveRefresh = resolve
-      })
-
-      mockedAxios.post.mockImplementation(() => refreshPromise as Promise<unknown>)
-
-      const { refreshToken } = useAuth()
-
-      // Fire two concurrent refreshes
-      const p1 = refreshToken()
-      const p2 = refreshToken()
-
-      // Both should return the same promise
-      resolveRefresh!({
-        data: { access_token: 'new-token', expires_in: 3600, token_type: 'bearer' },
-      })
-
-      const [r1, r2] = await Promise.all([p1, p2])
-      expect(r1).toBe(true)
-      expect(r2).toBe(true)
-
-      // axios.post should have been called only once
-      expect(mockedAxios.post).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('refreshToken - lifecycle behavior', () => {
-    it('keeps scheduled refresh when one of multiple consumers unmounts', async () => {
-      mockedAxios.post.mockImplementation((url: string) => {
-        if (url.endsWith('/auth/login')) {
-          return Promise.resolve({
-            data: { access_token: 'test-token', expires_in: 301, token_type: 'bearer' },
-          })
-        }
-        if (url.endsWith('/auth/refresh')) {
-          return Promise.resolve({
-            data: { access_token: 'refreshed-token', expires_in: 3600, token_type: 'bearer' },
-          })
-        }
-        throw new Error(`Unexpected POST ${url}`)
-      })
-      mockedAxios.get.mockResolvedValue({
-        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
-      })
-
-      const authA = useAuth()
-      useAuth()
-
-      await authA.login('test', 'password')
-
-      expect(unmountedCallbacks).toHaveLength(2)
-      unmountedCallbacks[0]!()
-
-      vi.advanceTimersByTime(2_000)
-      await Promise.resolve()
-
-      const refreshCalls = mockedAxios.post.mock.calls.filter(
-        ([url]) => typeof url === 'string' && url.endsWith('/auth/refresh'),
-      )
-      expect(refreshCalls).toHaveLength(1)
-
-      unmountedCallbacks[1]!()
-    })
-  })
-
-  describe('verifyToken', () => {
-    it('should return false when no token', async () => {
-      const { verifyToken } = useAuth()
-      const result = await verifyToken()
-      expect(result).toBe(false)
-    })
-
-    it('should return true on valid token', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('valid-token', 3600)
-
-      mockedAxios.get.mockResolvedValueOnce({
-        data: { valid: true, username: 'testuser' },
-      })
-
-      const { verifyToken } = useAuth()
-      const result = await verifyToken()
-      expect(result).toBe(true)
-    })
-  })
-
-  describe('updateProfile', () => {
-    it('should swap in the replacement token when a password change returns one', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('old-token', 3600)
-      mockedAxios.put.mockResolvedValueOnce({
-        data: {
-          id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true,
-          access_token: 'fresh-token', expires_in: 7200,
-        },
-      })
-
-      await useAuth().updateProfile({ currentPassword: 'old', newPassword: 'new-password' })
-
-      expect(authStore.token).toBe('fresh-token')
-    })
-
-    async function changePasswordDuringRefresh(settle: (reject: (e: unknown) => void, resolve: (v: unknown) => void) => void) {
-      const authStore = useAuthStore()
-      authStore.setToken('old-token', 3600)
-      let resolveRefresh!: (v: unknown) => void
-      let rejectRefresh!: (e: unknown) => void
-      mockedAxios.post.mockReturnValueOnce(new Promise((resolve, reject) => {
-        resolveRefresh = resolve
-        rejectRefresh = reject
-      }))
-      mockedAxios.put.mockResolvedValueOnce({
-        data: {
-          id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true,
-          access_token: 'fresh-token', expires_in: 7200,
-        },
-      })
-      const auth = useAuth()
-      const refreshing = auth.refreshToken()
-      await auth.updateProfile({ currentPassword: 'old', newPassword: 'new-password' })
-      settle(rejectRefresh, resolveRefresh)
-      await refreshing
-      return authStore.token
-    }
-
-    it('should keep the fresh token when an old-token refresh fails with 401 afterwards', async () => {
-      mockedAxios.isAxiosError.mockReturnValue(true)
-
-      const token = await changePasswordDuringRefresh((reject) => reject({ response: { status: 401 } }))
-
-      expect(token).toBe('fresh-token')
-    })
-
-    it('should keep the fresh token when an old-token refresh succeeds afterwards', async () => {
-      const token = await changePasswordDuringRefresh((_reject, resolve) =>
-        resolve({ data: { access_token: 'revoked-token', expires_in: 3600, token_type: 'bearer' } }),
-      )
-
-      expect(token).toBe('fresh-token')
-    })
-  })
-})
-

package/src/__tests__/composables/usePasskey.test.ts

@@ -1,38 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios from 'axios'
-import { startAuthentication, startRegistration } from '@simplewebauthn/browser'
-import { usePasskey } from '../../composables/usePasskey'
-
-vi.mock('axios')
-vi.mock('@simplewebauthn/browser', () => ({
-  browserSupportsWebAuthn: vi.fn(() => true),
-  startAuthentication: vi.fn(),
-  startRegistration: vi.fn(),
-}))
-
-const options = { challenge: 'challenge' }
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  vi.mocked(axios.get).mockResolvedValueOnce({ data: { options: JSON.stringify(options) } })
-  vi.mocked(axios.post).mockResolvedValueOnce({ data: { access_token: 'token', expires_in: 3600 } })
-})
-
-afterEach(() => {
-  vi.resetAllMocks()
-})
-
-describe('usePasskey', () => {
-  it('should pass server options as optionsJSON when logging in', async () => {
-    await usePasskey().loginWithPasskey()
-
-    expect(startAuthentication).toHaveBeenCalledWith({ optionsJSON: options })
-  })
-
-  it('should pass server options as optionsJSON when registering', async () => {
-    await usePasskey().registerPasskey('Laptop')
-
-    expect(startRegistration).toHaveBeenCalledWith({ optionsJSON: options })
-  })
-})