@equinor/fusion-framework-react-app 14.0.1 → 15.0.0-next.0

package/dist/types/create-component.d.ts

@@ -27,7 +27,7 @@ export type ComponentRenderer<TFusion extends Fusion = Fusion, TEnv = AppEnv> =
  * @example
  * ```tsx
  * const configCallback: AppConfigurator = (configurator) => {
- *  configurator.http.configureClient(
+ *  configurator.configureHttpClient(
  *     'bar', {
  *       baseUri: 'https://somewhere-test.com',
  *       defaultScopes: ['foo/.default']

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "14.0.1";
+export declare const version = "15.0.0-next.0";

package/docs/bookmark.md

@@ -78,6 +78,13 @@ const MyApp = () => {
 };
 ```
 
+> [!WARNING]
+> If your app has **not** called `enableBookmark`, `useCurrentBookmark` falls back to the
+> portal's framework-scoped bookmark provider and logs a `@deprecation` console warning
+> (`"application has not enabled bookmarks, this will not work in the future"`). This
+> fallback is deprecated and will be removed — always call `enableBookmark` in apps that
+> use bookmarks.
+
 ## useBookmark (Deprecated)
 
 > [!CAUTION]

package/docs/context.md

@@ -29,12 +29,14 @@ Returns the currently selected context from the application-scoped context modul
 ```ts
 function useCurrentContext(): {
   currentContext: ContextItem | null | undefined;
-  setCurrentContext: (context?: ContextItem | string | null) => void;
+  setCurrentContext: (context?: ContextItem | string | null) => void | Promise<ContextItem | null>;
 };
 ```
 
 **Returns:** An object with the current context (`ContextItem | null | undefined`) and a setter to change it.
 
+`setCurrentContext` clears the context when called with no argument (or `null`), resolves an item by `id` when given a `string`, or sets the given `ContextItem` directly. Clearing returns `void`; setting by `id` or by item returns a `Promise` that resolves once the switch completes — `await` it when you need to know the new context has taken effect (e.g. before navigating).
+
 ### Example
 
 ```tsx

package/docs/framework.md

@@ -31,11 +31,11 @@ Use this when your app hasn't configured its own context module but still needs
 ```ts
 function useFrameworkCurrentContext(): {
   currentContext: ContextItem | undefined;
-  setCurrentContext: (entry?: ContextItem | string | null) => void;
+  setCurrentContext: (entry?: ContextItem | string | null) => void | Promise<ContextItem | null>;
 };
 ```
 
-**Returns:** An object with `currentContext` (the portal's active context, or `undefined` if none is selected) and `setCurrentContext` to change it.
+**Returns:** An object with `currentContext` (the portal's active context, or `undefined` if none is selected) and `setCurrentContext` to change it. Clearing (no argument or `null`) returns `void`; setting by `id` or by item returns a `Promise` that resolves once the switch completes.
 
 **Example:**
 

package/docs/msal.md

@@ -116,7 +116,7 @@ const TokenInfo = () => {
   return (
     <div>
       <p>Access Token: {token.accessToken.substring(0, 20)}...</p>
-      <p>Expires: {new Date(token.expiresOn).toLocaleString()}</p>
+      <p>Expires: {token.expiresOn?.toLocaleString() ?? 'unknown'}</p>
       <p>Token Type: {token.tokenType}</p>
       <p>Scope: {token.scopes.join(', ')}</p>
     </div>
@@ -134,8 +134,8 @@ const TokenInfo = () => {
 
 **Note:** The `AuthenticationResult` type includes:
 - `accessToken: string`
-- `account: AccountInfo`
-- `expiresOn: Date`
+- `account: AccountInfo | null`
+- `expiresOn: Date | null`
 - `tokenType: string`
 - `scopes: string[]`
 - And more...

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@equinor/fusion-framework-react-app",
-  "version": "14.0.1",
+  "version": "15.0.0-next.0",
   "description": "",
+  "type": "module",
   "main": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {
@@ -131,44 +132,51 @@
     "directory": "packages/react"
   },
   "dependencies": {
-    "@equinor/fusion-framework-module-app": "8.0.4",
-    "@equinor/fusion-framework-module-http": "8.0.5",
-    "@equinor/fusion-framework-module": "6.1.2",
-    "@equinor/fusion-framework-react": "8.0.1",
-    "@equinor/fusion-framework-app": "13.0.1",
-    "@equinor/fusion-framework-module-navigation": "7.0.7",
-    "@equinor/fusion-framework-react-module": "4.0.2",
-    "@equinor/fusion-framework-react-module-http": "11.0.1"
+    "@equinor/fusion-framework": "8.1.0-next.0",
+    "@equinor/fusion-framework-module": "6.1.3-next.0",
+    "@equinor/fusion-framework-module-http": "8.1.0-next.0",
+    "@equinor/fusion-framework-module-navigation": "7.0.8-next.0",
+    "@equinor/fusion-framework-react": "9.0.0-next.0",
+    "@equinor/fusion-framework-app": "14.0.0-next.0",
+    "@equinor/fusion-framework-react-module": "4.0.3-next.0",
+    "@equinor/fusion-framework-module-app": "8.1.0-next.0",
+    "@equinor/fusion-framework-react-module-http": "12.0.0-next.0"
   },
   "devDependencies": {
-    "@testing-library/react": "^16.0.0",
+    "@remix-run/router": "^1.23.3",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
-    "happy-dom": "^20.8.4",
+    "@vitest/browser-playwright": "^4.1.0",
+    "playwright": "^1.62.1",
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
     "rxjs": "^7.8.1",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.0",
-    "@equinor/fusion-framework-module-ag-grid": "37.0.1",
-    "@equinor/fusion-framework-module-analytics": "3.0.6",
-    "@equinor/fusion-framework-module-event": "6.0.1",
-    "@equinor/fusion-framework-module-feature-flag": "2.0.3",
-    "@equinor/fusion-framework-module-state": "^2.0.0",
-    "@equinor/fusion-framework-module-msal": "10.0.2",
-    "@equinor/fusion-framework-react-module-bookmark": "6.0.1",
-    "@equinor/fusion-framework-react-module-context": "7.0.2",
-    "@equinor/fusion-framework-react-router": "2.4.0",
-    "@equinor/fusion-observable": "9.1.1"
+    "vitest": "^4.1.10",
+    "vitest-browser-react": "^2.2.0",
+    "@equinor/fusion-framework-module-ag-grid": "37.0.2-next.0",
+    "@equinor/fusion-framework-module-analytics": "3.1.0-next.0",
+    "@equinor/fusion-framework-module-bookmark": "4.1.0-next.0",
+    "@equinor/fusion-framework-module-context": "9.0.0-next.0",
+    "@equinor/fusion-framework-module-event": "6.1.0-next.0",
+    "@equinor/fusion-framework-module-feature-flag": "2.1.0-next.0",
+    "@equinor/fusion-framework-module-msal": "11.0.0-next.0",
+    "@equinor/fusion-framework-module-telemetry": "8.0.0-next.0",
+    "@equinor/fusion-framework-react-module-bookmark": "7.0.0-next.0",
+    "@equinor/fusion-framework-module-state": "^2.0.1-next.0",
+    "@equinor/fusion-framework-react-module-context": "7.0.3-next.0",
+    "@equinor/fusion-observable": "9.1.2-next.0",
+    "@equinor/fusion-framework-react-router": "2.4.1-next.0",
+    "@equinor/fusion-framework-vitest-plugin-react-app": "0.2.0-next.0"
   },
   "peerDependencies": {
     "@types/react": "^18.0.0 || ^19.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "rxjs": "^7.0.0",
-    "@equinor/fusion-framework-module-msal": "^10.0.2",
-    "@equinor/fusion-framework-react-router": "^2.4.0",
-    "@equinor/fusion-framework-module-state": "^2.0.0"
+    "@equinor/fusion-framework-module-msal": "^11.0.0-next.0",
+    "@equinor/fusion-framework-module-state": "^2.0.1-next.0",
+    "@equinor/fusion-framework-react-router": "^2.4.1-next.0"
   },
   "peerDependenciesMeta": {
     "@equinor/fusion-framework-react-module-ag-grid": {

package/src/__tests__/Apploader.test.tsx

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppManifest, AppModule } from '@equinor/fusion-framework-module-app';
+
+import { Apploader } from '../apploader/Apploader';
+import { renderAppComponent } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+// resolved from this test file rather than hardcoded, so it survives a package move
+const fixturesUri = new URL('./fixtures', import.meta.url).pathname;
+
+describe('Apploader', () => {
+  it('mounts the child app’s rendered content once its script loads', async () => {
+    const manifest: AppManifest = {
+      appKey: 'child-app',
+      displayName: 'Child App',
+      description: 'A child application',
+      type: 'standalone',
+      build: { version: '1.0.0', entryPoint: 'apploader-child-script.ts', assetPath: '' },
+    };
+
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, { manifest }, fixturesUri),
+    );
+
+    const { container } = await renderAppComponent(<Apploader appKey="child-app" />, { fusion });
+
+    // the loading state renders synchronously, before the script's dynamic import resolves
+    expect(container.textContent).toContain('Loading child-app');
+    await vi.waitFor(() => expect(container.textContent).toContain('mounted: child-app'));
+  });
+
+  it('surfaces the load error instead of throwing when the app’s script fails to import', async () => {
+    const manifest: AppManifest = {
+      appKey: 'broken-app',
+      displayName: 'Broken App',
+      description: 'An application whose build entry point does not exist',
+      type: 'standalone',
+      build: { version: '1.0.0', entryPoint: 'does-not-exist.ts', assetPath: '' },
+    };
+
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, { manifest }, fixturesUri),
+    );
+
+    const { container } = await renderAppComponent(<Apploader appKey="broken-app" />, { fusion });
+
+    await vi.waitFor(() => expect(container.textContent).toContain('Error loading broken-app'));
+  });
+});

package/src/__tests__/fixtures/apploader-child-script.ts

@@ -0,0 +1,9 @@
+import type { AppScriptModule } from '@equinor/fusion-framework-module-app';
+
+// a minimal stand-in for a real app bundle's entry point, dynamically imported by `App.initialize()`
+export const renderApp: AppScriptModule['renderApp'] = (el, { env }) => {
+  el.textContent = `mounted: ${env.manifest?.appKey}`;
+  return () => {
+    el.textContent = '';
+  };
+};

package/src/__tests__/testApp.test.tsx

@@ -0,0 +1,47 @@
+import { describe, expect } from 'vitest';
+
+import { enableContextMock } from '@equinor/fusion-framework-module-context/mock';
+import type { ContextItem } from '@equinor/fusion-framework-module-context';
+import { useCurrentContext } from '@equinor/fusion-framework-react-app/context';
+
+import { testApp } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const projectA: ContextItem = {
+  id: 'ctx-a',
+  title: 'Project A',
+  type: { id: 'ProjectMaster' },
+  value: {},
+};
+
+const Greeting = () => <p>hello</p>;
+
+const CurrentContext = () => {
+  const { currentContext } = useCurrentContext();
+  return <p>{currentContext?.title ?? 'none'}</p>;
+};
+
+describe('testApp', () => {
+  testApp(
+    'resolves a fusion/app scope and renders through the public /vitest entry point',
+    async ({ render, fusion, app }) => {
+      const screen = await render(<Greeting />);
+      await expect.element(screen.getByText('hello')).toBeVisible();
+      expect(fusion).toBeDefined();
+      expect(app).toBeDefined();
+    },
+  );
+
+  describe('with a seeded context module', () => {
+    const test = testApp.extend(
+      'configure',
+      { injected: true },
+      () => (configurator) =>
+        enableContextMock(configurator, (mock) => mock.setCurrentContext(projectA)),
+    );
+
+    test('starts on the seeded context', async ({ render }) => {
+      const screen = await render(<CurrentContext />);
+      await expect.element(screen.getByText(projectA.title as string)).toBeVisible();
+    });
+  });
+});

package/src/__tests__/useAccessToken.test.tsx

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+
+import { useAccessToken } from '../msal/useAccessToken';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+describe('useAccessToken', () => {
+  it('resolves an access token from the app scope’s real, mock-backed auth module', async () => {
+    // `renderAppHook` runs the real msal module against an in-process mock client,
+    // so `auth` behaves exactly as it would with a signed-in user in production.
+    const { result, unmount } = await renderAppHook(() =>
+      useAccessToken({ 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();
+    // a structurally valid JWT has three dot-separated segments
+    expect(result.current.token?.split('.')).toHaveLength(3);
+
+    // 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(
+      () => useAccessToken({ 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();
+  });
+});

package/src/__tests__/useAppSetting.test.tsx

@@ -0,0 +1,133 @@
+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 { useAppSetting } from '../settings/useAppSetting';
+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 `useAppSetting` 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;
+};
+
+describe('useAppSetting', () => {
+  it('resolves the persisted value for a single setting key', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark' });
+
+    const { result } = await renderAppHook(
+      () => useAppSetting<{ theme: string }, 'theme'>('theme'),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() => expect(result.current[0]).toBe('dark'));
+  });
+
+  it('falls back to the default value until the persisted settings resolve', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark' });
+
+    const { result } = await renderAppHook(
+      () => useAppSetting<{ theme: string }, 'theme'>('theme', 'light'),
+      { env, fusion },
+    );
+
+    expect(result.current[0]).toBe('light');
+    await vi.waitFor(() => expect(result.current[0]).toBe('dark'));
+  });
+
+  it('persists an updated value and notifies onUpdated', async () => {
+    const fusion = await mockSettingsFusion({ theme: 'dark' });
+    const onUpdated = vi.fn();
+
+    const { result } = await renderAppHook(
+      () => useAppSetting<{ theme: string }, 'theme'>('theme', undefined, { onUpdated }),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() => expect(result.current[0]).toBe('dark'));
+
+    act(() => {
+      result.current[1]('light');
+    });
+
+    await vi.waitFor(() => expect(result.current[0]).toBe('light'));
+    await vi.waitFor(() => expect(onUpdated).toHaveBeenCalled());
+  });
+
+  it('resolves the next value from the previous one when given an updater function', async () => {
+    const fusion = await mockSettingsFusion({ count: 1 });
+
+    const { result } = await renderAppHook(
+      () => useAppSetting<{ count: number }, 'count'>('count'),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() => expect(result.current[0]).toBe(1));
+
+    act(() => {
+      result.current[1]((current) => (current ?? 0) + 1);
+    });
+
+    await vi.waitFor(() => expect(result.current[0]).toBe(2));
+  });
+
+  it('surfaces a persistence failure through onError instead of throwing', async () => {
+    const fusion = await mockSettingsFusion(
+      { theme: 'dark' },
+      () => new Response(null, { status: 500 }),
+    );
+    const onError = vi.fn();
+
+    const { result } = await renderAppHook(
+      () => useAppSetting<{ theme: string }, 'theme'>('theme', undefined, { onError }),
+      { env, fusion },
+    );
+
+    await vi.waitFor(() => expect(result.current[0]).toBe('dark'));
+
+    act(() => {
+      result.current[1]('light');
+    });
+
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledWith(expect.any(Error)));
+  });
+});

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();
+  });
+});