@webex/internal-plugin-metrics 3.12.0-webex-services-ready.4 → 3.13.0-next.1

package/test/unit/spec/new-metrics.ts

@@ -8,20 +8,27 @@ import {
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 
-describe('internal-plugin-metrics', () => {
+import SourceNewMetrics from '@webex/internal-plugin-metrics/src/new-metrics';
+import * as Telemetry from '@webex/internal-plugin-metrics/src/unhandled-exception-telemetry';
 
-  const mockWebex = () => new MockWebex({
-    children: {
-      newMetrics: NewMetrics,
-    },
-    meetings: {
-    },
-    request: sinon.stub().resolves({}),
-    logger: {
-      log: sinon.stub(),
-      error: sinon.stub(),
-    }
-  });
+describe('internal-plugin-metrics', () => {
+  const mockWebex = (NewMetricsPlugin = NewMetrics) =>
+    new MockWebex({
+      children: {
+        newMetrics: NewMetricsPlugin,
+      },
+      meetings: {
+        getBasicMeetingInformation: sinon.stub().callsFake((meetingId) => ({
+          id: meetingId,
+          correlationId: `correlation-${meetingId}`,
+        })),
+      },
+      request: sinon.stub().resolves({}),
+      logger: {
+        log: sinon.stub(),
+        error: sinon.stub(),
+      },
+    });
 
   describe('check submitClientEvent, submitFeatureEvent when webex is not ready', () => {
     let webex;
@@ -50,12 +57,14 @@ describe('internal-plugin-metrics', () => {
         payload: {
           meetingSummaryInfo: {
             featureName: 'syncSystemMuteStatus',
-            featureActions: [{
-              actionName: 'syncMeetingMicUnmuteStatusToSystem',
-              actionId: '14200',
-              isInitialValue: false,
-              clickCount: '1'
-            }]
+            featureActions: [
+              {
+                actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                actionId: '14200',
+                isInitialValue: false,
+                clickCount: '1',
+              },
+            ],
           },
         },
       });
@@ -67,12 +76,54 @@ describe('internal-plugin-metrics', () => {
   });
 
   describe('new-metrics contstructor', () => {
-    it('checks callDiagnosticLatencies is defined before ready emit', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
 
+    it('checks callDiagnosticLatencies is defined before ready emit', () => {
       const webex = mockWebex();
 
       assert.instanceOf(webex.internal.newMetrics.callDiagnosticLatencies, CallDiagnosticLatencies);
     });
+
+    it('checks callDiagnosticMetrics is defined before ready emit', () => {
+      const webex = mockWebex();
+
+      assert.isDefined(webex.internal.newMetrics.callDiagnosticMetrics);
+    });
+
+    it('can call buildClientEventFetchRequestOptions before ready', async () => {
+      const webex = mockWebex();
+      const stub = sinon
+        .stub(
+          webex.internal.newMetrics.callDiagnosticMetrics,
+          'buildClientEventFetchRequestOptions'
+        )
+        .resolves({url: 'https://metrics.example.com'});
+
+      const result = await webex.internal.newMetrics.buildClientEventFetchRequestOptions({
+        name: 'client.alert.displayed',
+        options: {correlationId: 'test-id'},
+      });
+
+      assert.calledOnceWithExactly(stub, {
+        name: 'client.alert.displayed',
+        payload: undefined,
+        options: {correlationId: 'test-id'},
+      });
+      assert.deepEqual(result, {url: 'https://metrics.example.com'});
+    });
+
+    it('starts unhandled exception telemetry when webex is ready', () => {
+      const start = sinon.stub(Telemetry, 'startUnhandledExceptionTelemetry');
+      const webex = mockWebex(SourceNewMetrics);
+
+      assert.notCalled(start);
+
+      webex.emit('ready');
+
+      assert.calledOnceWithExactly(start, webex);
+    });
   });
 
   describe('new-metrics', () => {
@@ -98,7 +149,7 @@ describe('internal-plugin-metrics', () => {
 
     afterEach(() => {
       sinon.restore();
-    })
+    });
 
     it('lazy metrics backend initialization when checking if backend ready', () => {
       assert.isUndefined(webex.internal.newMetrics.behavioralMetrics);
@@ -109,10 +160,10 @@ describe('internal-plugin-metrics', () => {
       webex.internal.newMetrics.isReadyToSubmitOperationalEvents();
       assert.isDefined(webex.internal.newMetrics.operationalMetrics);
 
-      assert.isUndefined(webex.internal.newMetrics.businessMetrics)
+      assert.isUndefined(webex.internal.newMetrics.businessMetrics);
       webex.internal.newMetrics.isReadyToSubmitBusinessEvents();
       assert.isDefined(webex.internal.newMetrics.businessMetrics);
-    })
+    });
 
     it('returns the automated user classification', () => {
       assert.strictEqual(
@@ -122,7 +173,7 @@ describe('internal-plugin-metrics', () => {
     });
 
     it('passes the table through to the business metrics', () => {
-      assert.isUndefined(webex.internal.newMetrics.businessMetrics)
+      assert.isUndefined(webex.internal.newMetrics.businessMetrics);
       webex.internal.newMetrics.isReadyToSubmitBusinessEvents();
       assert.isDefined(webex.internal.newMetrics.businessMetrics);
       webex.internal.newMetrics.businessMetrics.submitBusinessEvent = sinon.stub();
@@ -130,14 +181,14 @@ describe('internal-plugin-metrics', () => {
         name: 'foobar',
         payload: {},
         table: 'test',
-        metadata: { foo: 'bar' },
+        metadata: {foo: 'bar'},
       });
 
       assert.calledWith(webex.internal.newMetrics.businessMetrics.submitBusinessEvent, {
         name: 'foobar',
         payload: {},
         table: 'test',
-        metadata: { foo: 'bar' },
+        metadata: {foo: 'bar'},
       });
     });
 
@@ -161,6 +212,87 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
+    describe('privacy and security permission enrichment', () => {
+      const permission = {
+        camera: {status: 'GRANTED' as const},
+        microphone: {status: 'DENIED' as const, reason: 'DENIED_BY_USER' as const},
+        contentShare: {status: 'REQUESTING' as const},
+      };
+
+      it('enriches an eligible client event through the public metrics API', () => {
+        webex.internal.newMetrics.setPrivacyAndSecurityPermission(permission);
+        webex.internal.newMetrics.submitClientEvent({name: 'client.call.initiated'});
+
+        const submittedPayload =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent.firstCall.args[0]
+            .payload;
+
+        assert.deepEqual(submittedPayload.privacyAndSecurityPermission, {
+          camera: permission.camera,
+          microphone: permission.microphone,
+        });
+      });
+
+      it('uses the meeting correlation id to preserve history across identifier transitions', () => {
+        webex.meetings.getBasicMeetingInformation
+          .withArgs('meeting-1')
+          .returns({id: 'meeting-1', correlationId: 'correlation-1'});
+        webex.internal.newMetrics.setPrivacyAndSecurityPermission(permission);
+
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.initiated',
+          options: {correlationId: 'correlation-1'},
+        });
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.ice.end',
+          payload: {},
+          options: {meetingId: 'meeting-1'},
+        });
+
+        const submissions = webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent.args;
+
+        assert.property(submissions[0][0].payload, 'privacyAndSecurityPermission');
+        assert.notProperty(submissions[1][0].payload, 'privacyAndSecurityPermission');
+      });
+
+      it('uses the default scope when no correlation id can be resolved', () => {
+        webex.internal.newMetrics.setPrivacyAndSecurityPermission(permission);
+
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.initiated',
+          options: {sessionCorrelationId: 'session-1'},
+        });
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.ice.end',
+          payload: {},
+          options: {sessionCorrelationId: 'session-2'},
+        });
+
+        const submissions = webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent.args;
+
+        assert.property(submissions[0][0].payload, 'privacyAndSecurityPermission');
+        assert.notProperty(submissions[1][0].payload, 'privacyAndSecurityPermission');
+      });
+
+      it('captures the permission snapshot before a delayed event is queued', () => {
+        webex.internal.newMetrics.setPrivacyAndSecurityPermission(permission);
+        webex.internal.newMetrics.setDelaySubmitClientEvents({shouldDelay: true});
+        webex.internal.newMetrics.submitClientEvent({name: 'client.call.initiated'});
+        webex.internal.newMetrics.setPrivacyAndSecurityPermission({
+          camera: {status: 'DENIED' as const},
+        });
+
+        const submission =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent.firstCall.args[0];
+
+        assert.isTrue(submission.delaySubmitEvent);
+        assert.deepEqual(submission.payload.privacyAndSecurityPermission, {
+          camera: permission.camera,
+          microphone: permission.microphone,
+        });
+      });
+    });
+
     it('submits feature Event successfully', () => {
       webex.internal.newMetrics.submitFeatureEvent({
         name: 'client.feature.meeting.summary',
@@ -170,12 +302,14 @@ describe('internal-plugin-metrics', () => {
         payload: {
           meetingSummaryInfo: {
             featureName: 'syncSystemMuteStatus',
-            featureActions: [{
-              actionName: 'syncMeetingMicUnmuteStatusToSystem',
-              actionId: '14200',
-              isInitialValue: false,
-              clickCount: '1'
-            }]
+            featureActions: [
+              {
+                actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                actionId: '14200',
+                isInitialValue: false,
+                clickCount: '1',
+              },
+            ],
           },
         },
       });
@@ -189,12 +323,14 @@ describe('internal-plugin-metrics', () => {
         payload: {
           meetingSummaryInfo: {
             featureName: 'syncSystemMuteStatus',
-            featureActions: [{
-              actionName: 'syncMeetingMicUnmuteStatusToSystem',
-              actionId: '14200',
-              isInitialValue: false,
-              clickCount: '1'
-            }]
+            featureActions: [
+              {
+                actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                actionId: '14200',
+                isInitialValue: false,
+                clickCount: '1',
+              },
+            ],
           },
         },
         options: {meetingId: '123'},
@@ -255,9 +391,9 @@ describe('internal-plugin-metrics', () => {
           method: 'POST',
           api: 'metrics',
           resource: 'clientmetrics',
-          headers: { 'x-prelogin-userid': 'my-id' },
+          headers: {'x-prelogin-userid': 'my-id'},
           body: {},
-          qs: { alias: true },
+          qs: {alias: true},
         });
         assert.calledWith(
           webex.logger.log,
@@ -266,8 +402,8 @@ describe('internal-plugin-metrics', () => {
       });
 
       it('handles failed request correctly', async () => {
-        webex.request.rejects(new Error("test error"));
-        sinon.stub(Utils, 'generateCommonErrorMetadata').returns('formattedError')
+        webex.request.rejects(new Error('test error'));
+        sinon.stub(Utils, 'generateCommonErrorMetadata').returns('formattedError');
         try {
           await webex.internal.newMetrics.clientMetricsAliasUser({event: 'test'}, 'my-id');
         } catch (err) {
@@ -349,19 +485,26 @@ describe('internal-plugin-metrics', () => {
         sinon.assert.match(webex.internal.newMetrics.delaySubmitClientEvents, true);
         sinon.assert.match(webex.internal.newMetrics.delayedClientEventsOverrides, {});
 
-        webex.internal.newMetrics.setDelaySubmitClientEvents({shouldDelay: false, overrides: {foo: 'bar'}});
+        webex.internal.newMetrics.setDelaySubmitClientEvents({
+          shouldDelay: false,
+          overrides: {foo: 'bar'},
+        });
 
-        assert.calledOnce(webex.internal.newMetrics.callDiagnosticMetrics.submitDelayedClientEvents);
-        assert.calledWith(webex.internal.newMetrics.callDiagnosticMetrics.submitDelayedClientEvents, {foo: 'bar'});
+        assert.calledOnce(
+          webex.internal.newMetrics.callDiagnosticMetrics.submitDelayedClientEvents
+        );
+        assert.calledWith(
+          webex.internal.newMetrics.callDiagnosticMetrics.submitDelayedClientEvents,
+          {foo: 'bar'}
+        );
 
         sinon.assert.match(webex.internal.newMetrics.delaySubmitClientEvents, false);
         sinon.assert.match(webex.internal.newMetrics.delayedClientEventsOverrides, {foo: 'bar'});
       });
 
       it('should not fail when called before webex is ready', () => {
-
         // Create mock
-        webex = mockWebex()
+        webex = mockWebex();
 
         webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp = sinon.stub();
         webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps = sinon.stub();
@@ -376,7 +519,6 @@ describe('internal-plugin-metrics', () => {
         webex.internal.newMetrics.setDelaySubmitClientEvents({shouldDelay: false});
         // Webex is ready
         webex.emit('ready');
-
       });
     });
   });

package/test/unit/spec/privacy-and-security-permission-enricher.ts

@@ -0,0 +1,318 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import type {ClientEvent, PrivacyAndSecurityPermission} from '../../../src/metrics.types';
+import PrivacyAndSecurityPermissionEnricher, {
+  PERMISSION_ENRICHMENT_RULES,
+} from '../../../src/privacy-and-security-permission-enricher';
+
+describe('PrivacyAndSecurityPermissionEnricher', () => {
+  const permission: PrivacyAndSecurityPermission = {
+    camera: {status: 'GRANTED'},
+    microphone: {status: 'DENIED', reason: 'DENIED_BY_USER'},
+    contentShare: {status: 'REQUESTING'},
+  };
+  let onEnrichmentError: sinon.SinonStub;
+  let enricher: PrivacyAndSecurityPermissionEnricher;
+
+  beforeEach(() => {
+    onEnrichmentError = sinon.stub();
+    enricher = new PrivacyAndSecurityPermissionEnricher(onEnrichmentError);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('permission enrichment rules', () => {
+    it('registers each production event in only one rule', () => {
+      const registeredEvents = PERMISSION_ENRICHMENT_RULES.flatMap(({events}) => [...events]);
+
+      assert.lengthOf(new Set(registeredEvents), registeredEvents.length);
+    });
+
+    [
+      'client.call.initiated',
+      'client.media.capabilities',
+      'client.ice.end',
+      'client.locus.join.request',
+      'client.locus.join.response',
+      'client.media-engine.ready',
+    ].forEach((name) => {
+      it(`projects camera and microphone for ${name}`, () => {
+        enricher.setPermission(permission);
+
+        const payload = enricher.enrich({name: name as ClientEvent['name'], scope: 'meeting'});
+
+        assert.deepEqual(payload?.privacyAndSecurityPermission, {
+          camera: permission.camera,
+          microphone: permission.microphone,
+        });
+      });
+    });
+
+    ['client.media.tx.start', 'client.media.tx.stop'].forEach((name) => {
+      [
+        {mediaType: 'audio' as const, expected: {microphone: permission.microphone}},
+        {mediaType: 'video' as const, expected: {camera: permission.camera}},
+        {mediaType: 'share' as const, expected: {contentShare: permission.contentShare}},
+      ].forEach(({mediaType, expected}) => {
+        it(`projects ${mediaType} permission for ${name}`, () => {
+          enricher.setPermission(permission);
+
+          const payload = enricher.enrich({
+            name: name as ClientEvent['name'],
+            payload: {mediaType},
+            scope: 'meeting',
+          });
+
+          assert.deepEqual(payload?.privacyAndSecurityPermission, expected);
+        });
+      });
+    });
+
+    [
+      'client.share.initiated',
+      'client.share.floor-grant.request',
+      'client.share.floor-granted.local',
+    ].forEach((name) => {
+      it(`projects content-share permission for ${name}`, () => {
+        enricher.setPermission(permission);
+
+        const payload = enricher.enrich({
+          name: name as ClientEvent['name'],
+          payload: {mediaType: 'share'},
+          scope: 'meeting',
+        });
+
+        assert.deepEqual(payload?.privacyAndSecurityPermission, {
+          contentShare: permission.contentShare,
+        });
+      });
+    });
+
+    ['client.call.leave', 'client.call.remote-ended', 'client.call.aborted'].forEach((name) => {
+      it(`projects every available permission for ${name}`, () => {
+        enricher.setPermission(permission);
+
+        const payload = enricher.enrich({name: name as ClientEvent['name'], scope: 'meeting'});
+
+        assert.deepEqual(payload?.privacyAndSecurityPermission, permission);
+      });
+    });
+  });
+
+  describe('setPermission', () => {
+    it('stores a defensive copy of the permission snapshot', () => {
+      const mutablePermission: PrivacyAndSecurityPermission = {
+        camera: {status: 'GRANTED'},
+      };
+
+      enricher.setPermission(mutablePermission);
+      mutablePermission.camera = {status: 'DENIED', reason: 'DENIED_BY_USER'};
+
+      const payload = enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+
+      assert.deepEqual(payload?.privacyAndSecurityPermission, {
+        camera: {status: 'GRANTED'},
+      });
+    });
+  });
+
+  describe('enrich', () => {
+    it('does not mutate the input payload or stored permission state', () => {
+      const inputPayload = {mediaType: 'audio' as const};
+
+      enricher.setPermission(permission);
+      const payload = enricher.enrich({
+        name: 'client.call.initiated',
+        payload: inputPayload,
+        scope: 'meeting',
+      });
+
+      assert.notStrictEqual(payload, inputPayload);
+      assert.notProperty(inputPayload, 'privacyAndSecurityPermission');
+      assert.notStrictEqual(payload?.privacyAndSecurityPermission?.camera, permission.camera);
+    });
+
+    it('returns the original payload when the requested permission is unavailable', () => {
+      const inputPayload = {mediaType: 'audio' as const};
+
+      enricher.setPermission({camera: permission.camera});
+      const payload = enricher.enrich({
+        name: 'client.media.tx.start',
+        payload: inputPayload,
+        scope: 'meeting',
+      });
+
+      assert.strictEqual(payload, inputPayload);
+    });
+
+    it('returns the original payload for unsupported share media types', () => {
+      const inputPayload = {mediaType: 'whiteboard' as const};
+
+      enricher.setPermission(permission);
+      const payload = enricher.enrich({
+        name: 'client.share.initiated',
+        payload: inputPayload,
+        scope: 'meeting',
+      });
+
+      assert.strictEqual(payload, inputPayload);
+    });
+
+    it('reports initial permission once and suppresses an unchanged later event', () => {
+      enricher.setPermission(permission);
+
+      const initialPayload = enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+      const unchangedPayload = enricher.enrich({name: 'client.ice.end', scope: 'meeting'});
+
+      assert.property(initialPayload, 'privacyAndSecurityPermission');
+      assert.isUndefined(unchangedPayload);
+    });
+
+    it('reports only permission resources that changed', () => {
+      enricher.setPermission(permission);
+      enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+      enricher.setPermission({
+        ...permission,
+        camera: {status: 'DENIED', reason: 'DENIED_BY_SYSTEM'},
+      });
+
+      const payload = enricher.enrich({name: 'client.ice.end', scope: 'meeting'});
+
+      assert.deepEqual(payload?.privacyAndSecurityPermission, {
+        camera: {status: 'DENIED', reason: 'DENIED_BY_SYSTEM'},
+      });
+    });
+
+    it('reports a changed reason when status is unchanged', () => {
+      enricher.setPermission({microphone: {status: 'DENIED', reason: 'DENIED_BY_USER'}});
+      enricher.enrich({
+        name: 'client.media.tx.start',
+        payload: {mediaType: 'audio'},
+        scope: 'meeting',
+      });
+      enricher.setPermission({microphone: {status: 'DENIED', reason: 'DENIED_BY_SYSTEM'}});
+
+      const payload = enricher.enrich({
+        name: 'client.media.tx.stop',
+        payload: {mediaType: 'audio'},
+        scope: 'meeting',
+      });
+
+      assert.deepEqual(payload?.privacyAndSecurityPermission, {
+        microphone: {status: 'DENIED', reason: 'DENIED_BY_SYSTEM'},
+      });
+    });
+
+    it('shares resource history across enrichment rules', () => {
+      enricher.setPermission(permission);
+      enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+
+      const payload = enricher.enrich({
+        name: 'client.media.tx.start',
+        payload: {mediaType: 'audio'},
+        scope: 'meeting',
+      });
+
+      assert.notProperty(payload, 'privacyAndSecurityPermission');
+    });
+
+    it('tracks permission history independently by scope', () => {
+      enricher.setPermission(permission);
+
+      const firstMeeting = enricher.enrich({name: 'client.call.initiated', scope: 'meeting-1'});
+      const secondMeeting = enricher.enrich({name: 'client.call.initiated', scope: 'meeting-2'});
+
+      assert.property(firstMeeting, 'privacyAndSecurityPermission');
+      assert.property(secondMeeting, 'privacyAndSecurityPermission');
+    });
+
+    it('clears only the terminal event scope', () => {
+      enricher.setPermission(permission);
+      enricher.enrich({name: 'client.call.initiated', scope: 'meeting-1'});
+      enricher.enrich({name: 'client.call.initiated', scope: 'meeting-2'});
+      enricher.enrich({name: 'client.call.leave', scope: 'meeting-1'});
+
+      const reusedScope = enricher.enrich({name: 'client.call.initiated', scope: 'meeting-1'});
+      const activeScope = enricher.enrich({name: 'client.ice.end', scope: 'meeting-2'});
+
+      assert.property(reusedScope, 'privacyAndSecurityPermission');
+      assert.isUndefined(activeScope);
+    });
+
+    it('preserves an explicit permission payload and uses it as the baseline', () => {
+      const explicitPayload = {
+        privacyAndSecurityPermission: {
+          camera: permission.camera,
+          microphone: permission.microphone,
+        },
+      };
+
+      enricher.setPermission(permission);
+      const returnedPayload = enricher.enrich({
+        name: 'client.call.initiated',
+        payload: explicitPayload,
+        scope: 'meeting',
+      });
+      const laterPayload = enricher.enrich({name: 'client.ice.end', scope: 'meeting'});
+
+      assert.strictEqual(returnedPayload, explicitPayload);
+      assert.isUndefined(laterPayload);
+    });
+
+    it('clears history after an explicit terminal payload', () => {
+      enricher.setPermission(permission);
+      enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+      enricher.enrich({
+        name: 'client.call.leave',
+        payload: {privacyAndSecurityPermission: permission},
+        scope: 'meeting',
+      });
+
+      const payload = enricher.enrich({name: 'client.call.initiated', scope: 'meeting'});
+
+      assert.property(payload, 'privacyAndSecurityPermission');
+    });
+
+    it('returns unchanged before permission state is supplied', () => {
+      const inputPayload = {mediaType: 'audio' as const};
+
+      const payload = enricher.enrich({
+        name: 'client.call.initiated',
+        payload: inputPayload,
+        scope: 'meeting',
+      });
+
+      assert.strictEqual(payload, inputPayload);
+    });
+
+    it('does not enrich unrelated events', () => {
+      enricher.setPermission(permission);
+
+      const payload = enricher.enrich({name: 'client.alert.displayed', scope: 'meeting'});
+
+      assert.isUndefined(payload);
+    });
+
+    it('reports enrichment errors and returns the original payload', () => {
+      const inputPayload = {};
+
+      Object.defineProperty(inputPayload, 'privacyAndSecurityPermission', {
+        get: () => {
+          throw new Error('permission read failed');
+        },
+      });
+
+      const payload = enricher.enrich({
+        name: 'client.call.initiated',
+        payload: inputPayload,
+        scope: 'meeting',
+      });
+
+      assert.strictEqual(payload, inputPayload);
+      assert.calledOnce(onEnrichmentError);
+    });
+  });
+});