feat(framework): expose .http, .services, .context and .telemetry on FrameworkMockConfigurator

Pin the four remaining built-in modules whose configure factories don't depend on ref, so their real configurators are reachable the same way .msal and .serviceDiscovery already are. event is deliberately left unpinned since its configure factory depends on ref for parent-scope event bubbling.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: odinr

.changeset/framework-mock-configurator-remaining-modules.md

@@ -0,0 +1,16 @@
+---
+"@equinor/fusion-framework": minor
+---
+
+Add `.http`, `.services`, `.context` and `.telemetry` accessors to `FrameworkMockConfigurator`, alongside the existing `.msal` and `.serviceDiscovery`.
+
+These four modules have no test double yet, so a client built through `.http`, or anything read through `.services`, `.context` or `.telemetry`, still performs real I/O — but their configurators are now reachable synchronously the same way `.msal` and `.serviceDiscovery` already are, since none of their `configure` factories depend on `ref`:
+
+```typescript
+const configurator = new FrameworkMockConfigurator();
+configurator.http.configureClient('my-api', { baseUri: 'http://localhost:6669' });
+
+const fusion = await init(configurator);
+```
+
+`event` is intentionally left out: its `configure` factory reads `ref` to wire event bubbling to a parent event provider when `FrameworkMockConfigurator` is hoisted inside a host framework, and pinning it would call `configure()` with `ref` always `undefined` — silently disabling that bubbling.

packages/framework/docs/testing-extending.md

@@ -62,4 +62,6 @@ class AppMockConfigurator extends FrameworkMockConfigurator<[InvoiceModule]> {
 
 ## What is not covered yet
 
-The `http`, `services`, `context` and `telemetry` modules initialize but are not yet backed by test doubles, so anything issuing an actual request still reaches the network. Adding one means creating a `src/mock/` folder in **that module**, then pinning its configurator with `_pin` and exposing it with `_getConfig` on `FrameworkMockConfigurator` — the two lines the built-in mocks already use.
+`.http`, `.services`, `.context` and `.telemetry` are already reachable on `FrameworkMockConfigurator` — their `configure` factories take no `ref`, so they were safe to pin the same way `.msal` and `.serviceDiscovery` are. What is missing is a test double behind them: none of the four modules has a `src/mock/` folder yet, so anything issuing an actual request through them still reaches the network. Adding one means creating that folder in **that module**, then pinning its mock configurator with `_pin` and exposing it with `_getConfig` on `FrameworkMockConfigurator`, replacing the real module descriptor pinned there today.
+
+`event` is not pinned at all, deliberately: its `configure` factory reads `ref` to wire event bubbling to a parent event provider when `FrameworkMockConfigurator` is hoisted inside a host framework. Pinning would call `configure()` with `ref` always `undefined`, silently breaking that bubbling — so it is left to build the normal way, from the module system's own configure phase, where `ref` is actually known.

packages/framework/src/__tests__/mock/mock-framework.test.ts

@@ -161,6 +161,34 @@ describe('FrameworkMockConfigurator', () => {
     expect(configurator.addModule(() => undefined)).toBe(configurator);
   });
 
+  it('exposes the same http configurator the http module is built from', async () => {
+    const configurator = new FrameworkMockConfigurator();
+
+    configurator.http.configureClient('my-api', { baseUri: 'http://localhost:6669' });
+
+    const fusion = await init(configurator);
+
+    expect(fusion.modules.http.createClient('my-api')).toBeDefined();
+  });
+
+  it('exposes the same services configurator the services module is built from', () => {
+    const configurator = new FrameworkMockConfigurator();
+
+    expect(configurator.services).toBeDefined();
+  });
+
+  it('exposes the same context configurator the context module is built from', () => {
+    const configurator = new FrameworkMockConfigurator();
+
+    expect(configurator.context).toBeDefined();
+  });
+
+  it('exposes the same telemetry configurator the telemetry module is built from', () => {
+    const configurator = new FrameworkMockConfigurator();
+
+    expect(configurator.telemetry).toBeDefined();
+  });
+
   it('lets a module supplied through TModules get the same kind of accessor as msal and serviceDiscovery', async () => {
     // Standing in for an application subclassing FrameworkMockConfigurator to
     // expose its own module the same way the built-ins are exposed.

packages/framework/src/mock/FrameworkMockConfigurator.ts

@@ -1,5 +1,10 @@
 import type { AnyModule } from '@equinor/fusion-framework-module';
 
+import contextModule, {
+  type ContextModuleConfigurator,
+} from '@equinor/fusion-framework-module-context';
+import httpModule, { type IHttpClientConfigurator } from '@equinor/fusion-framework-module-http';
+import type { HttpClientMsal } from '@equinor/fusion-framework-module-http/client';
 import {
   msalMockModule,
   type MsalMockConfigurator,
@@ -8,21 +13,36 @@ import {
   serviceDiscoveryMockModule,
   type ServiceDiscoveryMockConfigurator,
 } from '@equinor/fusion-framework-module-service-discovery/mock';
+import servicesModule, { type IApiConfigurator } from '@equinor/fusion-framework-module-services';
+import telemetryModule, {
+  type ITelemetryConfigurator,
+} from '@equinor/fusion-framework-module-telemetry';
 
 import { FrameworkConfigurator } from '../FrameworkConfigurator.js';
 
 /**
  * The real framework configurator, with every built-in module that reaches
- * outside the process backed by a test double.
+ * outside the process backed by a test double, and every other built-in
+ * module reachable the same way.
  *
  * @remarks
  * Nothing else changes: the same module set, the same configuration pipeline and
  * the same lifecycle are used. Only the boundaries that would need credentials or
  * network access are substituted, so a test still exercises module wiring,
  * configuration validation and lifecycle hooks.
  *
- * Each substituted module exposes its own mock configurator as a property, so a
- * test reaches it directly instead of registering a callback to receive it.
+ * Every built-in module exposes its own configurator as a property, so a test
+ * reaches it directly instead of registering a callback to receive it. `http`,
+ * `services`, `context` and `telemetry` are not backed by test doubles yet, so
+ * calls through their configurators still reach the network — but the
+ * configurators themselves are reachable the same way `.msal` is, since their
+ * `configure` factories take no `ref` and so lose nothing by being pinned
+ * early.
+ *
+ * `event` is deliberately not pinned: its `configure` factory reads `ref` to
+ * wire bubbling to a parent event provider when this configurator is hoisted
+ * inside a host framework, and pinning would freeze that decision before a
+ * `ref` could ever be known.
  *
  * Because this *is* a `FrameworkConfigurator`, every `enableX` helper an
  * application already uses accepts it unchanged — including the ones an
@@ -54,12 +74,15 @@ export class FrameworkMockConfigurator<
   constructor() {
     super();
 
-    // Pinning the built-in mocks up front — rather than waiting for `.msal` or
-    // `.serviceDiscovery` to be read — is what replaces the real `auth` and
-    // `serviceDiscovery` modules registered by `FrameworkConfigurator`'s own
-    // constructor, whether or not a test ever touches the accessor.
+    // Pinning up front — rather than waiting for an accessor to be read — is
+    // what replaces the modules `FrameworkConfigurator`'s own constructor
+    // already registered, whether or not a test ever touches the accessor.
     this._pin(msalMockModule);
     this._pin(serviceDiscoveryMockModule);
+    this._pin(httpModule);
+    this._pin(servicesModule);
+    this._pin(contextModule);
+    this._pin(telemetryModule);
   }
 
   /**
@@ -147,6 +170,48 @@ export class FrameworkMockConfigurator<
     return this._getConfig<ServiceDiscoveryMockConfigurator>(serviceDiscoveryMockModule.name);
   }
 
+  /**
+   * Configures the HTTP module's named clients.
+   *
+   * @remarks
+   * The real configurator — `http` has no test double yet, so this still
+   * reaches the network unless a test also gives the client in question its
+   * own `setClient` seam.
+   */
+  public get http(): IHttpClientConfigurator<HttpClientMsal> {
+    return this._getConfig<IHttpClientConfigurator<HttpClientMsal>>(httpModule.name);
+  }
+
+  /**
+   * Configures the typed API clients the `services` module builds.
+   *
+   * @remarks
+   * The real configurator — `services` has no test double yet.
+   */
+  public get services(): IApiConfigurator {
+    return this._getConfig<IApiConfigurator>(servicesModule.name);
+  }
+
+  /**
+   * Configures context resolution.
+   *
+   * @remarks
+   * The real configurator — `context` has no test double yet.
+   */
+  public get context(): ContextModuleConfigurator {
+    return this._getConfig<ContextModuleConfigurator>(contextModule.name);
+  }
+
+  /**
+   * Configures telemetry.
+   *
+   * @remarks
+   * The real configurator — `telemetry` has no test double yet.
+   */
+  public get telemetry(): ITelemetryConfigurator {
+    return this._getConfig<ITelemetryConfigurator>(telemetryModule.name);
+  }
+
   /**
    * Registers a module through its own enabler.
    *