- fetch client with bearer token, one retry after a renewal, ApiError with the server code - session kept in localStorage; renewal is single-flight in a tab and under a Web Lock across tabs, and a tab adopts a session another tab already renewed - a refused refresh token signs out once; an unreachable server keeps the session - mediaUrl and onTokenChange for audio and image URLs that carry the token - sign-in and first-account screen, and a gate that shows the app only when signed in
237 lines
8.9 KiB
TypeScript
237 lines
8.9 KiB
TypeScript
import { afterEach, beforeEach, expect, test, vi } from 'vitest'
|
|
import { apiError, mockFetch } from '@/test/mockFetch'
|
|
import {
|
|
getAccessToken,
|
|
login,
|
|
logout,
|
|
mediaUrl,
|
|
onTokenChange,
|
|
register,
|
|
restoreSession,
|
|
sessionStore,
|
|
} from './session'
|
|
|
|
const user = { id: 1, username: 'tom', is_admin: true }
|
|
|
|
function session(opts: { access?: string; refresh?: string; expiresInSeconds?: number } = {}) {
|
|
const { access = 'a1', refresh = 'r1', expiresInSeconds = 900 } = opts
|
|
return {
|
|
access_token: access,
|
|
access_expires_at: new Date(Date.now() + expiresInSeconds * 1000).toISOString(),
|
|
refresh_token: refresh,
|
|
refresh_expires_at: new Date(Date.now() + 86_400_000).toISOString(),
|
|
user,
|
|
}
|
|
}
|
|
|
|
function stored() {
|
|
const raw = localStorage.getItem('sonda.session')
|
|
return raw ? JSON.parse(raw) : null
|
|
}
|
|
|
|
function storeSession(s: ReturnType<typeof session>) {
|
|
localStorage.setItem('sonda.session', JSON.stringify(s))
|
|
}
|
|
|
|
beforeEach(() => {
|
|
sessionStore.setState({
|
|
status: 'loading',
|
|
user: null,
|
|
accessToken: null,
|
|
accessExpiresAt: 0,
|
|
refreshToken: null,
|
|
})
|
|
})
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks()
|
|
delete (navigator as unknown as Record<string, unknown>).locks
|
|
})
|
|
|
|
test('login keeps the session and opens it', async () => {
|
|
const { calls } = mockFetch({ 'POST /api/v1/auth/login': () => session() })
|
|
await login('tom', 'secret123')
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
expect(sessionStore.getState().user).toEqual(user)
|
|
expect(stored().access_token).toBe('a1')
|
|
expect(stored().refresh_token).toBe('r1')
|
|
expect(JSON.parse(calls[0].init.body as string)).toEqual({ username: 'tom', password: 'secret123' })
|
|
expect((calls[0].init.headers as Record<string, string>).Authorization).toBeUndefined()
|
|
})
|
|
|
|
test('register creates the account and then signs in', async () => {
|
|
const { calls } = mockFetch({
|
|
'POST /api/v1/auth/register': () => new Response(JSON.stringify(user), { status: 201 }),
|
|
'POST /api/v1/auth/login': () => session(),
|
|
})
|
|
await register('tom', 'secret123')
|
|
expect(calls.map((c) => c.key)).toEqual(['POST /api/v1/auth/register', 'POST /api/v1/auth/login'])
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
})
|
|
|
|
test('a token with time left is returned without any request', async () => {
|
|
const { calls } = mockFetch({ 'POST /api/v1/auth/login': () => session({ expiresInSeconds: 600 }) })
|
|
await login('tom', 'secret123')
|
|
await expect(getAccessToken()).resolves.toBe('a1')
|
|
expect(calls).toHaveLength(1)
|
|
})
|
|
|
|
test('five calls at once with 30 seconds left send a single refresh', async () => {
|
|
mockFetch({
|
|
'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30 }),
|
|
'POST /api/v1/auth/refresh': () => session({ access: 'a2', refresh: 'r2' }),
|
|
})
|
|
await login('tom', 'secret123')
|
|
const tokens = await Promise.all([1, 2, 3, 4, 5].map(() => getAccessToken()))
|
|
expect(tokens).toEqual(['a2', 'a2', 'a2', 'a2', 'a2'])
|
|
const calls = (fetch as ReturnType<typeof vi.fn>).mock.calls.filter(([url]) => String(url).endsWith('/auth/refresh'))
|
|
expect(calls).toHaveLength(1)
|
|
expect(stored().refresh_token).toBe('r2')
|
|
})
|
|
|
|
test('a refresh sends the stored refresh token', async () => {
|
|
const { calls } = mockFetch({
|
|
'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30, refresh: 'r1' }),
|
|
'POST /api/v1/auth/refresh': () => session({ access: 'a2', refresh: 'r2' }),
|
|
})
|
|
await login('tom', 'secret123')
|
|
await getAccessToken()
|
|
const refresh = calls.find((c) => c.key === 'POST /api/v1/auth/refresh')!
|
|
expect(JSON.parse(refresh.init.body as string)).toEqual({ refresh_token: 'r1' })
|
|
})
|
|
|
|
test('a second tab that already renewed the session is adopted, not renewed again', async () => {
|
|
const { calls } = mockFetch({ 'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30 }) })
|
|
await login('tom', 'secret123')
|
|
// The lock is where tab B gets in first: by the time this tab holds it, B has written a fresh session.
|
|
Object.defineProperty(navigator, 'locks', {
|
|
configurable: true,
|
|
value: {
|
|
request: async (_name: string, fn: () => Promise<unknown>) => {
|
|
storeSession(session({ access: 'from-tab-b', refresh: 'r-b' }))
|
|
return fn()
|
|
},
|
|
},
|
|
})
|
|
await expect(getAccessToken()).resolves.toBe('from-tab-b')
|
|
expect(calls.filter((c) => c.key === 'POST /api/v1/auth/refresh')).toHaveLength(0)
|
|
expect(sessionStore.getState().refreshToken).toBe('r-b')
|
|
})
|
|
|
|
test('a refresh token the server refuses signs out once and stops asking', async () => {
|
|
const { calls } = mockFetch({
|
|
'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30 }),
|
|
'POST /api/v1/auth/refresh': () => apiError(401, 'invalid_refresh_token'),
|
|
})
|
|
await login('tom', 'secret123')
|
|
await expect(getAccessToken()).resolves.toBeNull()
|
|
expect(sessionStore.getState().status).toBe('anonymous')
|
|
expect(localStorage.getItem('sonda.session')).toBeNull()
|
|
const before = calls.length
|
|
await expect(getAccessToken()).resolves.toBeNull()
|
|
expect(calls).toHaveLength(before)
|
|
})
|
|
|
|
test('a network failure while renewing keeps the session', async () => {
|
|
mockFetch({
|
|
'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30 }),
|
|
'POST /api/v1/auth/refresh': () => {
|
|
throw new TypeError('Failed to fetch')
|
|
},
|
|
})
|
|
await login('tom', 'secret123')
|
|
await expect(getAccessToken()).resolves.toBe('a1')
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
expect(stored()).not.toBeNull()
|
|
})
|
|
|
|
test('login works for the page lifetime when storage is blocked', async () => {
|
|
vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
|
|
throw new Error('blocked')
|
|
})
|
|
mockFetch({ 'POST /api/v1/auth/login': () => session() })
|
|
await login('tom', 'secret123')
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
await expect(getAccessToken()).resolves.toBe('a1')
|
|
})
|
|
|
|
test('mediaUrl adds the token to a path of the API', async () => {
|
|
mockFetch({ 'POST /api/v1/auth/login': () => session({ access: 'tok' }) })
|
|
await login('tom', 'secret123')
|
|
expect(mediaUrl('/tracks/3/stream')).toBe('/api/v1/tracks/3/stream?access_token=tok')
|
|
})
|
|
|
|
test('mediaUrl without a session gives the bare URL', () => {
|
|
expect(mediaUrl('/albums/2/cover')).toBe('/api/v1/albums/2/cover')
|
|
})
|
|
|
|
test('listeners hear about a new token until they unsubscribe', async () => {
|
|
mockFetch({
|
|
'POST /api/v1/auth/login': () => session({ expiresInSeconds: 30 }),
|
|
'POST /api/v1/auth/refresh': () => session({ access: 'a2', refresh: 'r2' }),
|
|
})
|
|
const heard: string[] = []
|
|
const off = onTokenChange((t) => heard.push(t))
|
|
await login('tom', 'secret123')
|
|
await getAccessToken()
|
|
off()
|
|
sessionStore.setState({ accessExpiresAt: Date.now() + 10_000 })
|
|
mockFetch({ 'POST /api/v1/auth/refresh': () => session({ access: 'a3', refresh: 'r3' }) })
|
|
await getAccessToken()
|
|
expect(heard).toEqual(['a1', 'a2'])
|
|
})
|
|
|
|
test('logout revokes the refresh token and forgets the session', async () => {
|
|
const { calls } = mockFetch({
|
|
'POST /api/v1/auth/login': () => session(),
|
|
'POST /api/v1/auth/logout': () => new Response(null, { status: 204 }),
|
|
})
|
|
await login('tom', 'secret123')
|
|
await logout()
|
|
const call = calls.find((c) => c.key === 'POST /api/v1/auth/logout')!
|
|
expect(JSON.parse(call.init.body as string)).toEqual({ refresh_token: 'r1' })
|
|
expect(sessionStore.getState().status).toBe('anonymous')
|
|
expect(localStorage.getItem('sonda.session')).toBeNull()
|
|
})
|
|
|
|
test('logout forgets the session even when the server cannot be reached', async () => {
|
|
mockFetch({
|
|
'POST /api/v1/auth/login': () => session(),
|
|
'POST /api/v1/auth/logout': () => {
|
|
throw new TypeError('Failed to fetch')
|
|
},
|
|
})
|
|
await login('tom', 'secret123')
|
|
await logout()
|
|
expect(sessionStore.getState().status).toBe('anonymous')
|
|
})
|
|
|
|
test('restoring with nothing stored leaves you signed out', async () => {
|
|
await restoreSession()
|
|
expect(sessionStore.getState().status).toBe('anonymous')
|
|
})
|
|
|
|
test('restoring a fresh stored session signs in without a request', async () => {
|
|
const { calls } = mockFetch({})
|
|
storeSession(session({ access: 'kept' }))
|
|
await restoreSession()
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
expect(sessionStore.getState().user).toEqual(user)
|
|
expect(calls).toHaveLength(0)
|
|
await expect(getAccessToken()).resolves.toBe('kept')
|
|
})
|
|
|
|
test('restoring a session whose access token ran out renews it', async () => {
|
|
mockFetch({ 'POST /api/v1/auth/refresh': () => session({ access: 'renewed', refresh: 'r2' }) })
|
|
storeSession(session({ expiresInSeconds: -60 }))
|
|
await restoreSession()
|
|
expect(sessionStore.getState().status).toBe('authenticated')
|
|
expect(sessionStore.getState().accessToken).toBe('renewed')
|
|
})
|
|
|
|
test('restoring a session the server no longer accepts signs out', async () => {
|
|
mockFetch({ 'POST /api/v1/auth/refresh': () => apiError(401, 'invalid_refresh_token') })
|
|
storeSession(session({ expiresInSeconds: -60 }))
|
|
await restoreSession()
|
|
expect(sessionStore.getState().status).toBe('anonymous')
|
|
})
|