@equinor/fusion-framework-react-app 14.0.2 → 14.0.3-next.0

package/src/__tests__/useAppSettings.test.tsx

@@ -0,0 +1,147 @@
+import { act } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { createRouterMiddleware } from '@equinor/fusion-framework-module-http/mock';
+
+import { useAppSettings } from '../settings/useAppSettings';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+/**
+ * Boots a parent framework whose `apps` client serves per-user settings from an
+ * in-memory store, so `useAppSettings` exercises the real fetch/update round-trip
+ * instead of a stubbed provider.
+ *
+ * @param initial - The settings the store starts seeded with.
+ * @param putResponse - Overrides the response a PUT request resolves to, to simulate a failed update.
+ */
+const mockSettingsFusion = async (
+  initial: Record<string, unknown> = {},
+  putResponse?: () => Response,
+) => {
+  const store: Record<string, unknown> = { ...initial };
+  const fusion = await mockFramework<[AppModule]>((configurator) => {
+    configurator.http.addMiddleware(
+      createRouterMiddleware('https://apps.fusion.test', (router) => {
+        router.get('/persons/me/apps/:appKey/settings', () => Response.json(store));
+        router.put('/persons/me/apps/:appKey/settings', async ({ request }) => {
+          // a caller-supplied response simulates a failed persistence request
+          if (putResponse) return putResponse();
+          // the PUT body replaces the seeded keys it targets, leaving the rest of the store untouched
+          Object.assign(store, await request.json());
+          return Response.json(store);
+        });
+      }),
+    );
+    enableAppManifestMock(configurator, env);
+  });
+  fusion.modules.app.setCurrentApp(env.manifest.appKey);
+  return fusion;
+};
+
+interface TestSettings extends Record<string, unknown> {
+  theme: string;
+  layout: string;
+}
+
+describe('useAppSettings', () => {
+  it('resolves the full persisted settings object', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark', layout: 'grid' });
+
+    const { result } = await renderAppHook(() => useAppSettings<TestSettings>(), { env, fusion });
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'grid' }),
+    );
+  });
+
+  it('falls back to the default value until the persisted settings resolve', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark', layout: 'grid' });
+
+    const { result } = await renderAppHook(
+      () => useAppSettings<TestSettings>({ theme: 'light', layout: 'list' }),
+      { env, fusion },
+    );
+
+    expect(result.current[0]).toMatchObject({ theme: 'light', layout: 'list' });
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'grid' }),
+    );
+  });
+
+  it('persists an updated settings object and notifies onUpdated', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark', layout: 'grid' });
+    const onUpdated = vi.fn();
+
+    const { result } = await renderAppHook(
+      () => useAppSettings<TestSettings>(undefined, { onUpdated }),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'grid' }),
+    );
+
+    act(() => {
+      result.current[1]({ theme: 'light', layout: 'grid' });
+    });
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'light', layout: 'grid' }),
+    );
+    await vi.waitFor(() => expect(onUpdated).toHaveBeenCalled());
+  });
+
+  it('resolves the next settings object from the previous one when given an updater function', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark', layout: 'grid' });
+
+    const { result } = await renderAppHook(() => useAppSettings<TestSettings>(), { env, fusion });
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'grid' }),
+    );
+
+    act(() => {
+      // `current` is typed as possibly undefined even though it's already resolved by this point
+      result.current[1]((current) => ({ theme: current?.theme ?? 'dark', layout: 'list' }));
+    });
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'list' }),
+    );
+  });
+
+  it('surfaces a persistence failure through onError instead of throwing', async () => {
+    const fusion = await mockSettingsFusion(
+      { theme: 'dark', layout: 'grid' },
+      () => new Response(null, { status: 500 }),
+    );
+    const onError = vi.fn();
+
+    const { result } = await renderAppHook(
+      () => useAppSettings<TestSettings>(undefined, { onError }),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() =>
+      expect(result.current[0]).toMatchObject({ theme: 'dark', layout: 'grid' }),
+    );
+
+    act(() => {
+      result.current[1]({ theme: 'light', layout: 'grid' });
+    });
+
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledWith(expect.any(Error)));
+  });
+});

package/src/__tests__/useCurrentAccount.test.tsx

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { useCurrentAccount } from '../msal/useCurrentAccount';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+describe('useCurrentAccount', () => {
+  it('returns the default mock user signed in by the app scope’s auth module', async () => {
+    const { result } = await renderAppHook(() => useCurrentAccount());
+
+    expect(result.current).toMatchObject({
+      name: 'Test User',
+      username: 'test.user@equinor.com',
+    });
+  });
+
+  it('returns the account configured through the msal mock builder', async () => {
+    const { result } = await renderAppHook(() => useCurrentAccount(), {
+      configure: (configurator) =>
+        configurator.msal.setAccount({ name: 'Ada Lovelace', username: 'ada@equinor.com' }),
+    });
+
+    expect(result.current).toMatchObject({ name: 'Ada Lovelace', username: 'ada@equinor.com' });
+  });
+
+  it('returns undefined when no account is signed in', async () => {
+    const { result } = await renderAppHook(() => useCurrentAccount(), {
+      configure: (configurator) => configurator.msal.setAccount(null),
+    });
+
+    expect(result.current).toBeUndefined();
+  });
+});

package/src/__tests__/useCurrentBookmark.test.tsx

@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableBookmarkMock } from '@equinor/fusion-framework-module-bookmark/mock';
+import type { Bookmark, BookmarkModule } from '@equinor/fusion-framework-module-bookmark';
+
+import { useCurrentBookmark } from '../bookmark/useCurrentBookmark';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+import { useAppModules } from '../useAppModules';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+/** A fully-formed seeded bookmark, so tests only override what they care about. */
+const createBookmark = (overrides: Partial<Bookmark> = {}): Bookmark => ({
+  id: 'bookmark-1',
+  name: 'My Bookmark',
+  appKey: 'test-app',
+  created: new Date('2024-01-01T00:00:00.000Z'),
+  createdBy: { id: 'seed-user', name: 'Seed User' },
+  ...overrides,
+});
+
+describe('useCurrentBookmark', () => {
+  it('returns the app-scoped current bookmark once it belongs to the active app', async () => {
+    const bookmark = createBookmark();
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const configure: AppMockConfigureFn<[BookmarkModule]> = (configurator) =>
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentBookmark(), { env, fusion, configure });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+  });
+
+  it('hides the current bookmark once it belongs to a different app', async () => {
+    const bookmark = createBookmark({ appKey: 'some-other-app' });
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const configure: AppMockConfigureFn<[BookmarkModule]> = (configurator) =>
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+
+    const { result } = await renderAppHook(
+      () => ({
+        bookmark: useCurrentBookmark(),
+        // unfiltered provider state, so we can tell the seeded bookmark actually
+        // resolved rather than the filter trivially matching a still-pending value
+        provider: useAppModules<[BookmarkModule]>().bookmark,
+      }),
+      { env, fusion, configure },
+    );
+
+    await vi.waitFor(() =>
+      expect(result.current.provider.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+    expect(result.current.bookmark.currentBookmark).toBeNull();
+  });
+
+  it('falls back to the framework-scoped bookmark provider, warning about the deprecation', async () => {
+    const bookmark = createBookmark();
+    const fusion = await mockFramework<[AppModule, BookmarkModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+    });
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const { result } = await renderAppHook(() => useCurrentBookmark(), { env, fusion });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+    expect(warnSpy).toHaveBeenCalledWith(
+      '@deprecation',
+      expect.stringContaining('has not enabled bookmarks'),
+    );
+
+    warnSpy.mockRestore();
+  });
+});

package/src/__tests__/useCurrentContext.test.tsx

@@ -0,0 +1,72 @@
+import { act } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableContextMock } from '@equinor/fusion-framework-module-context/mock';
+import type { ContextItem, ContextModule } from '@equinor/fusion-framework-module-context';
+
+import { useCurrentContext } from '../context/useCurrentContext';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+const project: ContextItem = {
+  id: 'ctx-1',
+  title: 'My project',
+  type: { id: 'ProjectMaster' },
+  value: {},
+};
+const facility: ContextItem = {
+  id: 'ctx-2',
+  title: 'My facility',
+  type: { id: 'Facility' },
+  value: {},
+};
+
+describe('useCurrentContext', () => {
+  it('resolves the context item selected on startup from the app-scoped context module', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[ContextModule]> = (configurator) =>
+      enableContextMock(configurator, (mock) => {
+        mock.setCurrentContext(project);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentContext(), { env, fusion, configure });
+
+    await vi.waitFor(() => expect(result.current.currentContext).toMatchObject({ id: project.id }));
+  });
+
+  it('switches the current context when setCurrentContext is called with another seeded item', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[ContextModule]> = (configurator) =>
+      enableContextMock(configurator, (mock) => {
+        mock.setCurrentContext(project);
+        mock.addContext(facility);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentContext(), { env, fusion, configure });
+    await vi.waitFor(() => expect(result.current.currentContext).toMatchObject({ id: project.id }));
+
+    await act(async () => {
+      await result.current.setCurrentContext(facility.id);
+    });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentContext).toMatchObject({ id: facility.id }),
+    );
+  });
+});

package/src/__tests__/useFeature.test.tsx

@@ -0,0 +1,104 @@
+import { act } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableFeatureFlagMock } from '@equinor/fusion-framework-module-feature-flag/mock';
+import type { FeatureFlagModule } from '@equinor/fusion-framework-module-feature-flag';
+
+import { useFeature } from '../feature-flag/useFeature';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('useFeature', () => {
+  it('resolves a flag seeded on the app scope when the framework has no feature-flag module', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: true });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('dark-mode'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('lets an app-scoped flag override a framework-scoped flag with the same key', async () => {
+    const fusion = await mockFramework<[AppModule, FeatureFlagModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: false });
+      });
+    });
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: true });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('dark-mode'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('exposes a framework-only flag through the merged stream when the app has not seeded it', async () => {
+    const fusion = await mockFramework<[AppModule, FeatureFlagModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'framework-only', enabled: true });
+      });
+    });
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator);
+    };
+
+    const { result } = await renderAppHook(() => useFeature('framework-only'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('inverts the current value when toggleFeature is called without an explicit value', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'my-flag', enabled: false });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('my-flag'), { env, fusion, configure });
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(false));
+
+    act(() => {
+      result.current.toggleFeature();
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+});

package/src/__tests__/useHelpCenter.test.tsx

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+
+import useAppModule from '../useAppModule';
+import { useHelpCenter } from '../help-center/useHelpCenter';
+import { EVENT_NAME } from '../help-center/event-name.js';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('useHelpCenter', () => {
+  it('dispatches the expected page and detail for every help-center action', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+
+    const { result } = await renderAppHook(
+      () => ({ helpCenter: useHelpCenter(), eventModule: useAppModule('event') }),
+      { env, fusion },
+    );
+
+    const received: Array<{ page: string } & Record<string, unknown>> = [];
+    result.current.eventModule.addEventListener(EVENT_NAME, (event) => {
+      received.push(event.detail as { page: string } & Record<string, unknown>);
+    });
+
+    result.current.helpCenter.openHelp();
+    await vi.waitFor(() => expect(received).toHaveLength(1));
+
+    result.current.helpCenter.openArticle('my-article');
+    await vi.waitFor(() => expect(received).toHaveLength(2));
+
+    result.current.helpCenter.openFaqs();
+    await vi.waitFor(() => expect(received).toHaveLength(3));
+
+    result.current.helpCenter.openSearch('my search');
+    await vi.waitFor(() => expect(received).toHaveLength(4));
+
+    result.current.helpCenter.openGovernance();
+    await vi.waitFor(() => expect(received).toHaveLength(5));
+
+    result.current.helpCenter.openReleaseNotes();
+    await vi.waitFor(() => expect(received).toHaveLength(6));
+
+    expect(received).toEqual([
+      { page: 'home' },
+      { page: 'article', articleId: 'my-article' },
+      { page: 'faqs' },
+      { page: 'search', search: 'my search' },
+      { page: 'governance' },
+      { page: 'release-notes' },
+    ]);
+  });
+});

package/src/__tests__/useStateSyncEvents.test.ts

@@ -1,9 +1,9 @@
+import { act } from 'react';
 import { describe, it, expect, vi } from 'vitest';
 import { Subject } from 'rxjs';
 
-import { act, renderHook } from '@testing-library/react';
-
 import { StateSyncEvent, type StateSyncEventType } from '@equinor/fusion-framework-module-state';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
 
 const event$ = new Subject<StateSyncEventType>();
 
@@ -14,8 +14,8 @@ vi.mock('../useAppModule', () => ({
 import { useStateSyncEvents } from '../state/useStateSyncEvents';
 
 describe('useStateSyncEvents', () => {
-  it('collects dispatched onStateSync.* events, oldest first', () => {
-    const { result } = renderHook(() => useStateSyncEvents(10));
+  it('collects dispatched onStateSync.* events, oldest first', async () => {
+    const { result } = await renderAppHook(() => useStateSyncEvents(10));
 
     expect(result.current).toEqual([]);
 
@@ -24,13 +24,14 @@ describe('useStateSyncEvents', () => {
       event$.next(new StateSyncEvent.Status({ detail: { status: 'paused' } }));
     });
 
-    expect(result.current).toHaveLength(2);
-    expect(result.current[0].detail.status).toBe('active');
-    expect(result.current[1].detail.status).toBe('paused');
+    expect(result.current).toMatchObject([
+      { detail: { status: 'active' } },
+      { detail: { status: 'paused' } },
+    ]);
   });
 
-  it('ignores events unrelated to state sync and trims the log to the given limit', () => {
-    const { result } = renderHook(() => useStateSyncEvents(1));
+  it('ignores events unrelated to state sync and trims the log to the given limit', async () => {
+    const { result } = await renderAppHook(() => useStateSyncEvents(1));
 
     act(() => {
       event$.next(new StateSyncEvent.Status({ detail: { status: 'active' } }));
@@ -43,8 +44,8 @@ describe('useStateSyncEvents', () => {
     expect(result.current[0]).toBeInstanceOf(StateSyncEvent.Error);
   });
 
-  it('unsubscribes from the event stream on unmount', () => {
-    const { result, unmount } = renderHook(() => useStateSyncEvents(10));
+  it('unsubscribes from the event stream on unmount', async () => {
+    const { result, unmount } = await renderAppHook(() => useStateSyncEvents(10));
 
     unmount();
 

package/src/__tests__/useToken.test.tsx

@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+
+import { useToken } from '../msal/useToken';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+describe('useToken', () => {
+  it('resolves a full AuthenticationResult from the app scope’s real, mock-backed auth module', async () => {
+    const { result, unmount } = await renderAppHook(() => useToken({ scopes: ['User.Read'] }));
+
+    // `renderAppHook` awaits the render, and the mock resolves near-instantly,
+    // so the pending state may have already settled by the time we can observe it
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+
+    expect(result.current.error).toBeNull();
+    expect(result.current.token?.scopes).toEqual(['User.Read']);
+    // a structurally valid JWT has three dot-separated segments
+    expect(result.current.token?.accessToken.split('.')).toHaveLength(3);
+    expect(result.current.token?.account).toMatchObject({ username: 'test.user@equinor.com' });
+
+    // unmount before the next test's environment tears down, so no acquisition
+    // effect can flush a state update against an already-destroyed `window`
+    await unmount();
+  });
+
+  it('surfaces an acquisition error instead of throwing', async () => {
+    const fusion = await mockFramework();
+    // persistent, not `-Once`: the app module hoists via a version-compat proxy that
+    // may call through before the hook's own effect does, consuming a one-shot mock
+    vi.spyOn(fusion.modules.auth, 'acquireToken').mockRejectedValue(
+      new Error('acquisition failed'),
+    );
+
+    const { result, unmount } = await renderAppHook(() => useToken({ scopes: ['User.Read'] }), {
+      fusion,
+    });
+
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+
+    expect(result.current.token).toBeUndefined();
+    expect(result.current.error).toBeInstanceOf(Error);
+
+    await unmount();
+  });
+
+  it('only re-acquires the token when the scopes\u2019 contents change, not on every re-render', async () => {
+    const fusion = await mockFramework();
+    const acquireToken = vi.spyOn(fusion.modules.auth, 'acquireToken');
+
+    const { result, rerender, unmount } = await renderAppHook((props) => useToken(props), {
+      initialProps: { scopes: ['User.Read'] },
+      fusion,
+    });
+
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(1);
+
+    // a fresh array literal with the same contents must not trigger a re-acquisition
+    await rerender({ scopes: ['User.Read'] });
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(1);
+
+    // changed scope contents must trigger a second acquisition
+    await rerender({ scopes: ['User.Read', 'Mail.Read'] });
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(2);
+
+    await unmount();
+  });
+});