@equinor/fusion-framework-module-analytics 3.0.7 → 3.0.8-next.0

package/dist/types/__tests__/MockAnalyticsAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/analytics-mock-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/mock/MockAnalyticsAdapter.d.ts

@@ -0,0 +1,76 @@
+import type { IAnalyticsAdapter } from '../adapters/AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from '../types.js';
+/**
+ * Selects which recorded events {@link MockAnalyticsAdapter.waitForAnalytic} or
+ * {@link MockAnalyticsAdapter.getAnalytics} act on.
+ *
+ * - `string` — matches `event.name` exactly.
+ * - `string[]` — matches if `event.name` is any of the given entries.
+ * - `(event) => boolean` — arbitrary predicate over the full event.
+ */
+export type AnalyticsEventMatcher<T extends AnalyticsEvent = AnalyticsEvent> = string | string[] | ((event: T) => boolean);
+/** Options accepted by {@link MockAnalyticsAdapter.waitForAnalytic}. */
+export interface WaitForAnalyticOptions {
+    /**
+     * Maximum time in milliseconds to wait for a matching event.
+     * When elapsed the returned promise rejects.
+     */
+    timeout?: number;
+    /**
+     * AbortSignal that can cancel the wait early.
+     * When aborted the returned promise rejects with the signal's reason.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * An {@link IAnalyticsAdapter} that records every tracked event in-memory instead
+ * of exporting it to a backend, for asserting on analytics in tests.
+ *
+ * @remarks
+ * Register it like any other adapter via {@link IAnalyticsConfigurator.setAdapter};
+ * it does not interfere with other adapters registered alongside it.
+ *
+ * @template T - Analytics event type, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * import { MockAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/mock';
+ *
+ * const recorder = new MockAnalyticsAdapter();
+ * enableAnalytics(configurator, (builder) => {
+ *   builder.setAdapter('mock', async () => recorder);
+ * });
+ *
+ * // ...later, in a test
+ * const event = await recorder.waitForAnalytic('button-click');
+ * expect(event.attributes?.section).toBe('header');
+ * ```
+ */
+export declare class MockAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> implements IAnalyticsAdapter<T> {
+    #private;
+    /**
+     * Records the event so it is visible to {@link getAnalytics} and any pending
+     * {@link waitForAnalytic} calls.
+     *
+     * @param event - The analytics event to record.
+     */
+    registerAnalytic(event: T): void;
+    /**
+     * Returns recorded events matching `matcher`, in dispatch order.
+     *
+     * @param matcher - Event name, array of names, or a predicate. Omit to get every recorded event.
+     * @returns Matching recorded events.
+     */
+    getAnalytics(matcher?: AnalyticsEventMatcher<T>): T[];
+    /**
+     * Waits for the next event matching `matcher`, resolving immediately if a
+     * matching event was already recorded.
+     *
+     * @param matcher - Event name, array of names, or a predicate.
+     * @param options - Optional timeout (ms) or AbortSignal.
+     * @returns A promise that resolves with the first matching event.
+     */
+    waitForAnalytic(matcher: AnalyticsEventMatcher<T>, options?: WaitForAnalyticOptions): Promise<T>;
+    /** Completes the internal event stream, rejecting any pending `waitForAnalytic` calls. */
+    [Symbol.dispose](): void;
+}

package/dist/types/mock/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Mock analytics adapter for tests: records tracked events in-memory instead
+ * of exporting them to a backend.
+ *
+ * @remarks
+ * Register it like any other {@link IAnalyticsAdapter} via
+ * {@link IAnalyticsConfigurator.setAdapter} — it observes tracked events
+ * alongside real adapters without affecting their delivery.
+ *
+ * @example
+ * ```ts
+ * import { MockAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/mock';
+ *
+ * const recorder = new MockAnalyticsAdapter();
+ * enableAnalytics(configurator, (builder) => {
+ *   builder.setAdapter('mock', async () => recorder);
+ * });
+ *
+ * const event = await recorder.waitForAnalytic('button-click');
+ * expect(event.attributes?.section).toBe('header');
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { MockAnalyticsAdapter, type AnalyticsEventMatcher, type WaitForAnalyticOptions, } from './MockAnalyticsAdapter.js';

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.0.7";
+export declare const version = "3.0.8-next.0";

package/docs/adapters.md

@@ -0,0 +1,79 @@
+# Adapters
+
+Adapters implement `IAnalyticsAdapter` and are responsible for processing and
+sending analytics data to their destinations. All adapters support async
+initialisation and will be initialised automatically when the provider starts.
+
+## ConsoleAnalyticsAdapter
+
+Logs every analytics event to the browser console. Useful for development and
+debugging. No configuration required.
+
+```typescript
+builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
+```
+
+## FusionAnalyticsAdapter
+
+Forwards analytics events to an OpenTelemetry-compatible log endpoint via a
+bundled `LoggerProvider`.
+
+Configuration options:
+
+| Option | Type | Description |
+|---|---|---|
+| `portalId` | `string` | Portal identifier included in every log record |
+| `logExporter` | `OTLPExporterBase` | OTLP log exporter for transport |
+
+### Using `OTLPLogExporter` (direct HTTP)
+
+```typescript
+import { OTLPLogExporter } from '@equinor/fusion-framework-module-analytics/logExporters';
+import { FusionAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+
+builder.setAdapter('fusion-log', async () => {
+  const logExporter = new OTLPLogExporter({
+    url: 'https://example.com/v1/logs',
+    headers: { 'Content-Type': 'application/json' },
+  });
+  return new FusionAnalyticsAdapter({ portalId: 'my-portal', logExporter });
+});
+```
+
+### Using `FusionOTLPLogExporter` (service discovery HTTP client)
+
+```typescript
+import { FusionOTLPLogExporter } from '@equinor/fusion-framework-module-analytics/logExporters';
+import { FusionAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+
+builder.setAdapter('fusion', async (args) => {
+  if (args.hasModule('serviceDiscovery')) {
+    const sd = await args.requireInstance('serviceDiscovery');
+    const httpClient = await sd.createClient('analytics');
+    const logExporter = new FusionOTLPLogExporter(httpClient);
+    return new FusionAnalyticsAdapter({ portalId: 'my-portal', logExporter });
+  }
+  console.error('Service discovery unavailable — analytics adapter not created');
+});
+```
+
+## Creating a Custom Adapter
+
+Implement `IAnalyticsAdapter` and register it with `setAdapter`:
+
+```typescript
+import type { IAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+import type { AnalyticsEvent } from '@equinor/fusion-framework-module-analytics';
+
+class MyRemoteAdapter implements IAnalyticsAdapter {
+  registerAnalytic(event: AnalyticsEvent): void {
+    navigator.sendBeacon('/analytics', JSON.stringify(event));
+  }
+
+  [Symbol.dispose](): void {
+    // cleanup if needed
+  }
+}
+
+builder.setAdapter('remote', async () => new MyRemoteAdapter());
+```

package/docs/collectors.md

@@ -0,0 +1,91 @@
+# Collectors
+
+Collectors implement `IAnalyticsCollector` (or extend `BaseCollector`) and emit
+`AnalyticsEvent` objects that are forwarded to all adapters. All collectors
+support async initialisation.
+
+## ContextSelectedCollector
+
+Emits an event when the active Fusion context changes. Includes the new context,
+the previous context, and the current app key in attributes.
+
+```typescript
+builder.setCollector('context-selected', async (args) => {
+  const ctx = await args.requireInstance('context');
+  const app = await args.requireInstance('app');
+  return new ContextSelectedCollector(ctx, app);
+});
+```
+
+## AppSelectedCollector
+
+Emits an event when the active application changes. Includes the new and
+previous app key metadata.
+
+```typescript
+builder.setCollector('app-selected', async (args) => {
+  const app = await args.requireInstance('app');
+  return new AppSelectedCollector(app);
+});
+```
+
+## AppLoadedCollector
+
+Emits an event when an application's modules finish loading. Includes app
+manifest metadata and the current context (if available).
+
+```typescript
+builder.setCollector('app-loaded', async (args) => {
+  const event = await args.requireInstance('event');
+  const app = await args.requireInstance('app');
+  return new AppLoadedCollector(event, app);
+});
+```
+
+## Creating a Custom Collector
+
+### Extending `BaseCollector`
+
+Extend `BaseCollector` with a Zod schema for validation:
+
+```typescript
+import { BaseCollector, createSchema } from '@equinor/fusion-framework-module-analytics/collectors';
+import { z } from 'zod';
+import { of } from 'rxjs';
+
+const schema = createSchema(z.string(), z.object({ page: z.string() }));
+
+class PageViewCollector extends BaseCollector<string, { page: string }> {
+  constructor() {
+    super('page-view', schema);
+  }
+
+  _initialize() {
+    return of({ value: window.location.pathname, attributes: { page: document.title } });
+  }
+}
+```
+
+### Implementing `IAnalyticsCollector` directly
+
+For cases that don't need schema validation, implement the `Subscribable` contract directly:
+
+```typescript
+import { type AnalyticsEvent, enableAnalytics } from '@equinor/fusion-framework-module-analytics';
+import { Subject } from 'rxjs';
+
+const configure = (configurator: IModulesConfigurator<any, any>) => {
+  enableAnalytics(configurator, (builder) => {
+    builder.setCollector('click-test', async () => {
+      const subject = new Subject<AnalyticsEvent>();
+      window.addEventListener('click', () => {
+        subject.next({ name: 'window-clicker', value: 42 });
+      });
+
+      return {
+        subscribe: (subscriber) => subject.subscribe(subscriber),
+      };
+    });
+  });
+};
+```

package/docs/testing.md

@@ -0,0 +1,87 @@
+# Testing
+
+Use `MockAnalyticsAdapter` from `@equinor/fusion-framework-module-analytics/mock` to assert on tracked analytics events without exporting them to a real backend. Register it like any other adapter via `setAdapter`, then query or await recorded events from your test:
+
+```ts
+import { enableAnalytics } from '@equinor/fusion-framework-module-analytics';
+import { MockAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/mock';
+
+const recorder = new MockAnalyticsAdapter();
+
+enableAnalytics(configurator, (builder) => {
+  builder.setAdapter('mock', async () => recorder);
+});
+
+// ... exercise the app under test, then assert:
+const event = await recorder.waitForAnalytic('button-click');
+expect(event.attributes?.section).toBe('header');
+
+// or synchronously inspect everything recorded so far:
+expect(recorder.getAnalytics('page-view')).toHaveLength(1);
+```
+
+`MockAnalyticsAdapter` is a genuine `IAnalyticsAdapter` implementation — it works the same way through the real `enableAnalytics` configuration pipeline as `ConsoleAnalyticsAdapter` or `FusionAnalyticsAdapter`, so registering it alongside other adapters doesn't change their behavior.
+
+## `getAnalytics(matcher?)`
+
+Returns recorded events synchronously, filtered by an event name, an array of names, or a predicate. Omit the matcher to get every recorded event.
+
+```ts
+recorder.getAnalytics(); // every recorded event
+recorder.getAnalytics('button-click'); // by name
+recorder.getAnalytics(['button-click', 'page-view']); // any of these names
+recorder.getAnalytics((event) => event.attributes?.section === 'header'); // predicate
+```
+
+## `waitForAnalytic(matcher, options?)`
+
+Resolves with the first matching event — immediately if one was already recorded, or waiting for a future one. Supports an optional `timeout` (ms) and `signal` (`AbortSignal`) so a test can't hang indefinitely, and rejects if the adapter is disposed before a match occurs.
+
+```ts
+// Rejects after 1000ms if the event never fires
+const event = await recorder.waitForAnalytic('button-click', { timeout: 1000 });
+
+// Rejects as soon as the signal aborts
+const controller = new AbortController();
+const pending = recorder.waitForAnalytic('button-click', { signal: controller.signal });
+controller.abort();
+
+await expect(pending).rejects.toThrow();
+```
+
+## Using a bespoke `ModulesConfigurator`
+
+`MockAnalyticsAdapter` works the same way with a manually composed set of modules — no app or portal host required:
+
+```ts
+import { ModulesConfigurator } from '@equinor/fusion-framework-module';
+import { enableAnalytics } from '@equinor/fusion-framework-module-analytics';
+import { MockAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/mock';
+import type { IAnalyticsProvider } from '@equinor/fusion-framework-module-analytics';
+
+const recorder = new MockAnalyticsAdapter();
+const configurator = new ModulesConfigurator([]);
+
+enableAnalytics(configurator, (builder) => {
+  builder.setAdapter('mock', async () => recorder);
+});
+
+// enableAnalytics only registers the module at runtime, so `initialize()` isn't
+// statically typed with an `analytics` property — cast to the real provider type.
+const instances = await configurator.initialize();
+const { analytics } = instances as unknown as { analytics: IAnalyticsProvider };
+analytics.trackAnalytic({ name: 'button-click', value: 'save' });
+
+expect(recorder.getAnalytics('button-click')).toHaveLength(1);
+```
+
+## Disposal
+
+`MockAnalyticsAdapter` completes its internal event stream on `[Symbol.dispose]()`, rejecting any pending `waitForAnalytic` calls instead of leaving them hanging:
+
+```ts
+const pending = recorder.waitForAnalytic('button-click');
+recorder[Symbol.dispose]();
+
+await expect(pending).rejects.toThrow('disposed before a matching event was recorded');
+```

package/docs/tracking-events.md

@@ -0,0 +1,16 @@
+# Tracking Events Manually
+
+The provider exposes methods for ad-hoc event tracking outside of collectors:
+
+```typescript
+// Single event
+provider.trackAnalytic({
+  name: 'button-click',
+  value: 'save',
+  attributes: { section: 'toolbar' },
+});
+
+// Observable stream
+const subscription = provider.trackAnalytic$(myEvent$);
+// later: subscription.unsubscribe();
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-analytics",
-  "version": "3.0.7",
+  "version": "3.0.8-next.0",
   "description": "Fusion module for collecting and exporting application analytics using OpenTelemetry standards",
   "main": "dist/esm/index.js",
   "type": "module",
@@ -20,6 +20,10 @@
     "./logExporters": {
       "import": "./dist/esm/logExporters/index.js",
       "types": "./dist/types/logExporters/index.d.ts"
+    },
+    "./mock": {
+      "import": "./dist/esm/mock/index.js",
+      "types": "./dist/types/mock/index.d.ts"
     }
   },
   "types": "dist/types/index.d.ts",
@@ -49,19 +53,19 @@
     "rxjs": "^7.8.1",
     "uuid": "^14.0.0",
     "zod": "^4.4.3",
-    "@equinor/fusion-framework-module-app": "8.0.5",
-    "@equinor/fusion-framework-module-event": "6.0.1",
-    "@equinor/fusion-framework-module-http": "8.0.5",
-    "@equinor/fusion-framework-module": "6.1.2",
-    "@equinor/fusion-framework-module-context": "8.0.3"
+    "@equinor/fusion-framework-module": "6.1.3-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-http": "8.1.0-next.0",
+    "@equinor/fusion-framework-module-app": "8.0.6-next.0"
   },
   "devDependencies": {
     "typescript": "^7.0.2",
-    "vitest": "^4.1.0",
-    "@equinor/fusion-observable": "^9.1.1"
+    "vitest": "^4.1.10",
+    "@equinor/fusion-observable": "^9.1.2-next.1"
   },
   "peerDependencies": {
-    "@equinor/fusion-observable": "9.1.1"
+    "@equinor/fusion-observable": "9.1.2-next.1"
   },
   "scripts": {
     "build": "tsc -b",

package/src/__tests__/MockAnalyticsAdapter.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+
+import { MockAnalyticsAdapter } from '../mock/MockAnalyticsAdapter.js';
+import type { AnalyticsEvent } from '../types.js';
+
+const createEvent = (name: string, overrides: Partial<AnalyticsEvent> = {}): AnalyticsEvent => ({
+  name,
+  value: null,
+  ...overrides,
+});
+
+describe('MockAnalyticsAdapter', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('records events via registerAnalytic and returns them from getAnalytics', () => {
+    const adapter = new MockAnalyticsAdapter();
+
+    adapter.registerAnalytic(createEvent('button-click'));
+    adapter.registerAnalytic(createEvent('page-view'));
+
+    expect(adapter.getAnalytics().map((e) => e.name)).toEqual(['button-click', 'page-view']);
+  });
+
+  it('filters getAnalytics by a single name, an array, and a predicate', () => {
+    const adapter = new MockAnalyticsAdapter();
+    adapter.registerAnalytic(createEvent('button-click', { attributes: { section: 'header' } }));
+    adapter.registerAnalytic(createEvent('page-view'));
+
+    expect(adapter.getAnalytics('button-click')).toHaveLength(1);
+    expect(adapter.getAnalytics(['button-click', 'page-view'])).toHaveLength(2);
+    expect(adapter.getAnalytics((e) => e.attributes?.section === 'header')).toHaveLength(1);
+  });
+
+  it('resolves waitForAnalytic immediately when a matching event is already recorded', async () => {
+    const adapter = new MockAnalyticsAdapter();
+    adapter.registerAnalytic(createEvent('button-click'));
+
+    const event = await adapter.waitForAnalytic('button-click');
+
+    expect(event.name).toBe('button-click');
+  });
+
+  it('resolves waitForAnalytic when a matching event is recorded later', async () => {
+    const adapter = new MockAnalyticsAdapter();
+
+    const promise = adapter.waitForAnalytic('button-click');
+    adapter.registerAnalytic(createEvent('page-view'));
+    adapter.registerAnalytic(createEvent('button-click'));
+    const event = await promise;
+
+    expect(event.name).toBe('button-click');
+  });
+
+  it('resolves waitForAnalytic via predicate matcher', async () => {
+    const adapter = new MockAnalyticsAdapter();
+
+    const promise = adapter.waitForAnalytic((e) => e.attributes?.id === 42);
+    adapter.registerAnalytic(createEvent('button-click', { attributes: { id: 1 } }));
+    adapter.registerAnalytic(createEvent('button-click', { attributes: { id: 42 } }));
+    const event = await promise;
+
+    expect(event.attributes?.id).toBe(42);
+  });
+
+  it('rejects when the timeout elapses before a matching event is recorded', async () => {
+    vi.useFakeTimers();
+    const adapter = new MockAnalyticsAdapter();
+
+    const promise = adapter.waitForAnalytic('button-click', { timeout: 500 });
+    vi.advanceTimersByTime(501);
+
+    await expect(promise).rejects.toThrow('waitForAnalytic timed out after 500ms');
+  });
+
+  it('rejects when the AbortSignal fires before a matching event', async () => {
+    const adapter = new MockAnalyticsAdapter();
+    const controller = new AbortController();
+
+    const promise = adapter.waitForAnalytic('button-click', { signal: controller.signal });
+    controller.abort();
+
+    await expect(promise).rejects.toThrow();
+  });
+
+  it('rejects immediately when passed an already-aborted signal', async () => {
+    const adapter = new MockAnalyticsAdapter();
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      adapter.waitForAnalytic('button-click', { signal: controller.signal }),
+    ).rejects.toThrow();
+  });
+
+  it('rejects pending waitForAnalytic calls when the adapter is disposed', async () => {
+    const adapter = new MockAnalyticsAdapter();
+
+    const promise = adapter.waitForAnalytic('button-click');
+    adapter[Symbol.dispose]();
+
+    await expect(promise).rejects.toThrow('disposed before a matching event was recorded');
+  });
+
+  it('rejects instead of hanging when a predicate matcher throws on a future event', async () => {
+    const adapter = new MockAnalyticsAdapter();
+    const boom = new Error('predicate boom');
+
+    const promise = adapter.waitForAnalytic(() => {
+      throw boom;
+    });
+    adapter.registerAnalytic(createEvent('button-click'));
+
+    await expect(promise).rejects.toThrow(boom);
+  });
+
+  it('does not interfere with events recorded by another adapter instance', () => {
+    const adapterA = new MockAnalyticsAdapter();
+    const adapterB = new MockAnalyticsAdapter();
+
+    adapterA.registerAnalytic(createEvent('button-click'));
+
+    expect(adapterA.getAnalytics()).toHaveLength(1);
+    expect(adapterB.getAnalytics()).toHaveLength(0);
+  });
+});

package/src/__tests__/mock/analytics-mock-adapter.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ModulesConfigurator } from '@equinor/fusion-framework-module';
+import { Subject } from 'rxjs';
+
+import { enableAnalytics } from '../../enable-analytics.js';
+import { ConsoleAnalyticsAdapter } from '../../adapters/ConsoleAnalyticsAdapter.js';
+import { MockAnalyticsAdapter } from '../../mock/MockAnalyticsAdapter.js';
+import type { IAnalyticsConfigurator } from '../../AnalyticsConfigurator.interface.js';
+import type { IAnalyticsProvider } from '../../AnalyticsProvider.interface.js';
+import type { AnalyticsEvent } from '../../types.js';
+
+/**
+ * Initializes the analytics module through the real module system, with a
+ * `MockAnalyticsAdapter` registered alongside whatever the test configures.
+ *
+ * @remarks
+ * Deliberately avoids hand-building an `AnalyticsProvider`. Testing the
+ * adapter's own logic in isolation (see `MockAnalyticsAdapter.test.ts`) can't
+ * prove it actually receives events through the real configure -> initialize
+ * -> collector/adapter dispatch pipeline every other adapter goes through.
+ *
+ * @param configure - Optional callback to register additional adapters/collectors.
+ * @returns The real `IAnalyticsProvider` instance and the recording adapter.
+ */
+const initializeWith = async (
+  configure?: (builder: IAnalyticsConfigurator) => void,
+): Promise<{ provider: IAnalyticsProvider; recorder: MockAnalyticsAdapter }> => {
+  const recorder = new MockAnalyticsAdapter();
+  const configurator = new ModulesConfigurator([]);
+
+  enableAnalytics(configurator, (builder) => {
+    builder.setAdapter('mock', async () => recorder);
+    configure?.(builder);
+  });
+
+  const instances = await configurator.initialize();
+  const provider = (instances as unknown as { analytics: IAnalyticsProvider }).analytics;
+
+  return { provider, recorder };
+};
+
+describe('MockAnalyticsAdapter (through the real analytics module)', () => {
+  it('observes events pushed via provider.trackAnalytic', async () => {
+    const { provider, recorder } = await initializeWith();
+
+    provider.trackAnalytic({ name: 'button-click', value: 'save' });
+
+    expect(recorder.getAnalytics('button-click')).toHaveLength(1);
+  });
+
+  it('observes events emitted by a real registered collector', async () => {
+    const clicks$ = new Subject<AnalyticsEvent>();
+    const { recorder } = await initializeWith((builder) => {
+      builder.setCollector('clicks', async () => clicks$);
+    });
+
+    clicks$.next({ name: 'window-click', value: 42 });
+
+    const event = await recorder.waitForAnalytic('window-click');
+    expect(event.value).toBe(42);
+  });
+
+  it('does not interfere with other adapters registered alongside it', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const { provider, recorder } = await initializeWith((builder) => {
+      builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
+    });
+
+    provider.trackAnalytic({ name: 'page-view', value: null });
+
+    expect(recorder.getAnalytics('page-view')).toHaveLength(1);
+    expect(logSpy).toHaveBeenCalledWith('Analytics::Adapter::Console', {
+      name: 'page-view',
+      value: null,
+    });
+
+    logSpy.mockRestore();
+  });
+});