@equinor/fusion-framework-module-context 8.0.3 → 9.0.0-next.0

package/src/__tests__/ContextModuleConfigurator.test.ts

@@ -0,0 +1,412 @@
+import { from, firstValueFrom, type ObservableInput } from 'rxjs';
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  ModulesConfigurator,
+  type ConfigBuilderCallbackArgs,
+} from '@equinor/fusion-framework-module';
+import { configureHttp } from '@equinor/fusion-framework-module-http';
+import { createRouterMiddleware } from '@equinor/fusion-framework-module-http/mock';
+import type { IApiProvider } from '@equinor/fusion-framework-module-services';
+import { enableServices } from '@equinor/fusion-framework-module-services';
+import {
+  enableTelemetryMock,
+  MockTelemetryAdapter,
+} from '@equinor/fusion-framework-module-telemetry/mock';
+import { TelemetryLevel, TelemetryScope } from '@equinor/fusion-framework-module-telemetry';
+import type { QueryCtorOptions } from '@equinor/fusion-query';
+
+import {
+  ContextModuleConfigurator,
+  type IContextModuleConfigurator,
+} from '../ContextModuleConfigurator';
+import type { ContextProvider } from '../ContextProvider';
+import { module as contextModule } from '../module';
+import type { ContextItem } from '../types';
+
+type RawContextEntity = {
+  id: string;
+  externalId: string | null;
+  source: string | null;
+  type: { id: string; isChildType?: boolean; parentTypeIds?: string[] };
+  value: Record<string, unknown> | null;
+  title: string | null;
+  isActive: boolean;
+  isDeleted: boolean;
+  created: string;
+  updated: string | null;
+};
+
+const createRawContextEntity = (overrides: Partial<RawContextEntity> = {}): RawContextEntity => ({
+  id: 'ctx-1',
+  externalId: null,
+  source: null,
+  type: { id: 'ProjectMaster', isChildType: false, parentTypeIds: [] },
+  value: { key: 'value' },
+  title: 'My project',
+  isActive: true,
+  isDeleted: false,
+  created: '2024-01-01T00:00:00.000Z',
+  updated: null,
+  ...overrides,
+});
+
+/** Fakes the resolved `ContextApiClient`, invoking the selector against a canned raw payload. */
+const createApiProvider = (): IApiProvider =>
+  ({
+    createContextClient: vi.fn().mockResolvedValue({
+      get: (_version: string, _args: unknown, opts: { selector: (r: Response) => unknown }) =>
+        opts.selector(new Response(JSON.stringify(createRawContextEntity()))),
+      query: (_version: string, _args: unknown, opts: { selector: (r: Response) => unknown }) =>
+        opts.selector(new Response(JSON.stringify([createRawContextEntity({ id: 'ctx-2' })]))),
+      related: (_version: string, _args: unknown, opts: { selector: (r: Response) => unknown }) =>
+        opts.selector(new Response(JSON.stringify([createRawContextEntity({ id: 'ctx-3' })]))),
+    }),
+  }) as unknown as IApiProvider;
+
+const createInitArgs = (
+  overrides: Partial<ConfigBuilderCallbackArgs> = {},
+): ConfigBuilderCallbackArgs => ({
+  config: {},
+  hasModule: vi.fn().mockReturnValue(false),
+  requireInstance: vi.fn(),
+  ...overrides,
+});
+
+const createMockClient = () => ({
+  get: () => Promise.resolve({ id: 'custom', type: { id: 'Mock' }, value: {} } as ContextItem),
+  query: () => Promise.resolve([] as ContextItem[]),
+});
+
+const invoke = <TResult, TArgs>(
+  options: QueryCtorOptions<TResult, TArgs>,
+  args: TArgs,
+): Promise<TResult> => {
+  const client = options.client as { fn: (args: TArgs) => ObservableInput<TResult> };
+  return firstValueFrom(from(client.fn(args)));
+};
+
+/**
+ * Boots the real `http`, `services`, and `context` modules through the real module
+ * system, faking only the network call itself (the actual external boundary) —
+ * everything above it, including HTTP request/response handling, the services API
+ * client, the context selectors, and `ContextProvider`, runs unmocked.
+ */
+const addContextHttp = (configurator: ModulesConfigurator<[]>): void => {
+  configurator.addConfig(
+    configureHttp((http) => {
+      http.configureClient('context', { baseUri: 'https://context.example.com' });
+      http.addMiddleware(
+        createRouterMiddleware('https://context.example.com', (router) => {
+          router.get('/contexts/:id/relations', () =>
+            Response.json([createRawContextEntity({ id: 'ctx-3' })]),
+          );
+          router.get('/contexts', () => Response.json([createRawContextEntity({ id: 'ctx-2' })]));
+          router.get('/contexts/:id', () => Response.json(createRawContextEntity()));
+        }),
+      );
+    }),
+  );
+};
+
+const initializeContextWith = async (
+  configure?: (builder: IContextModuleConfigurator) => void,
+): Promise<ContextProvider> => {
+  const configurator = new ModulesConfigurator([]);
+  addContextHttp(configurator);
+  enableServices(configurator);
+  configurator.addConfig({ module: contextModule, configure });
+  const instances = await configurator.initialize();
+  // the configurator's generic instance map doesn't know about the context module by name
+  return (instances as unknown as { context: ContextProvider }).context;
+};
+
+/**
+ * Same as {@link initializeContextWith}, but with a recording telemetry adapter registered, so
+ * a test can assert on `Context::postInitialize.*` events/exceptions tracked through it instead
+ * of the no-telemetry `console.warn` fallback.
+ */
+const initializeContextWithTelemetry = async (
+  configure?: (builder: IContextModuleConfigurator) => void,
+): Promise<{ provider: ContextProvider; adapter: MockTelemetryAdapter }> => {
+  const configurator = new ModulesConfigurator([]);
+  addContextHttp(configurator);
+  enableServices(configurator);
+  const adapter = new MockTelemetryAdapter();
+  enableTelemetryMock(configurator, (builder) => builder.setAdapter('mock', adapter));
+  configurator.addConfig({ module: contextModule, configure });
+  const instances = await configurator.initialize();
+  return {
+    // the configurator's generic instance map doesn't know about the context module by name
+    provider: (instances as unknown as { context: ContextProvider }).context,
+    adapter,
+  };
+};
+
+describe('ContextModuleConfigurator', () => {
+  describe('client defaulting', () => {
+    it('builds a client from the local services module api provider when none was configured', async () => {
+      const apiProvider = createApiProvider();
+      const configurator = new ContextModuleConfigurator();
+
+      const config = await configurator.createConfigAsync(
+        createInitArgs({
+          hasModule: vi.fn().mockReturnValue(true),
+          requireInstance: vi.fn().mockResolvedValue(apiProvider),
+        }),
+      );
+
+      const item = await invoke(config.client.get, { id: 'ctx-1' });
+      expect(item).toMatchObject({
+        id: 'ctx-1',
+        title: 'My project',
+        type: { id: 'ProjectMaster' },
+      });
+
+      const items = await invoke(config.client.query, { search: 'foo' });
+      expect(items).toEqual([expect.objectContaining({ id: 'ctx-2' })]);
+
+      const related = await invoke(
+        config.client.related as QueryCtorOptions<ContextItem[], unknown>,
+        {
+          item,
+          filter: undefined,
+        },
+      );
+      expect(related).toEqual([expect.objectContaining({ id: 'ctx-3' })]);
+    });
+
+    it('falls back to the parent services module when not registered locally', async () => {
+      const apiProvider = createApiProvider();
+      const configurator = new ContextModuleConfigurator();
+
+      const config = await configurator.createConfigAsync(
+        createInitArgs({ ref: { services: apiProvider } }),
+      );
+
+      const item = await invoke(config.client.get, { id: 'ctx-1' });
+      expect(item.id).toBe('ctx-1');
+    });
+
+    it('throws when no services module is available locally or on the parent', async () => {
+      const configurator = new ContextModuleConfigurator();
+
+      await expect(configurator.createConfigAsync(createInitArgs())).rejects.toThrow(
+        /no service services provider/,
+      );
+    });
+
+    it('setContextClient bypasses the services module entirely', async () => {
+      const requireInstance = vi.fn();
+      const configurator = new ContextModuleConfigurator();
+      configurator.addConfigBuilder((builder) => {
+        builder.setContextClient(createMockClient());
+      });
+
+      const config = await configurator.createConfigAsync(createInitArgs({ requireInstance }));
+
+      expect(requireInstance).not.toHaveBeenCalled();
+      const item = await invoke(config.client.get, { id: 'custom' });
+      expect(item.id).toBe('custom');
+    });
+  });
+
+  describe('config builders', () => {
+    it('applies setter values registered through addConfigBuilder', async () => {
+      const configurator = new ContextModuleConfigurator();
+      configurator.addConfigBuilder((builder) => {
+        builder.setContextType(['ProjectMaster']);
+        // keep only active context items
+        builder.setContextFilter((items) => items.filter((i) => i.isActive));
+        builder.setContextClient(createMockClient());
+      });
+
+      const config = await configurator.createConfigAsync(createInitArgs());
+
+      expect(config.contextType).toEqual(['ProjectMaster']);
+      expect(
+        config.contextFilter?.([
+          { isActive: true } as ContextItem,
+          { isActive: false } as ContextItem,
+        ]),
+      ).toHaveLength(1);
+    });
+
+    it('runs multiple config builders in order, letting later ones win', async () => {
+      const configurator = new ContextModuleConfigurator();
+      configurator.addConfigBuilder((builder) => {
+        builder.setContextType(['ProjectMaster']);
+        builder.setContextClient(createMockClient());
+      });
+      configurator.addConfigBuilder((builder) => {
+        builder.setContextType(['Facility']);
+      });
+
+      const config = await configurator.createConfigAsync(createInitArgs());
+
+      expect(config.contextType).toEqual(['Facility']);
+    });
+
+    it('exposes requireInstance to config builders once initialization has started', async () => {
+      const configurator = new ContextModuleConfigurator();
+      const requireInstance = vi.fn().mockResolvedValue('resolved-instance');
+      let resolved: unknown;
+      configurator.addConfigBuilder(async (builder) => {
+        resolved = await builder.requireInstance('event');
+        builder.setContextClient(createMockClient());
+      });
+
+      await configurator.createConfigAsync(createInitArgs({ requireInstance }));
+
+      expect(resolved).toBe('resolved-instance');
+      expect(requireInstance).toHaveBeenCalledWith('event');
+    });
+
+    it('requireInstance throws synchronously when called before initialization begins', () => {
+      const configurator = new ContextModuleConfigurator();
+
+      expect(() => configurator.requireInstance('event')).toThrow(
+        /requireInstance can only be called during module configuration/,
+      );
+    });
+  });
+
+  describe('resolveInitialContext defaulting', () => {
+    it('defaults to a resolver function when a builder did not set one', async () => {
+      const configurator = new ContextModuleConfigurator();
+      configurator.addConfigBuilder((builder) => {
+        builder.setContextClient(createMockClient());
+      });
+
+      const config = await configurator.createConfigAsync(createInitArgs());
+
+      expect(config.resolveInitialContext).toBeTypeOf('function');
+    });
+
+    it('keeps a builder-provided resolver instead of the default', async () => {
+      const configurator = new ContextModuleConfigurator();
+      const customResolver = vi.fn();
+      configurator.addConfigBuilder((builder) => {
+        builder.setResolveInitialContext(customResolver);
+        builder.setContextClient(createMockClient());
+      });
+
+      const config = await configurator.createConfigAsync(createInitArgs());
+
+      expect(config.resolveInitialContext).toBe(customResolver);
+    });
+  });
+});
+
+describe('ContextProvider through the real module system (http mocked at the network boundary)', () => {
+  it('switches the current context by id via the real client and selectors', async () => {
+    const provider = await initializeContextWith();
+
+    const item = await provider.setCurrentContextByIdAsync('ctx-1');
+
+    expect(item).toMatchObject({ id: 'ctx-1', title: 'My project', type: { id: 'ProjectMaster' } });
+    expect(provider.currentContext?.id).toBe('ctx-1');
+  });
+
+  it('queries context items via the real client and selectors', async () => {
+    const provider = await initializeContextWith();
+
+    const items = await provider.queryContextAsync('foo');
+
+    expect(items).toEqual([expect.objectContaining({ id: 'ctx-2' })]);
+  });
+
+  it('resolves related context items via the real client and selectors', async () => {
+    const provider = await initializeContextWith();
+
+    const related = await provider.relatedContextsAsync({
+      item: { id: 'ctx-1', type: { id: 'ProjectMaster' }, value: {} },
+      filter: { type: ['ProjectMaster'] },
+    });
+
+    expect(related).toEqual([expect.objectContaining({ id: 'ctx-3' })]);
+  });
+
+  it('resolves an invalid context item to a related item of the configured context type', async () => {
+    const provider = await initializeContextWith((builder) => {
+      builder.setContextType(['ProjectMaster']);
+    });
+
+    // 'Contract' is not one of the configured context types, so it must be resolved
+    const resolved = await provider.resolveContextAsync({
+      id: 'ctx-contract',
+      type: { id: 'Contract' },
+      value: {},
+    });
+
+    expect(resolved.id).toBe('ctx-3');
+  });
+
+  it('resolves silently, without warning, when there is no initial context to resolve', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const provider = await initializeContextWith();
+
+    expect(provider.currentContext).toBeUndefined();
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+
+  it('warns (rather than silently swallowing the error) when the resolver throws and no telemetry module is registered', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const resolverError = new Error('boom');
+
+    const provider = await initializeContextWith((builder) => {
+      builder.setResolveInitialContext(() => Promise.reject(resolverError));
+    });
+
+    expect(provider.currentContext).toBeUndefined();
+    expect(warnSpy).toHaveBeenCalledWith(
+      'Context::postInitialize.resolveInitialContext',
+      resolverError,
+    );
+
+    warnSpy.mockRestore();
+  });
+
+  it('tracks the resolver error through telemetry (rather than console.warn) when a telemetry module is registered', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const resolverError = new Error('boom');
+
+    const { provider, adapter } = await initializeContextWithTelemetry((builder) => {
+      builder.setResolveInitialContext(() => Promise.reject(resolverError));
+    });
+
+    expect(provider.currentContext).toBeUndefined();
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    const [item] = adapter.getItems('Context::postInitialize.resolveInitialContext');
+    expect(item).toMatchObject({
+      name: 'Context::postInitialize.resolveInitialContext',
+      exception: resolverError,
+      level: TelemetryLevel.Warning,
+      scope: ['context', TelemetryScope.Framework],
+    });
+
+    warnSpy.mockRestore();
+  });
+
+  it('tracks a resolved initial context as a telemetry event', async () => {
+    const { provider, adapter } = await initializeContextWithTelemetry((builder) => {
+      builder.setResolveInitialContext(() =>
+        Promise.resolve({ id: 'ctx-1', type: { id: 'ProjectMaster' }, value: {} }),
+      );
+    });
+
+    expect(provider.currentContext?.id).toBe('ctx-1');
+
+    const [item] = adapter.getItems('Context::postInitialize.initialContextResolved');
+    expect(item).toMatchObject({
+      name: 'Context::postInitialize.initialContextResolved',
+      level: TelemetryLevel.Debug,
+      scope: ['context', TelemetryScope.Framework],
+      properties: { contextId: 'ctx-1' },
+    });
+  });
+});

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

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+
+import { ModulesConfigurator } from '@equinor/fusion-framework-module';
+
+import type { ContextProvider } from '../../ContextProvider';
+import { module as realModule } from '../../module';
+import type { ContextItem } from '../../types';
+import { ContextMockConfigurator, contextMockModule, enableContextMock } from '../../mock';
+import { createContextItemFactory, createContextItems } from '../../mock/fixtures';
+
+/**
+ * Initializes the mock module through the real module system.
+ *
+ * @remarks
+ * Deliberately avoids hand-building initialization arguments — the module
+ * system itself is the thing under test, not a fake of it.
+ *
+ * @param configure - Callback to seed context items or override resolution.
+ * @returns The provider the module produced.
+ */
+const initializeMockWith = async (
+  configure?: (mock: ContextMockConfigurator) => void,
+): Promise<ContextProvider> => {
+  const configurator = new ModulesConfigurator([]);
+  enableContextMock(configurator, configure);
+  const instances = await configurator.initialize();
+  // the configurator's generic instance map doesn't know about the context module by name
+  return (instances as unknown as { context: ContextProvider }).context;
+};
+
+describe('contextMockModule', () => {
+  it('changes nothing but the configurator', () => {
+    expect(contextMockModule.name).toBe(realModule.name);
+    expect(contextMockModule.initialize).toBe(realModule.initialize);
+  });
+
+  it('builds a real ContextModuleConfigurator, so the whole builder stays available', () => {
+    const configurator = contextMockModule.configure?.();
+
+    expect(configurator).toBeInstanceOf(ContextMockConfigurator);
+  });
+});
+
+describe('enableContextMock', () => {
+  it('initializes with no current context when nothing is seeded', async () => {
+    const provider = await initializeMockWith();
+
+    expect(provider.currentContext).toBeFalsy();
+  });
+
+  it('selects a seeded item as the initial context, without a navigation or parent module', async () => {
+    const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+
+    const provider = await initializeMockWith((mock) => mock.setCurrentContext(project));
+
+    expect(provider.currentContext?.id).toBe(project.id);
+  });
+
+  it('resolves a seeded item by id', async () => {
+    const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+
+    const provider = await initializeMockWith((mock) => mock.setContexts([project]));
+    const resolved = await provider.setCurrentContextByIdAsync(project.id);
+
+    expect(resolved.id).toBe(project.id);
+  });
+
+  it('rejects with a clear error for an unseeded id', async () => {
+    const provider = await initializeMockWith();
+
+    await expect(provider.setCurrentContextByIdAsync('missing')).rejects.toThrow(
+      /no context item resolves for id "missing"/,
+    );
+  });
+
+  it('resolves related contexts by filtering the seeded pool by type', async () => {
+    const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+    const [contract] = createContextItems([{ type: 'Contract', parentTypeIds: ['ProjectMaster'] }]);
+
+    const provider = await initializeMockWith((mock) => mock.setContexts([project, contract]));
+    const related = await provider.relatedContextsAsync({
+      item: contract,
+      filter: { type: ['ProjectMaster'] },
+    });
+
+    expect(related).toEqual([project]);
+  });
+
+  it('resolves a child-typed item into its configured parent type', async () => {
+    const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+    const [contract] = createContextItems([{ type: 'Contract', parentTypeIds: ['ProjectMaster'] }]);
+
+    const provider = await initializeMockWith((mock) => {
+      // the provider only calls resolveContext for a type it wasn't configured to accept
+      mock.addConfigBuilder((builder) => {
+        builder.setContextType(['ProjectMaster']);
+      });
+      mock.setContexts([project, contract]);
+    });
+
+    const resolved = await provider.resolveContextAsync(contract);
+
+    expect(resolved.id).toBe(project.id);
+  });
+
+  it('overrides the default type-filtered related contexts for one specific item', async () => {
+    const createContract = createContextItemFactory('contract');
+    const contractA = createContract({
+      type: { id: 'Contract', isChildType: true, parentTypeIds: ['ProjectMaster'] },
+    });
+    const contractB = createContract({
+      type: { id: 'Contract', isChildType: true, parentTypeIds: ['ProjectMaster'] },
+    });
+
+    const provider = await initializeMockWith((mock) => {
+      mock.setContexts([contractA, contractB]);
+      mock.setRelatedContexts(contractA.id, [contractB]);
+    });
+    const related = await provider.relatedContextsAsync({
+      item: contractA,
+      filter: { type: ['Contract'] },
+    });
+
+    expect(related).toEqual([contractB]);
+  });
+
+  it('resolves through the escape hatch when set', async () => {
+    const special: ContextItem = { id: 'special', type: { id: 'ProjectMaster' }, value: {} };
+
+    const provider = await initializeMockWith((mock) =>
+      mock.setResolver((id) => (id === 'special' ? special : undefined)),
+    );
+    const resolved = await provider.setCurrentContextByIdAsync('special');
+
+    expect(resolved).toEqual(special);
+  });
+});

package/src/__tests__/mock/create-context-item-factory.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+
+import { createContextItemFactory } from '../../mock/fixtures';
+
+describe('createContextItemFactory', () => {
+  it('generates sequential, deterministic ids across calls', () => {
+    const createContextItem = createContextItemFactory();
+
+    expect(createContextItem().id).toBe('ctx-1');
+    expect(createContextItem().id).toBe('ctx-2');
+    expect(createContextItem().id).toBe('ctx-3');
+  });
+
+  it('scopes the sequence to the returned factory, not globally', () => {
+    const a = createContextItemFactory();
+    const b = createContextItemFactory();
+
+    a();
+    a();
+
+    // b starts counting from 1 regardless of how many items a() already created
+    expect(b().id).toBe('ctx-1');
+  });
+
+  it('uses the given prefix', () => {
+    const createContextItem = createContextItemFactory('project');
+
+    expect(createContextItem().id).toBe('project-1');
+  });
+
+  it('applies overrides on top of the defaults', () => {
+    const createContextItem = createContextItemFactory();
+
+    const item = createContextItem({ title: 'Project 42', type: { id: 'ProjectMaster' } });
+
+    expect(item.title).toBe('Project 42');
+    expect(item.type).toEqual({ id: 'ProjectMaster' });
+    expect(item.value).toEqual({});
+  });
+
+  it('lets an explicit id override the generator without breaking the sequence', () => {
+    const createContextItem = createContextItemFactory();
+
+    const first = createContextItem({ id: 'explicit-id' });
+    const second = createContextItem();
+
+    expect(first.id).toBe('explicit-id');
+    // the counter still advances, even though the first call didn't consume a generated id
+    expect(second.id).toBe('ctx-2');
+  });
+
+  it('fills in a deterministic default title from a faker instance seeded by the item id', () => {
+    // two independent factories generating the same id must produce the same title
+    const titleA = createContextItemFactory()().title;
+    const titleB = createContextItemFactory()().title;
+
+    expect(titleA).toEqual(titleB);
+    expect(titleA).toEqual(expect.any(String));
+  });
+});

package/src/__tests__/mock/create-context-items.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+
+import { createContextItems } from '../../mock/fixtures';
+
+describe('createContextItems', () => {
+  it('generates one item per type by default, with deterministic ids', () => {
+    const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+
+    expect(project.id).toBe('projectmaster-1');
+    expect(project.type).toEqual({ id: 'ProjectMaster' });
+  });
+
+  it('generates `count` items per type, numbered from 1', () => {
+    const items = createContextItems([{ type: 'Facility', count: 3 }]);
+
+    // compare ids only, to assert the sequence without repeating every field
+    expect(items.map((item) => item.id)).toEqual(['facility-1', 'facility-2', 'facility-3']);
+  });
+
+  it('generates items for several types in the order given', () => {
+    const items = createContextItems([{ type: 'ProjectMaster' }, { type: 'Facility', count: 2 }]);
+
+    // compare ids only, to assert both type and generation order together
+    expect(items.map((item) => item.id)).toEqual(['projectmaster-1', 'facility-1', 'facility-2']);
+  });
+
+  it('marks a type as a child type when parentTypeIds is given', () => {
+    const [facility] = createContextItems([{ type: 'Facility', parentTypeIds: ['ProjectMaster'] }]);
+
+    expect(facility.type).toEqual({
+      id: 'Facility',
+      isChildType: true,
+      parentTypeIds: ['ProjectMaster'],
+    });
+  });
+
+  it('applies per-item overrides by 1-based index', () => {
+    const items = createContextItems([
+      {
+        type: 'Facility',
+        count: 2,
+        item: (index) => ({ title: `Facility ${index}` }),
+      },
+    ]);
+
+    // compare titles only, to assert the override was applied per index
+    expect(items.map((item) => item.title)).toEqual(['Facility 1', 'Facility 2']);
+  });
+
+  it('fills in a deterministic default title from a faker instance seeded by the item id', () => {
+    const [a] = createContextItems([{ type: 'ProjectMaster' }]);
+    const [b] = createContextItems([{ type: 'ProjectMaster' }]);
+
+    // same id ('projectmaster-1') in both calls must produce the same title
+    expect(a.title).toEqual(b.title);
+    expect(a.title).toEqual(expect.any(String));
+  });
+});

package/src/index.ts

@@ -11,11 +11,9 @@
  * @packageDocumentation
  */
 
-export {
-  ContextModuleConfigurator,
-  IContextModuleConfigurator,
-  ContextModuleConfig,
-} from './configurator';
+export { ContextModuleConfigurator } from './ContextModuleConfigurator';
+export type { IContextModuleConfigurator } from './ContextModuleConfigurator.interface';
+export type { ContextModuleConfig } from './ContextModuleConfig';
 
 export { IContextProvider, ContextProvider } from './ContextProvider';