Enterprise agent platform for building, deploying, and operating AI teammates.
import {
act,
cleanup,
fireEvent,
render,
screen,
waitFor,
} from "@testing-library/react"
import React from "react"
import { renderToString } from "react-dom/server"
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
import { AnonymousAuthProvider, AuthProvider, useAuth } from "@/contexts/auth-context"
import { apiRequest, refreshStoredAccessToken } from "@/lib/api-wrapper"
import { AUTH_CACHE_KEY, AUTH_TOKEN_UPDATED_EVENT, clearStoredAuth, readAuthSessionSnapshot } from "@/lib/auth-cache"
const toastError = vi.hoisted(() => vi.fn())
const translate = vi.hoisted(() => vi.fn((key: string) => `translated:${key}`))
vi.mock("@/lib/api-wrapper", () => ({
apiRequest: vi.fn(async () => new Response(null, { status: 404 })),
refreshStoredAccessToken: vi.fn(),
}))
vi.mock("@/components/ui/sonner", () => ({ toast: { error: toastError } }))
vi.mock("@/contexts/i18n-context", () => ({ useI18n: () => ({ t: translate }) }))
afterEach(() => {
cleanup()
vi.unstubAllGlobals()
})
function writeAuthCache(
user: { id: string; username: string; email?: string | null; is_admin?: boolean },
token: string,
refreshToken: string | null = null,
expiresIn?: number,
refreshExpiresIn?: number,
) {
const now = Date.now()
localStorage.setItem(AUTH_CACHE_KEY, JSON.stringify({
schemaVersion: 2, sessionId: `test-${Math.random()}`, credentialRevision: 0, profileRevision: 0,
user, token, refreshToken, timestamp: now,
expiresAt: expiresIn ? now + expiresIn * 1000 : undefined,
refreshExpiresAt: refreshExpiresIn ? now + refreshExpiresIn * 1000 : undefined,
}))
}
function AuthProbe() {
const { checkAuth, token } = useAuth()
const [checkResult, setCheckResult] = React.useState("pending")
return (
<>
<span data-testid="access-token">{token || "none"}</span>
<span data-testid="check-result">{checkResult}</span>
<button onClick={() => {
void checkAuth().then(result => setCheckResult(String(result)))
}}>
Check auth
</button>
</>
)
}
function AuthRefreshProbe() {
const { refreshAccessToken, token } = useAuth()
const [refreshResult, setRefreshResult] = React.useState("pending")
return (
<>
<span data-testid="refresh-access-token">{token || "none"}</span>
<span data-testid="refresh-result">{refreshResult}</span>
<button onClick={() => {
void refreshAccessToken().then(result => setRefreshResult(String(result)))
}}>
Refresh access token
</button>
</>
)
}
function AuthLogoutProbe() {
const { logout, token } = useAuth()
const [result, setResult] = React.useState("pending")
return <>
<span data-testid="logout-token">{token || "none"}</span>
<span data-testid="logout-result">{result}</span>
<button onClick={() => { void logout().then(value => setResult(String(value))) }}>Logout</button>
</>
}
function AuthLoginLogoutProbe() {
const { login, logout, token } = useAuth()
const [loginResult, setLoginResult] = React.useState("pending")
const [logoutResult, setLogoutResult] = React.useState("pending")
return <>
<span data-testid="login-logout-token">{token || "none"}</span>
<span data-testid="login-result">{loginResult}</span>
<span data-testid="login-logout-result">{logoutResult}</span>
<button onClick={() => { void login("alice", "password").then(value => setLoginResult(String(value))) }}>Login</button>
<button onClick={() => { void logout().then(value => setLogoutResult(String(value))) }}>Logout</button>
</>
}
function deferred<T>() {
let resolve!: (value: T) => void
const promise = new Promise<T>(resolvePromise => { resolve = resolvePromise })
return { promise, resolve }
}
function AuthSsrProbe() {
const { isLoading, session } = useAuth()
return <span>{`${isLoading}:${session.accessToken || "none"}`}</span>
}
function AnonymousAuthProbe() {
const auth = useAuth()
const [results, setResults] = React.useState<boolean[] | null>(null)
const projection = {
user: auth.user,
isAuthenticated: auth.isAuthenticated,
token: auth.token,
refreshToken: auth.refreshToken,
session: auth.session,
isLoading: auth.isLoading,
inTeam: auth.inTeam,
teamRole: auth.teamRole,
}
return <>
<span data-testid="anonymous-auth-projection">{JSON.stringify(projection)}</span>
<span data-testid="anonymous-auth-results">{JSON.stringify(results)}</span>
<button onClick={() => {
void Promise.all([
auth.login("ignored", "ignored"),
auth.logout(),
auth.checkAuth(),
auth.refreshAccessToken(),
]).then(setResults)
}}>
Exercise anonymous auth
</button>
</>
}
describe("AuthProvider storage synchronization", () => {
beforeEach(() => {
localStorage.clear()
vi.restoreAllMocks()
toastError.mockReset()
translate.mockClear()
Object.defineProperty(navigator, "locks", {
configurable: true,
value: { request: vi.fn(async (_name: string, callback: () => Promise<unknown>) => callback()) },
})
vi.mocked(apiRequest).mockImplementation(
async () => new Response(null, { status: 404 })
)
})
it.each(["not_current", "invalid_response", "transport_failed"] as const)(
"does not discard a live session when refresh returns %s", async status => {
writeAuthCache({ id: "1", username: "alice" }, "current-token", "refresh-token")
vi.mocked(refreshStoredAccessToken).mockResolvedValue({ status, accessToken: null })
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await screen.findByText("current-token")
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => expect(screen.getByTestId("refresh-result")).toHaveTextContent("false"))
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("current-token")
expect(toastError).not.toHaveBeenCalled()
},
)
it.each(["refreshed", "advanced"] as const)(
"accepts %s only for the active session and exact access token", async status => {
writeAuthCache({ id: "1", username: "alice" }, "current-token", "refresh-token")
vi.mocked(refreshStoredAccessToken).mockResolvedValue({
status, accessToken: "current-token", session: readAuthSessionSnapshot(),
})
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await screen.findByText("current-token")
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => expect(screen.getByTestId("refresh-result")).toHaveTextContent("true"))
},
)
it("rejects a refreshed token that does not match the current credential", async () => {
writeAuthCache({ id: "1", username: "alice" }, "current-token", "refresh-token")
vi.mocked(refreshStoredAccessToken).mockResolvedValue({
status: "advanced", accessToken: "stale-token", session: {
...readAuthSessionSnapshot(), accessToken: "stale-token",
},
})
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await screen.findByText("current-token")
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => expect(screen.getByTestId("refresh-result")).toHaveTextContent("false"))
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("current-token")
})
it("server-renders an empty loading projection when browser storage is unavailable", () => {
vi.stubGlobal("localStorage", {})
expect(() => renderToString(<AuthProvider><AuthSsrProbe /></AuthProvider>)).not.toThrow()
expect(renderToString(<AuthProvider><AuthSsrProbe /></AuthProvider>)).toContain("true:none")
})
it("keeps anonymous routes neutral without auth storage or API side effects", async () => {
const cacheBefore = JSON.stringify({
schemaVersion: 2, sessionId: "personal-session", credentialRevision: 0, profileRevision: 0,
user: { id: "1", username: "alice" }, token: "personal-access", refreshToken: "personal-refresh",
timestamp: Date.now(),
})
localStorage.setItem(AUTH_CACHE_KEY, cacheBefore)
vi.mocked(apiRequest).mockClear()
vi.mocked(refreshStoredAccessToken).mockClear()
const lockRequest = vi.mocked(navigator.locks.request)
lockRequest.mockClear()
render(<AnonymousAuthProvider><AnonymousAuthProbe /></AnonymousAuthProvider>)
expect(JSON.parse(screen.getByTestId("anonymous-auth-projection").textContent || "null")).toEqual({
user: null,
isAuthenticated: false,
token: null,
refreshToken: null,
session: {
sessionId: null, credentialRevision: null, profileRevision: null,
userId: null, accessToken: null, refreshToken: null, profileFingerprint: null,
},
isLoading: false,
inTeam: false,
teamRole: null,
})
fireEvent.click(screen.getByRole("button", { name: "Exercise anonymous auth" }))
await waitFor(() => {
expect(screen.getByTestId("anonymous-auth-results")).toHaveTextContent("[false,false,false,false]")
})
expect(localStorage.getItem(AUTH_CACHE_KEY)).toBe(cacheBefore)
expect(apiRequest).not.toHaveBeenCalled()
expect(refreshStoredAccessToken).not.toHaveBeenCalled()
expect(lockRequest).not.toHaveBeenCalled()
})
it("ignores non-object auth cache payloads without a runtime error", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"access-token",
"refresh-token",
120,
240
)
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {})
render(
<AuthProvider>
<AuthProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("access-token")).toHaveTextContent("access-token")
})
act(() => {
window.dispatchEvent(new StorageEvent("storage", {
key: AUTH_CACHE_KEY,
newValue: "null",
}))
})
expect(screen.getByTestId("access-token")).toHaveTextContent("access-token")
expect(consoleError).not.toHaveBeenCalled()
})
it("updates auth state from a valid cross-tab cache payload", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240
)
render(
<AuthProvider>
<AuthProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("access-token")).toHaveTextContent("alice-access")
})
writeAuthCache(
{ id: "2", username: "bob", email: null, is_admin: false },
"bob-access",
"bob-refresh",
120,
240
)
act(() => {
window.dispatchEvent(new StorageEvent("storage", {
key: AUTH_CACHE_KEY,
newValue: localStorage.getItem(AUTH_CACHE_KEY),
}))
})
expect(screen.getByTestId("access-token")).toHaveTextContent("bob-access")
})
it("recomputes the projection from a value-free same-tab invalidation", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240,
)
render(<AuthProvider><AuthProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("access-token")).toHaveTextContent("alice-access"))
localStorage.removeItem(AUTH_CACHE_KEY)
act(() => window.dispatchEvent(new Event(AUTH_TOKEN_UPDATED_EVENT)))
expect(screen.getByTestId("access-token")).toHaveTextContent("none")
})
it("keeps auth state when a 401 leaves the refresh cache intact", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240
)
vi.mocked(apiRequest).mockImplementation(async (url) =>
new Response(null, {
status: String(url).endsWith("/api/auth/verify") ? 401 : 404,
headers: { "Error-Type": "TokenExpired" },
})
)
render(
<AuthProvider>
<AuthProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("access-token")).toHaveTextContent("alice-access")
})
fireEvent.click(screen.getByRole("button", { name: "Check auth" }))
await waitFor(() => {
expect(screen.getByTestId("check-result")).toHaveTextContent("true")
})
expect(screen.getByTestId("access-token")).toHaveTextContent("alice-access")
})
it("clears auth state when a 401 follows a rejected refresh", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240
)
vi.mocked(apiRequest).mockImplementation(async (url) => {
if (String(url).endsWith("/api/auth/verify")) {
clearStoredAuth()
return new Response(null, {
status: 401,
headers: { "Error-Type": "TokenExpired" },
})
}
return new Response(null, { status: 404 })
})
render(
<AuthProvider>
<AuthProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("access-token")).toHaveTextContent("alice-access")
})
fireEvent.click(screen.getByRole("button", { name: "Check auth" }))
await waitFor(() => {
expect(screen.getByTestId("check-result")).toHaveTextContent("false")
expect(screen.getByTestId("access-token")).toHaveTextContent("none")
})
})
it("does not log out a replacement session after an older refresh is rejected", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240
)
let resolveRefresh!: (value: { status: "rejected"; accessToken: null }) => void
const refreshPromise = new Promise<{ status: "rejected"; accessToken: null }>((resolve) => {
resolveRefresh = resolve
})
vi.mocked(refreshStoredAccessToken).mockReturnValue(refreshPromise)
render(
<AuthProvider>
<AuthRefreshProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("alice-access")
})
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => {
expect(refreshStoredAccessToken).toHaveBeenCalledWith(expect.objectContaining({
accessToken: "alice-access",
userId: "1",
}))
})
writeAuthCache(
{ id: "2", username: "bob", email: null, is_admin: false },
"bob-access",
"bob-refresh",
120,
240
)
act(() => {
window.dispatchEvent(new StorageEvent("storage", {
key: AUTH_CACHE_KEY,
newValue: localStorage.getItem(AUTH_CACHE_KEY),
}))
})
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("bob-access")
await act(async () => {
resolveRefresh({ status: "rejected", accessToken: null })
await refreshPromise
})
await waitFor(() => {
expect(screen.getByTestId("refresh-result")).toHaveTextContent("false")
})
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("bob-access")
expect(JSON.parse(localStorage.getItem(AUTH_CACHE_KEY) || "null")).toMatchObject({
token: "bob-access",
refreshToken: "bob-refresh",
user: { id: "2" },
})
})
it("logs out the current session after its own refresh is rejected", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"alice-access",
"alice-refresh",
120,
240
)
vi.mocked(refreshStoredAccessToken).mockResolvedValue({ status: "rejected", accessToken: null })
vi.spyOn(console, "error").mockImplementation(() => {})
render(
<AuthProvider>
<AuthRefreshProbe />
</AuthProvider>
)
await waitFor(() => {
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("alice-access")
})
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => {
expect(screen.getByTestId("refresh-result")).toHaveTextContent("false")
expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("none")
})
expect(localStorage.getItem(AUTH_CACHE_KEY)).toBeNull()
})
it("does not reuse the old check debounce after credentials advance in storage", async () => {
writeAuthCache(
{ id: "1", username: "alice", email: null, is_admin: false },
"old-access", "old-refresh", 120, 240,
)
render(<AuthProvider><AuthProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("access-token")).toHaveTextContent("old-access"))
const raw = JSON.parse(localStorage.getItem(AUTH_CACHE_KEY) || "{}")
raw.token = "new-access"
raw.credentialRevision += 1
localStorage.setItem(AUTH_CACHE_KEY, JSON.stringify(raw))
fireEvent.click(screen.getByRole("button", { name: "Check auth" }))
await waitFor(() => {
expect(screen.getByTestId("check-result")).toHaveTextContent("true")
expect(screen.getByTestId("access-token")).toHaveTextContent("new-access")
})
expect(vi.mocked(apiRequest).mock.calls.filter(([url]) => String(url).endsWith("/api/auth/verify"))).toHaveLength(0)
})
it("keeps the Provider projection when logout cannot acquire the storage lock", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
Object.defineProperty(navigator, "locks", {
configurable: true,
value: { request: vi.fn(async () => { throw new Error("lock unavailable") }) },
})
render(<AuthProvider><AuthLogoutProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("logout-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Logout" }))
await waitFor(() => expect(screen.getByTestId("logout-result")).toHaveTextContent("false"))
expect(screen.getByTestId("logout-token")).toHaveTextContent("access")
expect(JSON.parse(localStorage.getItem(AUTH_CACHE_KEY) || "null")).toMatchObject({ token: "access" })
})
it("clears the Provider projection when logout falls back from an intent barrier write", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
const originalSetItem = localStorage.setItem.bind(localStorage)
vi.spyOn(localStorage, "setItem").mockImplementation((key, value) => {
if (key === "auth_login_intent") throw new Error("intent write failed")
originalSetItem(key, value)
})
vi.spyOn(console, "error").mockImplementation(() => {})
render(<AuthProvider><AuthLogoutProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("logout-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Logout" }))
await waitFor(() => {
expect(screen.getByTestId("logout-result")).toHaveTextContent("true")
expect(screen.getByTestId("logout-token")).toHaveTextContent("none")
})
expect(localStorage.getItem(AUTH_CACHE_KEY)).toBeNull()
})
it("revokes the server refresh session before clearing local auth", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
const fetchMock = vi.fn(async (..._args: unknown[]) => new Response(null, { status: 200 }))
vi.stubGlobal("fetch", fetchMock)
render(<AuthProvider><AuthLogoutProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("logout-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Logout" }))
await waitFor(() => expect(screen.getByTestId("logout-result")).toHaveTextContent("true"))
const logoutCalls = fetchMock.mock.calls.filter(([url]) => String(url).endsWith("/api/auth/logout"))
expect(logoutCalls).toHaveLength(1)
expect(logoutCalls[0][1]).toMatchObject({
method: "POST",
headers: {
Authorization: "Bearer access",
},
body: JSON.stringify({ refresh_token: "refresh" }),
})
})
it("clears the Provider projection even when the login-intent barrier cannot be replaced or removed", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
const originalSetItem = localStorage.setItem.bind(localStorage)
const originalRemoveItem = localStorage.removeItem.bind(localStorage)
vi.spyOn(localStorage, "setItem").mockImplementation((key, value) => {
if (key === "auth_login_intent") throw new Error("intent write failed")
originalSetItem(key, value)
})
vi.spyOn(localStorage, "removeItem").mockImplementation(key => {
if (key === "auth_login_intent") throw new Error("intent removal failed")
originalRemoveItem(key)
})
render(<AuthProvider><AuthLogoutProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("logout-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Logout" }))
await waitFor(() => {
expect(screen.getByTestId("logout-result")).toHaveTextContent("false")
expect(screen.getByTestId("logout-token")).toHaveTextContent("none")
})
expect(localStorage.getItem(AUTH_CACHE_KEY)).toBeNull()
})
it("does not persist a same-tab login response after logout invalidates the operation", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "existing-access", "existing-refresh", 120, 240)
const loginResponse = deferred<Response>()
vi.mocked(apiRequest).mockImplementation(async url => {
if (String(url).endsWith("/api/auth/login")) return loginResponse.promise
return new Response(null, { status: 404 })
})
render(<AuthProvider><AuthLoginLogoutProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("login-logout-token")).toHaveTextContent("existing-access"))
fireEvent.click(screen.getByRole("button", { name: "Login" }))
await waitFor(() => expect(apiRequest).toHaveBeenCalledWith(expect.stringContaining("/api/auth/login"), expect.anything()))
const originalSetItem = localStorage.setItem.bind(localStorage)
const originalRemoveItem = localStorage.removeItem.bind(localStorage)
const setItem = vi.spyOn(localStorage, "setItem").mockImplementation((key, value) => {
if (key === "auth_login_intent" || key === "auth_revoked_login_intent") throw new Error("barrier persistence failed")
originalSetItem(key, value)
})
const removeItem = vi.spyOn(localStorage, "removeItem").mockImplementation(key => {
if (key === "auth_login_intent") throw new Error("intent removal failed")
originalRemoveItem(key)
})
fireEvent.click(screen.getByRole("button", { name: "Logout" }))
await waitFor(() => expect(screen.getByTestId("login-logout-token")).toHaveTextContent("none"))
setItem.mockRestore()
removeItem.mockRestore()
await act(async () => {
loginResponse.resolve(new Response(JSON.stringify({
user: { id: "1", username: "alice" }, access_token: "late-access", refresh_token: "late-refresh",
}), { status: 200, headers: { "Content-Type": "application/json" } }))
await loginResponse.promise
})
await waitFor(() => {
expect(screen.getByTestId("login-result")).toHaveTextContent("false")
expect(screen.getByTestId("login-logout-token")).toHaveTextContent("none")
})
expect(localStorage.getItem(AUTH_CACHE_KEY)).toBeNull()
})
it("shows the localized unavailable refresh toast with its stable deduplication ID", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
vi.mocked(refreshStoredAccessToken).mockResolvedValue({
status: "unavailable", accessToken: null, reason: "coordination_unavailable",
})
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await waitFor(() => expect(toastError).toHaveBeenCalledWith(
"translated:login.alerts.coordination_unavailable",
{ id: "auth-refresh-unavailable" },
))
})
it("does not show a refresh toast after the provider unmounts", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
const refresh = deferred<{ status: "unavailable"; accessToken: null; reason: "operation_failed" }>()
vi.mocked(refreshStoredAccessToken).mockReturnValue(refresh.promise)
const rendered = render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
rendered.unmount()
await act(async () => {
refresh.resolve({ status: "unavailable", accessToken: null, reason: "operation_failed" })
await refresh.promise
})
expect(toastError).not.toHaveBeenCalled()
})
it("does not show a refresh toast after the captured session is replaced", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "alice-access", "alice-refresh", 120, 240)
const refresh = deferred<{ status: "unavailable"; accessToken: null; reason: "operation_failed" }>()
vi.mocked(refreshStoredAccessToken).mockReturnValue(refresh.promise)
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("alice-access"))
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
writeAuthCache({ id: "2", username: "bob", email: null, is_admin: false }, "bob-access", "bob-refresh", 120, 240)
act(() => window.dispatchEvent(new StorageEvent("storage", { key: AUTH_CACHE_KEY })))
await waitFor(() => expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("bob-access"))
await act(async () => {
refresh.resolve({ status: "unavailable", accessToken: null, reason: "operation_failed" })
await refresh.promise
})
expect(toastError).not.toHaveBeenCalled()
})
it("suppresses the stale refresh operation and emits one stable-ID toast for the current operation", async () => {
writeAuthCache({ id: "1", username: "alice", email: null, is_admin: false }, "access", "refresh", 120, 240)
const first = deferred<{ status: "unavailable"; accessToken: null; reason: "operation_failed" }>()
const second = deferred<{ status: "unavailable"; accessToken: null; reason: "operation_failed" }>()
vi.mocked(refreshStoredAccessToken)
.mockReturnValueOnce(first.promise)
.mockReturnValueOnce(second.promise)
render(<AuthProvider><AuthRefreshProbe /></AuthProvider>)
await waitFor(() => expect(screen.getByTestId("refresh-access-token")).toHaveTextContent("access"))
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
fireEvent.click(screen.getByRole("button", { name: "Refresh access token" }))
await act(async () => {
first.resolve({ status: "unavailable", accessToken: null, reason: "operation_failed" })
await first.promise
})
expect(toastError).not.toHaveBeenCalled()
await act(async () => {
second.resolve({ status: "unavailable", accessToken: null, reason: "operation_failed" })
await second.promise
})
expect(toastError).toHaveBeenCalledTimes(1)
expect(toastError).toHaveBeenCalledWith(
"translated:login.alerts.operation_failed",
{ id: "auth-refresh-unavailable" },
)
})
})
describe("AuthProvider expiry check on page wake-up", () => {
const wakeEvents: Record<string, () => void> = {
"the page becomes visible": () => document.dispatchEvent(new Event("visibilitychange")),
"the window regains focus": () => window.dispatchEvent(new Event("focus")),
"the browser comes back online": () => window.dispatchEvent(new Event("online")),
}
beforeEach(() => {
localStorage.clear()
Object.defineProperty(navigator, "locks", {
configurable: true,
value: { request: vi.fn(async (_name: string, callback: () => Promise<unknown>) => callback()) },
})
vi.mocked(apiRequest).mockImplementation(async () => new Response(null, { status: 404 }))
vi.mocked(refreshStoredAccessToken).mockReset()
vi.mocked(refreshStoredAccessToken).mockResolvedValue({ status: "not_current", accessToken: null })
})
afterEach(() => {
Reflect.deleteProperty(document, "visibilityState")
})
it.each(Object.keys(wakeEvents))("refreshes a token near expiry as soon as %s", async event => {
writeAuthCache({ id: "1", username: "alice" }, "expiring-token", "refresh-token", 60, 3600)
render(<AuthProvider><AuthProbe /></AuthProvider>)
await screen.findByText("expiring-token")
expect(refreshStoredAccessToken).not.toHaveBeenCalled()
act(() => wakeEvents[event]())
await waitFor(() => expect(refreshStoredAccessToken).toHaveBeenCalledWith(
expect.objectContaining({ accessToken: "expiring-token", refreshToken: "refresh-token" }),
))
})
it("does not refresh when the page turns hidden", async () => {
writeAuthCache({ id: "1", username: "alice" }, "expiring-token", "refresh-token", 60, 3600)
render(<AuthProvider><AuthProbe /></AuthProvider>)
await screen.findByText("expiring-token")
Object.defineProperty(document, "visibilityState", { configurable: true, get: () => "hidden" })
act(() => wakeEvents["the page becomes visible"]())
expect(refreshStoredAccessToken).not.toHaveBeenCalled()
})
it("does not refresh a token that is far from expiry", async () => {
writeAuthCache({ id: "1", username: "alice" }, "fresh-token", "refresh-token", 3600, 7200)
render(<AuthProvider><AuthProbe /></AuthProvider>)
await screen.findByText("fresh-token")
act(() => {
for (const fire of Object.values(wakeEvents)) fire()
})
expect(refreshStoredAccessToken).not.toHaveBeenCalled()
})
it("stops checking once the provider unmounts", async () => {
writeAuthCache({ id: "1", username: "alice" }, "expiring-token", "refresh-token", 60, 3600)
const { unmount } = render(<AuthProvider><AuthProbe /></AuthProvider>)
await screen.findByText("expiring-token")
unmount()
act(() => {
for (const fire of Object.values(wakeEvents)) fire()
})
expect(refreshStoredAccessToken).not.toHaveBeenCalled()
})
})