@equinor/fusion-framework-app 13.0.0 → 14.0.0-next.0

package/src/__tests__/mock/AppMockConfigurator.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+
+import { AppConfig } from '@equinor/fusion-framework-module-app';
+import { enableTelemetry } from '@equinor/fusion-framework-module-telemetry';
+
+import { AppConfigurator } from '../../AppConfigurator.js';
+import { AppMockConfigurator } from '../../mock/AppMockConfigurator.js';
+
+const mockEnv = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+    build: {
+      version: '1.0.0',
+      entryPoint: 'index.js',
+    },
+  },
+};
+
+describe('AppMockConfigurator', () => {
+  it('is a real AppConfigurator', () => {
+    const configurator = new AppMockConfigurator(mockEnv);
+
+    expect(configurator).toBeInstanceOf(AppMockConfigurator);
+    expect(configurator).toBeInstanceOf(AppConfigurator);
+  });
+
+  it('constructs without throwing when env.config declares endpoints', async () => {
+    // the base AppConfigurator constructor auto-registers these via addConfig,
+    // before this class's own fields (#pinnedModules) are initialized
+    const env = {
+      ...mockEnv,
+      config: new AppConfig({
+        endpoints: { status: { url: 'https://status.example.com', scopes: [] } },
+      }),
+    };
+
+    const configurator = new AppMockConfigurator(env);
+    configurator.http.addMiddleware(async (uri, init, next) =>
+      uri === 'https://status.example.com/health' ? Response.json({ ok: true }) : next(uri, init),
+    );
+
+    enableTelemetry(configurator);
+    const modules = await configurator.initialize();
+
+    await expect(modules.http.createClient('status').json('/health')).resolves.toEqual({
+      ok: true,
+    });
+  });
+
+  it('exposes the same http configurator the http module is built from', async () => {
+    const configurator = new AppMockConfigurator(mockEnv);
+
+    configurator.http.configureClient('catalog', { baseUri: 'https://api.example.com' });
+    configurator.http.addMiddleware(async (uri, init, next) =>
+      uri === 'https://api.example.com/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+    );
+
+    // msal's config schema requires a telemetry module, normally wired by configureModules
+    enableTelemetry(configurator);
+    const modules = await configurator.initialize();
+
+    await expect(modules.http.createClient('catalog').json('/items')).resolves.toEqual([{ id: 1 }]);
+  });
+
+  it('exposes the same msal configurator the auth module is built from', async () => {
+    const configurator = new AppMockConfigurator(mockEnv);
+
+    configurator.msal.setAccount({ name: 'Ada Lovelace' });
+
+    // msal's config schema requires a telemetry module, normally wired by configureModules
+    enableTelemetry(configurator);
+    const modules = await configurator.initialize();
+
+    expect(modules.auth.account?.name).toBe('Ada Lovelace');
+  });
+
+  it('answers a client registered through configureHttpClient via addMiddleware', async () => {
+    const configurator = new AppMockConfigurator(mockEnv);
+
+    configurator.configureHttpClient('status-api', { baseUri: 'https://status.example.com' });
+    configurator.http.addMiddleware(async (uri, init, next) =>
+      uri === 'https://status.example.com/status' ? Response.json({ ok: true }) : next(uri, init),
+    );
+
+    // msal's config schema requires a telemetry module, normally wired by configureModules
+    enableTelemetry(configurator);
+    const modules = await configurator.initialize();
+
+    await expect(modules.http.createClient('status-api').json('/status')).resolves.toEqual({
+      ok: true,
+    });
+  });
+});

package/src/__tests__/mock/mock-app.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Fusion } from '@equinor/fusion-framework';
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { AppConfig, type AppModule } from '@equinor/fusion-framework-module-app';
+
+import { AppMockConfigurator } from '../../mock/AppMockConfigurator.js';
+import { mockAppModules } from '../../mock/mock-app-modules.js';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+    build: {
+      version: '1.0.0',
+      entryPoint: 'index.js',
+    },
+  },
+  config: new AppConfig({ environment: { foo: 'bar' } }),
+};
+
+describe('mockApp', () => {
+  it('initializes the app module pipeline with no configuration', async () => {
+    const modules = await mockAppModules(undefined, env);
+
+    expect(modules.event).toBeDefined();
+    expect(modules.auth).toBeDefined();
+    expect(modules.http).toBeDefined();
+  });
+
+  it('passes a real AppConfigurator to the callback', async () => {
+    expect.assertions(1);
+
+    await mockAppModules((configurator) => {
+      expect(configurator).toBeInstanceOf(AppMockConfigurator);
+    }, env);
+  });
+
+  it('answers a service-discovery-resolved client from the app’s own mocked http module', async () => {
+    const modules = await mockAppModules((configurator) => {
+      configurator.useFrameworkServiceClient('portal-api');
+      // matches against the full resolved URL, so the host is part of the match to keep this
+      // from also answering a different client's request
+      configurator.http.addMiddleware(async (uri, init, next) =>
+        uri === 'https://portal-api.fusion.test/items'
+          ? Response.json([{ id: 1 }])
+          : next(uri, init),
+      );
+    }, env);
+
+    await expect(modules.http.createClient('portal-api').json('/items')).resolves.toEqual([
+      { id: 1 },
+    ]);
+  });
+
+  it('reuses an already-mocked fusion instance instead of creating a new one', async () => {
+    expect.assertions(1);
+
+    const fusion = await mockFramework((configurator) => {
+      configurator.msal.setAccount({ name: 'Ada Lovelace' });
+    });
+
+    await mockAppModules(
+      (_configurator, { fusion: parent }) => {
+        expect(parent.modules.auth.account?.name).toBe('Ada Lovelace');
+      },
+      env,
+      fusion,
+    );
+  });
+
+  it('awaits an async configure callback before initialize resolves', async () => {
+    const modules = await mockAppModules(async (configurator) => {
+      await Promise.resolve();
+      configurator.msal.setAccount({ name: 'Ada Lovelace' });
+    }, env);
+
+    expect(modules.auth.account?.name).toBe('Ada Lovelace');
+  });
+
+  it('serves this app’s own manifest and config through the default parent’s app module', async () => {
+    expect.assertions(2);
+
+    await mockAppModules(async (_configurator, { fusion }) => {
+      // the default parent always has `app` enabled; typed as plain `Fusion` since callers
+      // may pass in a parent without it, so the module set is narrowed just for this assertion
+      const { app } = (fusion as Fusion<[AppModule]>).modules;
+      app.setCurrentApp(env.manifest.appKey);
+
+      await expect(app.current?.getManifestAsync()).resolves.toMatchObject({
+        appKey: env.manifest.appKey,
+        displayName: env.manifest.displayName,
+      });
+      await expect(app.current?.getConfigAsync()).resolves.toMatchObject({
+        environment: env.config.environment,
+      });
+    }, env);
+  });
+
+  it('falls through to the real client for a manifest not matching this app’s own', async () => {
+    expect.assertions(1);
+
+    await mockAppModules(async (_configurator, { fusion }) => {
+      const { app } = (fusion as Fusion<[AppModule]>).modules;
+      app.setCurrentApp('some-other-app');
+
+      await expect(app.current?.getManifestAsync()).rejects.toThrow();
+    }, env);
+  });
+});

package/src/__tests__/mock/msal-hoisting.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import type { AuthenticationResult } from '@equinor/fusion-framework-module-msal';
+
+import { mockAppModules } from '../../mock/mock-app-modules.js';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('msal hoisting', () => {
+  it('delegates acquireToken to the parent’s auth module instead of building its own client', async () => {
+    const fusion = await mockFramework();
+    const result = { accessToken: 'parent-issued-token' } as AuthenticationResult;
+    vi.spyOn(fusion.modules.auth, 'acquireToken').mockResolvedValue(result);
+
+    const modules = await mockAppModules(undefined, env, fusion);
+
+    // the app's own `auth` is a distinct (proxying) object, not the parent's instance itself
+    expect(modules.auth).not.toBe(fusion.modules.auth);
+    await expect(
+      modules.auth.acquireToken({ request: { scopes: ['User.Read'] } }),
+    ).resolves.toMatchObject({ accessToken: 'parent-issued-token' });
+  });
+
+  it('surfaces the parent’s acquisition failures instead of falling back to its own client', async () => {
+    const fusion = await mockFramework();
+    vi.spyOn(fusion.modules.auth, 'acquireToken').mockRejectedValue(
+      new Error('acquisition failed'),
+    );
+
+    const modules = await mockAppModules(undefined, env, fusion);
+
+    await expect(modules.auth.acquireToken({ request: { scopes: ['User.Read'] } })).rejects.toThrow(
+      'acquisition failed',
+    );
+  });
+
+  it('reflects the parent’s signed-in account rather than signing in its own', async () => {
+    const fusion = await mockFramework((configurator) => {
+      configurator.msal.setAccount({ name: 'Ada Lovelace' });
+    });
+
+    const modules = await mockAppModules(undefined, env, fusion);
+
+    expect(modules.auth.account?.name).toBe('Ada Lovelace');
+  });
+});

package/src/configure-modules.ts

@@ -7,14 +7,11 @@
 
 import type { Fusion } from '@equinor/fusion-framework';
 import type { AnyModule } from '@equinor/fusion-framework-module';
-import {
-  enableTelemetry,
-  type MetadataExtractor,
-} from '@equinor/fusion-framework-module-telemetry';
 
 import { AppConfigurator } from './AppConfigurator';
 
 import type { AppModulesInstance, AppModuleInitiator, AppEnv } from './types';
+import { initializeAppModules } from './initialize-app-modules';
 
 /**
  * Create an application module initializer for a Fusion application.
@@ -66,56 +63,9 @@ export const configureModules =
    * @returns The fully initialized application module instance.
    */
   async (args: { fusion: TRef; env: TEnv }): Promise<AppModulesInstance<TModules>> => {
-    const { fusion } = args;
-
     // Create app configurator
     const configurator = new AppConfigurator<TModules, TRef['modules'], TEnv>(args.env);
-
-    // Extract telemetry metadata from app manifest for tracking and debugging
-    const metadataExtractor: MetadataExtractor = () => {
-      return {
-        fusion: {
-          type: 'app-telemetry',
-          app: {
-            key: args.env.manifest?.appKey || 'unknown-app',
-            version: args.env.manifest?.build?.version || 'unknown-version',
-          },
-        },
-      };
-    };
-
-    // Enable telemetry collection for module configuration events
-    // attachConfiguratorEvents automatically prefixes events with configurator class name
-    enableTelemetry(configurator, {
-      attachConfiguratorEvents: true,
-      configure: (builder) => {
-        builder.setMetadata(metadataExtractor);
-        builder.setParent(fusion.modules.telemetry);
-        // Scope telemetry to 'app' level for app-specific event filtering
-        builder.setDefaultScope(['app']);
-      },
-    });
-
-    // Allow user configuration callback to run before module initialization
-    if (cb) {
-      await Promise.resolve(cb(configurator, args));
-    }
-    // Type cast is safe because AppConfigurator.initialize() returns the exact module
-    // instance that was registered and configured above. The intermediate 'unknown'
-    // cast is necessary due to TypeScript's generic inference limitations with the
-    // configurator's initialization chain, but the runtime value is guaranteed to match.
-    const modules: AppModulesInstance<TModules> = (await configurator.initialize(
-      args.fusion.modules,
-    )) as unknown as AppModulesInstance<TModules>;
-
-    // Dispatch app modules loaded event for app lifecycle tracking
-    // TODO(#5061): remove check after fusion-cli is updated (app module is not enabled in fusion-cli)
-    if (args.env.manifest?.appKey) {
-      modules.event.dispatchEvent('onAppModulesLoaded', {
-        detail: { appKey: args.env.manifest.appKey, manifest: args.env.manifest, modules },
-      });
-    }
-    return modules;
+    return initializeAppModules(configurator, cb, args);
   };
 
 export default configureModules;

package/src/initialize-app-modules.ts

@@ -0,0 +1,98 @@
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+import {
+  enableTelemetry,
+  type MetadataExtractor,
+} from '@equinor/fusion-framework-module-telemetry';
+
+import type { AppConfigurator } from './AppConfigurator';
+import type { AppModulesInstance, AppEnv } from './types';
+
+/**
+ * Runs the telemetry wiring, the caller's configuration callback and module
+ * initialization against an already constructed configurator.
+ *
+ * @remarks
+ * Extracted so `mockAppModules` (`@equinor/fusion-framework-app/mock`) can drive the
+ * exact same pipeline against an `AppMockConfigurator` instead of reimplementing
+ * it — the same way `FrameworkConfigurator` and `FrameworkMockConfigurator`
+ * share the framework's `init`.
+ *
+ * @param configurator - The (real or mock) app configurator to run the pipeline on.
+ * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
+ * @param args - Object containing the Fusion instance and the application environment.
+ * @returns The fully initialized application module instance.
+ * @template TModules - Application module descriptors beyond the default set.
+ * @template TRef - The parent Fusion instance type.
+ * @template TEnv - The application environment descriptor.
+ * @template TConfigurator - The (real or mock) `AppConfigurator` subclass driving the pipeline.
+ */
+export async function initializeAppModules<
+  TModules extends Array<AnyModule> | never,
+  TRef extends Fusion = Fusion,
+  TEnv extends AppEnv = AppEnv,
+  // Widened beyond the plain `AppConfigurator` so callers such as `mockAppModules` can
+  // drive the same pipeline against a subclass (e.g. `AppMockConfigurator`) and have `cb`
+  // typed against that subclass rather than the base `IAppConfigurator` interface.
+  TConfigurator extends AppConfigurator<TModules, TRef['modules'], TEnv> = AppConfigurator<
+    TModules,
+    TRef['modules'],
+    TEnv
+  >,
+>(
+  configurator: TConfigurator,
+  cb:
+    | ((configurator: TConfigurator, args: { fusion: TRef; env: TEnv }) => void | Promise<void>)
+    | undefined,
+  args: { fusion: TRef; env: TEnv },
+): Promise<AppModulesInstance<TModules>> {
+  const { fusion } = args;
+
+  // Extract telemetry metadata from app manifest for tracking and debugging
+  const metadataExtractor: MetadataExtractor = () => {
+    return {
+      fusion: {
+        type: 'app-telemetry',
+        app: {
+          key: args.env.manifest?.appKey || 'unknown-app',
+          version: args.env.manifest?.build?.version || 'unknown-version',
+        },
+      },
+    };
+  };
+
+  // Enable telemetry collection for module configuration events
+  // attachConfiguratorEvents automatically prefixes events with configurator class name
+  enableTelemetry(configurator, {
+    attachConfiguratorEvents: true,
+    configure: (builder) => {
+      builder.setMetadata(metadataExtractor);
+      builder.setParent(fusion.modules.telemetry);
+      // Scope telemetry to 'app' level for app-specific event filtering
+      builder.setDefaultScope(['app']);
+    },
+  });
+
+  // Allow user configuration callback to run before module initialization
+  if (cb) {
+    await Promise.resolve(cb(configurator, args));
+  }
+  // Type cast is safe because AppConfigurator.initialize() returns the exact module
+  // instance that was registered and configured above. The intermediate 'unknown'
+  // cast is necessary due to TypeScript's generic inference limitations with the
+  // configurator's initialization chain, but the runtime value is guaranteed to match.
+  const modules: AppModulesInstance<TModules> = (await configurator.initialize(
+    args.fusion.modules,
+  )) as unknown as AppModulesInstance<TModules>;
+
+  // Dispatch app modules loaded event for app lifecycle tracking
+  // TODO(#5061): remove check after fusion-cli is updated (app module is not enabled in fusion-cli)
+  if (args.env.manifest?.appKey) {
+    modules.event.dispatchEvent('onAppModulesLoaded', {
+      detail: { appKey: args.env.manifest.appKey, manifest: args.env.manifest, modules },
+    });
+  }
+  return modules;
+}
+
+export default initializeAppModules;

package/src/mock/AppMockConfigurator.ts

@@ -0,0 +1,218 @@
+import type { FusionModulesInstance } from '@equinor/fusion-framework';
+
+import type {
+  AnyModule,
+  IModuleConfigurator,
+  ModuleConfigType,
+} from '@equinor/fusion-framework-module';
+
+import http, { type IHttpClientConfigurator } from '@equinor/fusion-framework-module-http';
+import {
+  msalMockModule,
+  type MsalMockConfigurator,
+} from '@equinor/fusion-framework-module-msal/mock';
+
+import { AppConfigurator } from '../AppConfigurator.js';
+import type { AppEnv } from '../types.js';
+
+/**
+ * The real `AppConfigurator`, with the `msal` module it registers backed by
+ * the same test double `FrameworkMockConfigurator` uses. `http` is the real
+ * module — fake a response by registering a short-circuiting middleware
+ * through `.http.addMiddleware(...)` instead of swapping the module out.
+ *
+ * @remarks
+ * Nothing else changes: the same module set (`event`, `http`, `msal`), the same
+ * configuration pipeline and the same lifecycle are used. `configureHttpClient`,
+ * `useFrameworkServiceClient` and any callback written for a real
+ * `AppConfigurator` work against this unchanged.
+ *
+ * `http` and `msal` are pinned early — mirroring `FrameworkMockConfigurator`,
+ * one level down — so `.http` and `.msal` are reachable synchronously, before
+ * `useFrameworkServiceClient` or a `configureModules` callback ever runs.
+ * `event` is deliberately not pinned, for the same reason it isn't in
+ * `FrameworkMockConfigurator`: its `configure` factory reads `ref` to wire
+ * bubbling to a parent event provider, and pinning would freeze that decision
+ * before a `ref` could ever be known.
+ *
+ * @typeParam TModules - Module descriptors beyond the default set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @typeParam TRef - The resolved Fusion modules instance used as a reference during initialization.
+ * @typeParam TEnv - The application environment descriptor.
+ *
+ * @example
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const configurator = new AppMockConfigurator({ manifest });
+ *
+ * configurator.configureHttpClient('catalog', { baseUri: 'https://api.example.com' });
+ * configurator.http.addMiddleware(async (uri, init, next) =>
+ *   uri === 'https://api.example.com/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+ * );
+ * ```
+ */
+export class AppMockConfigurator<
+  TModules extends Array<AnyModule> | unknown = unknown,
+  TRef extends FusionModulesInstance = FusionModulesInstance,
+  TEnv extends AppEnv = AppEnv,
+> extends AppConfigurator<TModules, TRef, TEnv> {
+  static override readonly className: string = 'AppMockConfigurator';
+
+  // Keyed by module name, so `_getConfig` can look a pinned configurator up
+  // without needing the module descriptor again.
+  #configurators = new Map<string, unknown>();
+
+  // Keyed by module name, so `addConfig` can redirect a registration at the
+  // pinned descriptor instead of the unpinned one it was given.
+  #pinnedModules = new Map<string, AnyModule>();
+
+  /**
+   * Creates an app configurator backed by the built-in mock modules.
+   *
+   * @param env - The application environment containing manifest, config, and optional basename.
+   */
+  constructor(env: TEnv) {
+    super(env);
+
+    // Pinning up front replaces the modules AppConfigurator's own constructor
+    // already registered, whether or not a test ever touches the accessor.
+    this._pin(http);
+    this._pin(msalMockModule);
+
+    // deferred from AppConfigurator's own constructor (see the override below) until
+    // after pinning, so endpoint-derived clients register against the pinned http module
+    super._configureHttpClientsFromAppConfig();
+  }
+
+  /**
+   * No-ops the base constructor's own call to this, since it would otherwise run
+   * before {@link _pin} has anything to redirect `addConfig` at; this class calls
+   * {@link AppConfigurator._configureHttpClientsFromAppConfig} itself once pinned.
+   */
+  protected override _configureHttpClientsFromAppConfig(): void {}
+
+  /**
+   * Registers a module configurator, redirecting registrations for a pinned module
+   * at its pinned descriptor.
+   *
+   * @remarks
+   * `configureHttpClient`, `useFrameworkServiceClient` and similar helpers always
+   * pass the real, unpinned module descriptor — the base `addConfig` replaces a
+   * module's descriptor whenever it doesn't recognize the object it's given, even
+   * under the same name, which would otherwise silently un-pin it.
+   *
+   * @param config - The module configurator descriptor to register.
+   * @template T - The module type being configured.
+   * @template TConfig - The resolved configuration type for the module.
+   */
+  public override addConfig<T extends AnyModule, TConfig = ModuleConfigType<T>>(
+    config: IModuleConfigurator<T, TRef, TConfig>,
+  ): void {
+    const pinnedModule = this.#pinnedModules.get(config.module.name) as T | undefined;
+    super.addConfig(pinnedModule ? { ...config, module: pinnedModule } : config);
+  }
+
+  /**
+   * Pins a module to a single configurator instance for the lifetime of this
+   * configurator, so it can be reached by name through {@link _getConfig}.
+   *
+   * @remarks
+   * The module system otherwise builds a fresh configurator from its own
+   * `configure` factory during the configure phase — too late for a test to
+   * reach, and a new instance on every call besides. This replaces that factory
+   * with one that always returns the same instance, and registers the result
+   * under the module's own name.
+   *
+   * An application module supplied through {@link TModules} uses this the same
+   * way `.http` and `.msal` do, to expose its own named accessor:
+   *
+   * ```typescript
+   * class MyAppMockConfigurator extends AppMockConfigurator<[WidgetsModule]> {
+   *   constructor(env: AppEnv) {
+   *     super(env);
+   *     this._pin(widgetsMockModule);
+   *   }
+   *
+   *   public get widgets(): WidgetsMockConfigurator {
+   *     return this._getConfig('widgets');
+   *   }
+   * }
+   * ```
+   *
+   * @param module - The module descriptor to pin a configurator for.
+   * @template TModule - The specific module descriptor type being pinned.
+   * @throws {Error} If the module declares no `configure` factory to pin, or
+   *   the factory returns a promise instead of a configurator — pinning is
+   *   synchronous, so a test can reach the accessor immediately.
+   */
+  protected _pin<TModule extends AnyModule>(module: TModule): void {
+    // A module without a configure factory has nothing this method could pin
+    if (!module.configure) {
+      throw new Error(`Cannot pin "${module.name}": it declares no configure factory.`);
+    }
+    const instance = module.configure();
+    // Async factories would make the pinned instance unavailable until the module system
+    // resolves it later, defeating the point of pinning it for immediate synchronous access
+    if (instance instanceof Promise) {
+      throw new Error(
+        `Cannot pin "${module.name}": its configure factory returns a promise, so it cannot be resolved synchronously.`,
+      );
+    }
+    this.#configurators.set(module.name, instance);
+    const pinnedModule = { ...module, configure: () => instance } as TModule;
+    this.#pinnedModules.set(module.name, pinnedModule);
+    this.addConfig({ module: pinnedModule });
+  }
+
+  /**
+   * Returns the configurator pinned for a module by name.
+   *
+   * @param name - The module's name, as passed to {@link _pin}.
+   * @template TConfig - The specific configurator type expected for this module.
+   * @returns The configurator pinned under `name`.
+   * @throws {Error} If no configurator has been pinned for that name.
+   */
+  protected _getConfig<TConfig>(name: string): TConfig {
+    const config = this.#configurators.get(name);
+    // A missing entry means _pin was never called for this module name
+    if (config === undefined) {
+      throw new Error(
+        `No configurator is pinned for module "${name}" — call this._pin(module) before this._getConfig("${name}").`,
+      );
+    }
+    return config as TConfig;
+  }
+
+  /**
+   * Configures the app's named HTTP clients.
+   *
+   * @remarks
+   * The same {@link IHttpClientConfigurator} the `http` module is configured
+   * from — the real one, not a test double. Every client it builds —
+   * including ones registered through
+   * {@link AppConfigurator.configureHttpClient} or
+   * {@link AppConfigurator.useFrameworkServiceClient} — is reachable here to
+   * register a short-circuiting {@link HttpMiddleware} through
+   * `addMiddleware`, so it answers from that instead of the network.
+   *
+   * @returns The real HTTP configurator.
+   */
+  public get http(): IHttpClientConfigurator {
+    return this._getConfig<IHttpClientConfigurator>(http.name);
+  }
+
+  /**
+   * Configures the user the app's `msal` module signs in.
+   *
+   * @remarks
+   * The same {@link MsalMockConfigurator} the `msal` module is configured from,
+   * so a change made here is what the module sees.
+   *
+   * @returns The MSAL mock configurator.
+   */
+  public get msal(): MsalMockConfigurator {
+    return this._getConfig<MsalMockConfigurator>(msalMockModule.name);
+  }
+}
+
+export default AppMockConfigurator;