@usehercules/auth 1.2.0 → 1.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,487 @@
1
+ import { act, renderHook, waitFor } from "@testing-library/react";
2
+ import {
3
+ InMemoryWebStorage,
4
+ User,
5
+ UserManager,
6
+ WebStorageStateStore,
7
+ type NavigateParams,
8
+ type UserManagerSettings,
9
+ } from "oidc-client-ts";
10
+ import { AuthProvider, useAuth } from "react-oidc-context";
11
+ import type { PropsWithChildren } from "react";
12
+ import { afterEach, describe, expect, it, vi } from "vitest";
13
+ import { HerculesUserManager } from "./user-manager";
14
+
15
+ const AUTHORITY = "https://tenant.hercules-auth.com";
16
+ const END_SESSION = "https://auth.example.com/api/auth/oauth2/end-session";
17
+ const CLIENT_ID = "configured-client";
18
+ const RETURN_URI = "https://app.example.com";
19
+ const managers: UserManager[] = [];
20
+
21
+ function token(claims: Record<string, unknown>): string {
22
+ const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString("base64url");
23
+ return `${encode({ alg: "RS256" })}.${encode(claims)}.synthetic-signature`;
24
+ }
25
+
26
+ function user(idToken?: string, profile: Record<string, unknown> = {}): User {
27
+ const now = Math.floor(Date.now() / 1000);
28
+ return new User({
29
+ id_token: idToken,
30
+ access_token: "opaque-access-token",
31
+ refresh_token: "opaque-refresh-token",
32
+ token_type: "Bearer",
33
+ scope: "openid offline_access",
34
+ expires_at: now + 3600,
35
+ profile: {
36
+ iss: AUTHORITY,
37
+ aud: CLIENT_ID,
38
+ sub: "end-user",
39
+ iat: now,
40
+ exp: now + 3600,
41
+ ...profile,
42
+ },
43
+ });
44
+ }
45
+
46
+ function fixture(
47
+ settings: Partial<UserManagerSettings> = {},
48
+ Manager: typeof UserManager = HerculesUserManager,
49
+ ) {
50
+ const events: string[] = [];
51
+ const navigate = vi.fn(async (params: NavigateParams) => {
52
+ events.push("navigate");
53
+ return { url: params.url };
54
+ });
55
+ const close = vi.fn();
56
+ const navigator = {
57
+ prepare: vi.fn(async () => ({ navigate, close })),
58
+ callback: vi.fn(async () => {}),
59
+ };
60
+ const manager = new Manager(
61
+ {
62
+ authority: AUTHORITY,
63
+ client_id: CLIENT_ID,
64
+ redirect_uri: `${RETURN_URI}/auth/callback`,
65
+ post_logout_redirect_uri: RETURN_URI,
66
+ automaticSilentRenew: false,
67
+ userStore: new WebStorageStateStore({ store: new InMemoryWebStorage() }),
68
+ stateStore: new WebStorageStateStore({ store: new InMemoryWebStorage() }),
69
+ metadata: {
70
+ issuer: AUTHORITY,
71
+ authorization_endpoint: `${AUTHORITY}/api/auth/oauth2/authorize`,
72
+ end_session_endpoint: END_SESSION,
73
+ revocation_endpoint: `${AUTHORITY}/api/auth/oauth2/revoke`,
74
+ },
75
+ ...settings,
76
+ },
77
+ navigator,
78
+ navigator,
79
+ navigator,
80
+ );
81
+ manager.events.addUserUnloaded(() => {
82
+ events.push("unloaded");
83
+ });
84
+ managers.push(manager);
85
+ return { manager, navigate, close, events };
86
+ }
87
+
88
+ function navigationUrl(navigate: ReturnType<typeof fixture>["navigate"]): URL {
89
+ const params = navigate.mock.calls[0]?.[0];
90
+ expect(params).toBeDefined();
91
+ return new URL(params!.url);
92
+ }
93
+
94
+ afterEach(async () => {
95
+ for (const manager of managers.splice(0)) {
96
+ manager.stopSilentRenew();
97
+ await manager.events.unload();
98
+ }
99
+ vi.unstubAllGlobals();
100
+ });
101
+
102
+ describe("HerculesUserManager signoutRedirect", () => {
103
+ it.each([
104
+ { name: "missing", sid: undefined },
105
+ { name: "null", sid: null },
106
+ { name: "empty", sid: "" },
107
+ { name: "numeric", sid: 0 },
108
+ { name: "boolean", sid: false },
109
+ { name: "an array", sid: [] },
110
+ { name: "an object", sid: {} },
111
+ ])("uses confirmation when the literal ID-token sid is $name", async ({ sid }) => {
112
+ const { manager, navigate, events } = fixture();
113
+ const fetch = vi.fn();
114
+ vi.stubGlobal("fetch", fetch);
115
+ await manager.storeUser(user(token({ sid }), { sid: "profile-is-not-the-ID-token" }));
116
+
117
+ await manager.signoutRedirect();
118
+
119
+ const url = navigationUrl(navigate);
120
+ expect(url.origin + url.pathname).toBe(END_SESSION);
121
+ expect(url.searchParams.has("id_token_hint")).toBe(false);
122
+ expect(url.searchParams.get("client_id")).toBe(CLIENT_ID);
123
+ expect(url.searchParams.get("post_logout_redirect_uri")).toBe(RETURN_URI);
124
+ expect(await manager.getUser()).toBeNull();
125
+ expect(events).toEqual(["unloaded", "navigate"]);
126
+ expect(fetch).not.toHaveBeenCalled();
127
+ });
128
+
129
+ it("uses configured routing instead of claims in the omitted hint", async () => {
130
+ const { manager, navigate } = fixture();
131
+ await manager.storeUser(
132
+ user(token({ sid: null, iss: "https://untrusted.example.com", aud: "another-client" })),
133
+ );
134
+
135
+ await manager.signoutRedirect();
136
+
137
+ const url = navigationUrl(navigate);
138
+ expect(url.origin + url.pathname).toBe(END_SESSION);
139
+ expect(url.searchParams.get("client_id")).toBe(CLIENT_ID);
140
+ });
141
+
142
+ it("includes the configured client even without a return URI", async () => {
143
+ const { manager, navigate } = fixture({ post_logout_redirect_uri: "" });
144
+ await manager.storeUser(user(token({ sid: null })));
145
+
146
+ await manager.signoutRedirect();
147
+
148
+ const url = navigationUrl(navigate);
149
+ expect(url.searchParams.has("post_logout_redirect_uri")).toBe(false);
150
+ expect(url.searchParams.get("client_id")).toBe(CLIENT_ID);
151
+ });
152
+
153
+ it.each([
154
+ {
155
+ name: "a session-bound token whose profile omits sid",
156
+ idToken: token({ sid: "session-id" }),
157
+ extraQueryParams: {},
158
+ },
159
+ { name: "an unreadable token", idToken: "not-a-jwt", extraQueryParams: {} },
160
+ { name: "no ID token", idToken: undefined, extraQueryParams: {} },
161
+ {
162
+ name: "duplicate hints",
163
+ idToken: token({ sid: null }),
164
+ extraQueryParams: { id_token_hint: token({ sid: null }) },
165
+ },
166
+ {
167
+ name: "a different explicit client",
168
+ idToken: token({ sid: null }),
169
+ extraQueryParams: { client_id: "another-client" },
170
+ },
171
+ ])("keeps the upstream URL byte-for-byte for $name", async ({ idToken, extraQueryParams }) => {
172
+ const original = fixture({ extraQueryParams }, UserManager);
173
+ const adapted = fixture({ extraQueryParams });
174
+ await original.manager.storeUser(user(idToken));
175
+ await adapted.manager.storeUser(user(idToken));
176
+
177
+ await original.manager.signoutRedirect();
178
+ await adapted.manager.signoutRedirect();
179
+
180
+ expect(adapted.navigate.mock.calls[0]?.[0]).toEqual(original.navigate.mock.calls[0]?.[0]);
181
+ expect(adapted.events).toEqual(original.events);
182
+ });
183
+
184
+ it("leaves duplicate client IDs to existing provider validation", async () => {
185
+ const settings = {
186
+ metadata: {
187
+ issuer: AUTHORITY,
188
+ end_session_endpoint: `${END_SESSION}?client_id=${CLIENT_ID}`,
189
+ },
190
+ extraQueryParams: { client_id: CLIENT_ID },
191
+ };
192
+ const original = fixture(settings, UserManager);
193
+ const adapted = fixture(settings);
194
+ await original.manager.storeUser(user(token({ sid: null })));
195
+ await adapted.manager.storeUser(user(token({ sid: null })));
196
+
197
+ await original.manager.signoutRedirect();
198
+ await adapted.manager.signoutRedirect();
199
+
200
+ expect(adapted.navigate.mock.calls[0]?.[0]).toEqual(original.navigate.mock.calls[0]?.[0]);
201
+ });
202
+
203
+ it.each(["signoutPopup", "signoutSilent"] as const)("does not change %s", async (method) => {
204
+ const { manager, navigate } = fixture();
205
+ const idToken = token({ sid: null });
206
+ await manager.storeUser(user(idToken));
207
+
208
+ await manager[method]();
209
+
210
+ expect(navigationUrl(navigate).searchParams.get("id_token_hint")).toBe(idToken);
211
+ });
212
+
213
+ it("does not replace an explicitly supplied session-bound hint", async () => {
214
+ const { manager, navigate } = fixture();
215
+ const supplied = token({ sid: "explicit-session" });
216
+ await manager.storeUser(user(token({ sid: null })));
217
+
218
+ await manager.signoutRedirect({ id_token_hint: supplied });
219
+
220
+ expect(navigationUrl(navigate).searchParams.get("id_token_hint")).toBe(supplied);
221
+ });
222
+
223
+ it("preserves state storage, callback data, and navigator parameters", async () => {
224
+ const { manager, navigate } = fixture({ iframeScriptOrigin: "https://bridge.example.com" });
225
+ await manager.storeUser(user(token({ sid: null })));
226
+
227
+ await manager.signoutRedirect({ state: { returnTo: "/settings" }, url_state: "client-state" });
228
+
229
+ const url = navigationUrl(navigate);
230
+ const state = url.searchParams.get("state");
231
+ expect(state).toContain("client-state");
232
+ expect(navigate.mock.calls[0]?.[0].scriptOrigin).toBe("https://bridge.example.com");
233
+ const callback = await manager.signoutRedirectCallback(
234
+ `${RETURN_URI}?state=${encodeURIComponent(state!)}`,
235
+ );
236
+ expect(callback.userState).toEqual({ returnTo: "/settings" });
237
+ });
238
+
239
+ it.each([
240
+ { types: undefined, expected: ["access_token", "refresh_token"] },
241
+ { types: ["refresh_token"] as const, expected: ["refresh_token"] },
242
+ ])("preserves configured revocation order: $expected", async ({ types, expected }) => {
243
+ const { manager, navigate, events } = fixture({
244
+ revokeTokensOnSignout: true,
245
+ ...(types ? { revokeTokenTypes: [...types] } : {}),
246
+ });
247
+ const fetch = vi.fn(async (_input: unknown, init?: RequestInit) => {
248
+ const body = new URLSearchParams(String(init?.body));
249
+ events.push(`revoke:${body.get("token_type_hint")}`);
250
+ return new Response("{}", { headers: { "content-type": "application/json" } });
251
+ });
252
+ vi.stubGlobal("fetch", fetch);
253
+ await manager.storeUser(user(token({ sid: null })));
254
+
255
+ await manager.signoutRedirect();
256
+
257
+ expect(events).toEqual([...expected.map((type) => `revoke:${type}`), "unloaded", "navigate"]);
258
+ expect(navigationUrl(navigate).searchParams.has("id_token_hint")).toBe(false);
259
+ });
260
+
261
+ it("does not reread a user written after the upstream removal", async () => {
262
+ const { manager, navigate, events } = fixture();
263
+ await manager.storeUser(user(token({ sid: null })));
264
+ const readUser = vi.spyOn(manager.settings.userStore, "get");
265
+ manager.events.addUserUnloaded(async () => {
266
+ await manager.storeUser(user(token({ sid: null, iat: 2 })));
267
+ });
268
+
269
+ await manager.signoutRedirect();
270
+
271
+ expect(readUser).toHaveBeenCalledOnce();
272
+ expect(events).toEqual(["unloaded", "navigate"]);
273
+ expect(navigationUrl(navigate).searchParams.has("id_token_hint")).toBe(false);
274
+ });
275
+
276
+ it("delegates navigator failure and close to the upstream error path", async () => {
277
+ const { manager, navigate, close, events } = fixture();
278
+ const error = new Error("navigation failed");
279
+ navigate.mockRejectedValueOnce(error);
280
+ await manager.storeUser(user(token({ sid: null })));
281
+
282
+ await expect(manager.signoutRedirect()).rejects.toThrow(error);
283
+
284
+ expect(close).toHaveBeenCalledOnce();
285
+ expect(events).toEqual(["unloaded"]);
286
+ });
287
+
288
+ it("leaves loading and revocation errors inside the existing React navigator action", async () => {
289
+ const { manager, navigate, close, events } = fixture({ revokeTokensOnSignout: true });
290
+ let rejectRevocation!: (error: Error) => void;
291
+ vi.stubGlobal(
292
+ "fetch",
293
+ vi.fn(
294
+ () =>
295
+ new Promise<Response>((_resolve, reject) => {
296
+ rejectRevocation = reject;
297
+ }),
298
+ ),
299
+ );
300
+ await manager.storeUser(user(token({ sid: null })));
301
+ const { result } = renderHook(() => useAuth(), {
302
+ wrapper: ({ children }: PropsWithChildren) => (
303
+ <AuthProvider userManager={manager}>{children}</AuthProvider>
304
+ ),
305
+ });
306
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
307
+
308
+ let signout!: ReturnType<typeof manager.signoutRedirect>;
309
+ act(() => {
310
+ signout = result.current.signoutRedirect();
311
+ });
312
+ await waitFor(() => expect(result.current.activeNavigator).toBe("signoutRedirect"));
313
+ await waitFor(() => expect(rejectRevocation).toBeDefined());
314
+ await act(async () => {
315
+ rejectRevocation(new Error("revocation failed"));
316
+ await signout;
317
+ });
318
+
319
+ expect(result.current.activeNavigator).toBeUndefined();
320
+ expect(result.current.error?.source).toBe("signoutRedirect");
321
+ expect(navigate).not.toHaveBeenCalled();
322
+ expect(close).toHaveBeenCalledOnce();
323
+ expect(events).toEqual([]);
324
+ expect(await manager.getUser()).not.toBeNull();
325
+ });
326
+ });
327
+
328
+ describe("HerculesUserManager signoutRedirect inside a frame", () => {
329
+ afterEach(() => {
330
+ vi.restoreAllMocks();
331
+ });
332
+
333
+ function simulateFrame() {
334
+ vi.spyOn(window, "top", "get").mockReturnValue({} as Window);
335
+ }
336
+
337
+ function stubEndSession(events: string[]) {
338
+ const fetch = vi.fn(async (input: unknown, init?: RequestInit) => {
339
+ if (init?.mode === "no-cors") {
340
+ events.push("end-session");
341
+ } else {
342
+ events.push(`revoke:${new URLSearchParams(String(init?.body)).get("token_type_hint")}`);
343
+ }
344
+ return new Response("{}", { headers: { "content-type": "application/json" } });
345
+ });
346
+ vi.stubGlobal("fetch", fetch);
347
+ return fetch;
348
+ }
349
+
350
+ function endSessionUrl(fetch: ReturnType<typeof stubEndSession>): URL {
351
+ const call = fetch.mock.calls.find(([, init]) => init?.mode === "no-cors");
352
+ expect(call).toBeDefined();
353
+ return new URL(String(call![0]));
354
+ }
355
+
356
+ it.each([
357
+ { name: "a different top window", top: () => ({}) as Window },
358
+ {
359
+ name: "an inaccessible top window",
360
+ top: (): Window => {
361
+ throw new DOMException("Blocked a frame", "SecurityError");
362
+ },
363
+ },
364
+ ])("ends the session in the background under $name", async ({ top }) => {
365
+ vi.spyOn(window, "top", "get").mockImplementation(top);
366
+ const { manager, navigate, events } = fixture();
367
+ const fetch = stubEndSession(events);
368
+ const idToken = token({ sid: "session-id" });
369
+ await manager.storeUser(user(idToken));
370
+
371
+ await manager.signoutRedirect();
372
+
373
+ expect(navigate).not.toHaveBeenCalled();
374
+ expect(events).toEqual(["unloaded", "end-session"]);
375
+ const url = endSessionUrl(fetch);
376
+ expect(url.origin + url.pathname).toBe(END_SESSION);
377
+ expect(url.searchParams.get("id_token_hint")).toBe(idToken);
378
+ expect(url.searchParams.get("post_logout_redirect_uri")).toBe(RETURN_URI);
379
+ expect(fetch).toHaveBeenCalledWith(url.toString(), {
380
+ mode: "no-cors",
381
+ credentials: "omit",
382
+ signal: expect.any(AbortSignal),
383
+ });
384
+ expect(await manager.getUser()).toBeNull();
385
+ });
386
+
387
+ it("applies the sessionless hint transform to the background request", async () => {
388
+ simulateFrame();
389
+ const { manager, navigate, events } = fixture();
390
+ const fetch = stubEndSession(events);
391
+ await manager.storeUser(user(token({ sid: null })));
392
+
393
+ await manager.signoutRedirect();
394
+
395
+ expect(navigate).not.toHaveBeenCalled();
396
+ const url = endSessionUrl(fetch);
397
+ expect(url.searchParams.has("id_token_hint")).toBe(false);
398
+ expect(url.searchParams.get("client_id")).toBe(CLIENT_ID);
399
+ });
400
+
401
+ it("keeps navigating when the app redirects its top window", async () => {
402
+ simulateFrame();
403
+ const { manager, navigate, events } = fixture({ redirectTarget: "top" });
404
+ const fetch = stubEndSession(events);
405
+ await manager.storeUser(user(token({ sid: "session-id" })));
406
+
407
+ await manager.signoutRedirect();
408
+
409
+ expect(navigate).toHaveBeenCalledOnce();
410
+ expect(fetch).not.toHaveBeenCalled();
411
+ });
412
+
413
+ it("keeps configured revocation before the background request", async () => {
414
+ simulateFrame();
415
+ const { manager, navigate, events } = fixture({ revokeTokensOnSignout: true });
416
+ stubEndSession(events);
417
+ await manager.storeUser(user(token({ sid: "session-id" })));
418
+
419
+ await manager.signoutRedirect();
420
+
421
+ expect(navigate).not.toHaveBeenCalled();
422
+ expect(events).toEqual([
423
+ "revoke:access_token",
424
+ "revoke:refresh_token",
425
+ "unloaded",
426
+ "end-session",
427
+ ]);
428
+ });
429
+
430
+ it("signs out locally when the background request fails", async () => {
431
+ simulateFrame();
432
+ const { manager, close, events } = fixture();
433
+ vi.stubGlobal(
434
+ "fetch",
435
+ vi.fn(async () => {
436
+ throw new TypeError("Failed to fetch");
437
+ }),
438
+ );
439
+ await manager.storeUser(user(token({ sid: "session-id" })));
440
+
441
+ await expect(manager.signoutRedirect()).resolves.toBeUndefined();
442
+
443
+ expect(close).not.toHaveBeenCalled();
444
+ expect(events).toEqual(["unloaded"]);
445
+ expect(await manager.getUser()).toBeNull();
446
+ });
447
+
448
+ it("stops waiting for a background request that hangs", async () => {
449
+ simulateFrame();
450
+ const timeout = vi.spyOn(AbortSignal, "timeout").mockReturnValue(AbortSignal.abort());
451
+ const { manager, events } = fixture();
452
+ vi.stubGlobal(
453
+ "fetch",
454
+ vi.fn(async (_input: unknown, init?: RequestInit) => {
455
+ init?.signal?.throwIfAborted();
456
+ return new Promise<Response>(() => {});
457
+ }),
458
+ );
459
+ await manager.storeUser(user(token({ sid: "session-id" })));
460
+
461
+ await expect(manager.signoutRedirect()).resolves.toBeUndefined();
462
+
463
+ expect(timeout).toHaveBeenCalledWith(5000);
464
+ expect(events).toEqual(["unloaded"]);
465
+ });
466
+
467
+ it("settles the React navigator action as signed out", async () => {
468
+ simulateFrame();
469
+ const { manager, events } = fixture();
470
+ stubEndSession(events);
471
+ await manager.storeUser(user(token({ sid: "session-id" })));
472
+ const { result } = renderHook(() => useAuth(), {
473
+ wrapper: ({ children }: PropsWithChildren) => (
474
+ <AuthProvider userManager={manager}>{children}</AuthProvider>
475
+ ),
476
+ });
477
+ await waitFor(() => expect(result.current.isAuthenticated).toBe(true));
478
+
479
+ await act(async () => {
480
+ await result.current.signoutRedirect();
481
+ });
482
+
483
+ expect(result.current.isAuthenticated).toBe(false);
484
+ expect(result.current.activeNavigator).toBeUndefined();
485
+ expect(result.current.error).toBeUndefined();
486
+ });
487
+ });
@@ -0,0 +1,70 @@
1
+ import { jwtDecode } from "jwt-decode";
2
+ import {
3
+ UserManager,
4
+ type CreateSignoutRequestArgs,
5
+ type IWindow,
6
+ type NavigateResponse,
7
+ } from "oidc-client-ts";
8
+
9
+ function logoutRedirectUrl(requestUrl: string, clientId: string): string {
10
+ const url = new URL(requestUrl);
11
+ const hints = url.searchParams.getAll("id_token_hint");
12
+ const idToken = hints[0];
13
+ if (!idToken || hints.length !== 1) return requestUrl;
14
+
15
+ let sessionId: unknown;
16
+ try {
17
+ sessionId = jwtDecode<{ sid?: unknown }>(idToken).sid;
18
+ } catch {
19
+ return requestUrl;
20
+ }
21
+ if (typeof sessionId === "string" && sessionId.length > 0) return requestUrl;
22
+
23
+ const clients = url.searchParams.getAll("client_id");
24
+ if (clients.length > 1 || (clients.length === 1 && clients[0] !== clientId)) return requestUrl;
25
+
26
+ url.searchParams.delete("id_token_hint");
27
+ url.searchParams.set("client_id", clientId);
28
+ return url.toString();
29
+ }
30
+
31
+ const END_SESSION_TIMEOUT_MS = 5000;
32
+
33
+ function isFramed(): boolean {
34
+ if (typeof window === "undefined") return false;
35
+ try {
36
+ return window.self !== window.top;
37
+ } catch {
38
+ return true;
39
+ }
40
+ }
41
+
42
+ async function endSessionInBackground(url: string): Promise<NavigateResponse> {
43
+ await fetch(url, {
44
+ mode: "no-cors",
45
+ credentials: "omit",
46
+ signal: AbortSignal.timeout(END_SESSION_TIMEOUT_MS),
47
+ }).catch(() => undefined);
48
+ return { url };
49
+ }
50
+
51
+ export class HerculesUserManager extends UserManager {
52
+ // Transform after UserManager's revocation and single storage removal, inside its navigator action.
53
+ protected override _signoutStart(
54
+ args: CreateSignoutRequestArgs = {},
55
+ handle: IWindow,
56
+ ): Promise<NavigateResponse> {
57
+ if (args.request_type !== "so:r") return super._signoutStart(args, handle);
58
+
59
+ return super._signoutStart(args, {
60
+ close: () => handle.close(),
61
+ navigate: (params) => {
62
+ const url = logoutRedirectUrl(params.url, this.settings.client_id);
63
+ if (this.settings.redirectTarget !== "top" && isFramed()) {
64
+ return endSessionInBackground(url);
65
+ }
66
+ return handle.navigate({ ...params, url });
67
+ },
68
+ });
69
+ }
70
+ }
@@ -0,0 +1,66 @@
1
+ import { render, screen } from "@testing-library/react";
2
+ import type { UserManager } from "oidc-client-ts";
3
+ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
4
+ import { HerculesAuthProvider, useHerculesAuthProvider } from "./HerculesAuthProvider";
5
+
6
+ function blockStorage(name: "localStorage" | "sessionStorage") {
7
+ vi.spyOn(window, name, "get").mockImplementation(() => {
8
+ throw new DOMException("The operation is insecure.", "SecurityError");
9
+ });
10
+ }
11
+
12
+ function mountProvider(): UserManager {
13
+ let manager: UserManager | undefined;
14
+ function Capture() {
15
+ manager = useHerculesAuthProvider().userManager;
16
+ return <div data-testid="app">app</div>;
17
+ }
18
+ const { unmount } = render(
19
+ <HerculesAuthProvider authority="https://auth.example.com" client_id="test-client">
20
+ <Capture />
21
+ </HerculesAuthProvider>,
22
+ );
23
+ expect(screen.getByTestId("app")).toBeTruthy();
24
+ unmount();
25
+ return manager!;
26
+ }
27
+
28
+ beforeEach(() => {
29
+ window.localStorage.clear();
30
+ window.sessionStorage.clear();
31
+ });
32
+
33
+ afterEach(() => {
34
+ vi.restoreAllMocks();
35
+ });
36
+
37
+ describe("HerculesAuthProvider storage", () => {
38
+ it("keeps OIDC state in localStorage when it is available", async () => {
39
+ const { stateStore, userStore } = mountProvider().settings;
40
+
41
+ await stateStore.set("request", "state");
42
+ await userStore.set("user", "session");
43
+
44
+ expect(window.localStorage.getItem("oidc.request")).toBe("state");
45
+ expect(window.localStorage.getItem("oidc.user")).toBe("session");
46
+ });
47
+
48
+ it("falls back to sessionStorage, which survives the sign-in redirect", async () => {
49
+ blockStorage("localStorage");
50
+
51
+ await mountProvider().settings.stateStore.set("request", "state");
52
+
53
+ expect(window.sessionStorage.getItem("oidc.request")).toBe("state");
54
+ await expect(mountProvider().settings.stateStore.get("request")).resolves.toBe("state");
55
+ });
56
+
57
+ it("mounts with in-memory storage when the browser blocks all Web Storage", async () => {
58
+ blockStorage("localStorage");
59
+ blockStorage("sessionStorage");
60
+
61
+ const { stateStore } = mountProvider().settings;
62
+ await stateStore.set("request", "state");
63
+
64
+ await expect(stateStore.get("request")).resolves.toBe("state");
65
+ });
66
+ });