@equinor/fusion-framework 8.0.15 → 8.1.0-next.1

package/dist/esm/mock/FrameworkMockConfigurator.js

@@ -0,0 +1,233 @@
+import { contextMockModule, } from '@equinor/fusion-framework-module-context/mock';
+import { module as httpModule, } from '@equinor/fusion-framework-module-http';
+import { msalMockModule, } from '@equinor/fusion-framework-module-msal/mock';
+import { serviceDiscoveryMockModule, } from '@equinor/fusion-framework-module-service-discovery/mock';
+import servicesModule from '@equinor/fusion-framework-module-services';
+import { telemetryMockModule, } from '@equinor/fusion-framework-module-telemetry/mock';
+import { FrameworkConfigurator } from '../FrameworkConfigurator.js';
+/**
+ * The real framework configurator, with every built-in module that reaches
+ * 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.
+ *
+ * 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`
+ * is the real configurator — fake a response by registering a
+ * short-circuiting middleware through `.http.addMiddleware(...)` instead of
+ * swapping the module out; see `@equinor/fusion-framework-module-http/mock`'s
+ * `createOpenApiMockMiddleware` for faking a whole `@equinor/fusion-openapi-mock`
+ * document that way. `services` is not backed by a test double yet either, so
+ * calls through its configurator still reach the network — but
+ * the configurator itself is reachable the same way `.msal` is, since its
+ * `configure` factory takes no `ref` and so loses 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
+ * application team writes for their own modules.
+ *
+ * @typeParam TModules - Module descriptors beyond the built-in set. Supply this
+ *   when a test registers application modules, so they are typed on the resulting
+ *   instance.
+ *
+ * @example
+ * ```typescript
+ * const configurator = new FrameworkMockConfigurator();
+ *
+ * configurator.msal.setAccount({ name: 'Ada Lovelace' });
+ * configurator.serviceDiscovery.setBaseUri('http://localhost:6669');
+ *
+ * const fusion = await init(configurator);
+ * ```
+ */
+export class FrameworkMockConfigurator extends FrameworkConfigurator {
+    static className = 'FrameworkMockConfigurator';
+    // Keyed by module name, so `_getConfig` can look a pinned configurator up
+    // without needing the module descriptor again.
+    #configurators = new Map();
+    /**
+     * Creates a framework configurator backed by the built-in mock modules.
+     */
+    constructor() {
+        super();
+        // 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(contextMockModule);
+        this._pin(telemetryMockModule);
+    }
+    /**
+     * 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.
+     *
+     * A subclass registering a module supplied through {@link TModules} uses
+     * this the same way `.msal` and `.serviceDiscovery` do, to expose its own
+     * named accessor:
+     *
+     * ```typescript
+     * class MyMockConfigurator extends FrameworkMockConfigurator<[InvoiceModule]> {
+     *   constructor() {
+     *     super();
+     *     this._pin(invoiceMockModule);
+     *   }
+     *
+     *   public get invoices(): InvoiceMockConfigurator {
+     *     return this._getConfig('invoices');
+     *   }
+     * }
+     * ```
+     *
+     * @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.
+     */
+    _pin(module) {
+        // 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);
+        this.addConfig({ module: { ...module, configure: () => instance } });
+    }
+    /**
+     * 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.
+     */
+    _getConfig(name) {
+        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;
+    }
+    /**
+     * Configures the user the framework signs in.
+     *
+     * @remarks
+     * The same {@link MsalMockConfigurator} the auth module is configured from, so
+     * a change made here is what the module sees.
+     *
+     * @returns The MSAL mock configurator.
+     */
+    get msal() {
+        return this._getConfig(msalMockModule.name);
+    }
+    /**
+     * Configures the registry services are resolved from.
+     *
+     * @remarks
+     * The same {@link ServiceDiscoveryMockConfigurator} the service discovery
+     * module is configured from, so a change made here is what the module sees.
+     *
+     * @returns The service discovery mock configurator.
+     */
+    get serviceDiscovery() {
+        return this._getConfig(serviceDiscoveryMockModule.name);
+    }
+    /**
+     * Configures the HTTP module's named clients.
+     *
+     * @remarks
+     * The same {@link IHttpClientConfigurator} the HTTP module is configured
+     * from — the real one, not a test double. Register a short-circuiting
+     * {@link HttpMiddleware} through `addMiddleware` to answer from that
+     * instead of the network.
+     *
+     * @returns The real HTTP configurator.
+     */
+    get http() {
+        return this._getConfig(httpModule.name);
+    }
+    /**
+     * Configures the typed API clients the `services` module builds.
+     *
+     * @remarks
+     * The real configurator — `services` has no test double yet.
+     *
+     * @returns The real API configurator.
+     */
+    get services() {
+        return this._getConfig(servicesModule.name);
+    }
+    /**
+     * Configures context resolution.
+     *
+     * @remarks
+     * The same {@link ContextMockConfigurator} the context module is configured
+     * from, so seeding an item here is what `fusion.modules.context` resolves.
+     *
+     * @returns The context mock configurator.
+     */
+    get context() {
+        return this._getConfig(contextMockModule.name);
+    }
+    /**
+     * Configures telemetry.
+     *
+     * @remarks
+     * The same {@link TelemetryMockConfigurator} the telemetry module is
+     * configured from, so a tracked event or measurement can be read back from
+     * its adapter instead of reaching Application Insights.
+     *
+     * @returns The telemetry mock configurator.
+     */
+    get telemetry() {
+        return this._getConfig(telemetryMockModule.name);
+    }
+    /**
+     * Registers a module through its own enabler.
+     *
+     * @remarks
+     * Sugar for calling the enabler directly — `enableMyModuleMock(configurator)`
+     * works just as well, because this class *is* a `FrameworkConfigurator`. Use
+     * whichever reads better at the call site.
+     *
+     * @param configure - Callback receiving this configurator.
+     * @returns This configurator, for chaining.
+     *
+     * @example
+     * ```typescript
+     * configurator.addModule((c) => enableMyModuleMock(c, { total: 42 }));
+     * ```
+     */
+    addModule(configure) {
+        configure(this);
+        return this;
+    }
+}
+export default FrameworkMockConfigurator;
+//# sourceMappingURL=FrameworkMockConfigurator.js.map

package/dist/esm/mock/FrameworkMockConfigurator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameworkMockConfigurator.js","sourceRoot":"","sources":["../../../src/mock/FrameworkMockConfigurator.ts"],"names":[],"mappings":"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"}

package/dist/esm/mock/index.js

@@ -0,0 +1,32 @@
+/**
+ * Zero-configuration Fusion Framework instances for tests.
+ *
+ * @remarks
+ * Lets an application initialize the real framework — real modules, real
+ * configuration pipeline, real lifecycle — while the boundaries that reach
+ * outside the process are substituted with deterministic fakes. No credentials,
+ * no network access and no configuration are required.
+ *
+ * This entry point holds **no mock logic**. Each module owns and exports its own
+ * test double from its `./mock` entry point; this entry point only composes the
+ * built-in set into a ready-to-use instance. An application module follows the
+ * same pattern and plugs in identically.
+ *
+ * This entry point is test-runner agnostic: it contains no dependency on Vitest
+ * or any other test framework, so the same helpers work under any runner.
+ *
+ * Fixture generators with realistic fake data (e.g. `createContextItems`) live
+ * on each module's own `/mock/fixtures` entry point instead of here, since they
+ * pull in an extra dependency ({@link https://fakerjs.dev/ | faker}) that
+ * plain configurator mocking doesn't need.
+ *
+ * @packageDocumentation
+ */
+export { mockFramework } from './mock-framework.js';
+export { FrameworkMockConfigurator } from './FrameworkMockConfigurator.js';
+// Re-exported so a test can reach the built-in module mocks without importing
+// each module's `./mock` entry point directly. The mocks are owned by their modules.
+export { enableMsalMock, msalMockModule, MsalMockConfigurator, MsalMockClient, createMsalMockClient, createMockToken, } from '@equinor/fusion-framework-module-msal/mock';
+export { mockServiceDiscovery, enableServiceDiscoveryMock, serviceDiscoveryMockModule, ServiceDiscoveryMockClient, ServiceDiscoveryMockConfigurator, createMockService, defaultServiceDiscoveryMockServices, } from '@equinor/fusion-framework-module-service-discovery/mock';
+export { enableContextMock, contextMockModule, ContextMockConfigurator, } from '@equinor/fusion-framework-module-context/mock';
+//# sourceMappingURL=index.js.map

package/dist/esm/mock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mock/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,aAAa,EAAiC,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,8EAA8E;AAC9E,qFAAqF;AACrF,OAAO,EACL,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,eAAe,GAIhB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,iBAAiB,EACjB,mCAAmC,GAIpC,MAAM,yDAAyD,CAAC;AAEjE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,GAGxB,MAAM,+CAA+C,CAAC"}

package/dist/esm/mock/mock-framework.js

@@ -0,0 +1,55 @@
+import { init } from '../init.js';
+import { FrameworkMockConfigurator } from './FrameworkMockConfigurator.js';
+/**
+ * Starts a Fusion framework instance that needs no credentials and no network.
+ *
+ * @remarks
+ * The real framework is started: the real module set, the real configuration
+ * pipeline and the real lifecycle. Only the boundaries that would need
+ * credentials or network access are substituted, so a test exercises the wiring
+ * an application actually depends on rather than a reimplementation of it.
+ *
+ * The configurator passed to `configure` is a {@link FrameworkMockConfigurator},
+ * which *is* a `FrameworkConfigurator`. Every `enableX` helper therefore accepts
+ * it unchanged — including the ones an application team writes for their own
+ * modules.
+ *
+ * Spying on individual calls is left to the test runner. The framework makes the
+ * runtime substitutable; `vi.spyOn`, `bun:test` `spyOn` and `t.mock.method` all
+ * work against the resulting instance with no framework support.
+ *
+ * @typeParam TModules - Module descriptors beyond the built-in set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @template TModules - Module descriptors beyond the built-in set.
+ * @param configure - Callback that configures the framework before it starts.
+ * @returns The initialized framework instance.
+ *
+ * @example Zero configuration
+ * ```typescript
+ * const fusion = await mockFramework();
+ * ```
+ *
+ * @example Configure the built-in mocks
+ * ```typescript
+ * const fusion = await mockFramework((configurator) => {
+ *   configurator.msal.setAccount({ name: 'Ada Lovelace' });
+ *   configurator.serviceDiscovery.setBaseUri('http://localhost:6669');
+ * });
+ * ```
+ *
+ * @example Register an application module
+ * ```typescript
+ * const fusion = await mockFramework<[InvoiceModule]>((configurator) => {
+ *   enableInvoicesMock(configurator, { total: 42 });
+ * });
+ *
+ * await fusion.modules.invoices.getInvoice('1');
+ * ```
+ */
+export async function mockFramework(configure) {
+    const configurator = new FrameworkMockConfigurator();
+    await configure?.(configurator);
+    return await init(configurator);
+}
+export default mockFramework;
+//# sourceMappingURL=mock-framework.js.map

package/dist/esm/mock/mock-framework.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-framework.js","sourceRoot":"","sources":["../../../src/mock/mock-framework.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGlC,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAY3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,SAA8C;IAE9C,MAAM,YAAY,GAAG,IAAI,yBAAyB,EAAY,CAAC;IAC/D,MAAM,SAAS,EAAE,CAAC,YAAY,CAAC,CAAC;IAChC,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC;AAClC,CAAC;AAED,eAAe,aAAa,CAAC"}

package/dist/esm/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '8.0.15';
+export const version = '8.1.0-next.1';
 //# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,cAAc,CAAC"}