@webex/internal-plugin-metrics 3.0.0 → 3.1.0

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -41,11 +41,41 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.latencyTimestamps.get('client.alert.displayed'), now.getTime());
     });
 
-    it('should save latency correctly', () => {
+    it('should save latency correctly by default and overwrites', () => {
       assert.deepEqual(cdl.precomputedLatencies.size, 0);
       cdl.saveLatency('internal.client.pageJMT', 10);
       assert.deepEqual(cdl.precomputedLatencies.size, 1);
       assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 20);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
+    });
+
+    it('should overwrite latency when accumulate is false', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10, false);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 20, false);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
+    });
+
+    it('should save latency correctly when accumulate is true', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10, true);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+    });
+
+    it('should save latency correctly when accumulate is true and there is existing value', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 10, true);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
     });
 
     it('should save only first timestamp correctly', () => {
@@ -78,8 +108,13 @@ describe('internal-plugin-metrics', () => {
       cdl.saveTimestamp({key: 'client.alert.displayed'});
       cdl.saveTimestamp({key: 'client.alert.removed'});
       assert.deepEqual(cdl.latencyTimestamps.size, 2);
+      cdl.saveLatency('internal.api.fetch.intelligence.models', 42);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+
       cdl.clearTimestamps();
+
       assert.deepEqual(cdl.latencyTimestamps.size, 0);
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
     });
 
     it('should calculate diff between timestamps correctly', () => {
@@ -111,6 +146,127 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getMeetingInfoReqResp(), 10);
     });
 
+    describe('measureLatency', () => {
+      let clock;
+      let saveLatencySpy;
+
+      beforeEach(() => {
+        clock = sinon.useFakeTimers();
+
+        saveLatencySpy = sinon.stub(cdl, 'saveLatency');
+      });
+
+      afterEach(() => {
+        clock.restore();
+        sinon.restore();
+      });
+
+      it('checks measureLatency with accumulate false', async () => {
+        const key = 'internal.client.pageJMT';
+        const accumulate = false;
+
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(50);
+          return Promise.resolve('test');
+        });
+
+        // accumulate should be false by default
+        const promise = cdl.measureLatency(callbackStub, 'internal.client.pageJMT');
+
+        const resolvedValue = await promise;
+        assert.deepEqual(resolvedValue, 'test');
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 50, accumulate);
+      });
+
+      it('checks measureLatency with accumulate true', async () => {
+        const key = 'internal.download.time';
+        const accumulate = true;
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(20);
+          return Promise.resolve('test123');
+        });
+
+        const promise = cdl.measureLatency(callbackStub, 'internal.download.time', accumulate);
+
+        const resolvedValue = await promise;
+        assert.deepEqual(resolvedValue, 'test123');
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 20, accumulate);
+      });
+
+      it('checks measureLatency when callBack rejects', async () => {
+        const key = 'internal.client.pageJMT';
+        const accumulate = false;
+        const error = new Error('some error');
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(50);
+          return Promise.reject(error);
+        });
+
+        const promise = cdl.measureLatency(callbackStub, 'internal.client.pageJMT', accumulate);
+
+        const rejectedValue = await assert.isRejected(promise);
+        assert.deepEqual(rejectedValue, error);
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 50, accumulate);
+      });
+    });
+
+    describe('getRefreshCaptchaReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.refresh.captcha.time', 123);
+
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.refresh.captcha.time', 321.44);
+
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), 321);
+      });
+    });
+
+    describe('getReachabilityClustersReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.get.cluster.time', 123);
+
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.get.cluster.time', 321.44);
+
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), 321);
+      });
+    });
+
+    describe('getExchangeCITokenJMT', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.exchange.ci.token.time', 123);
+
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.exchange.ci.token.time', 321.44);
+
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), 321);
+      });
+    });
+
     describe('saveTimestamp', () => {
       afterEach(() => {
         sinon.restore();
@@ -512,9 +668,51 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getInterstitialToMediaOKJMT(), 10);
     });
 
+    it('calculates getU2CTime correctly', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getU2CTime(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.get.u2c.time', 123);
+
+        assert.deepEqual(cdl.getU2CTime(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.get.u2c.time', 321.44);
+
+        assert.deepEqual(cdl.getU2CTime(), 321);
+      });
+    });
+
     it('calculates getDownloadTimeJMT correctly', () => {
       cdl.saveLatency('internal.download.time', 1000);
       assert.deepEqual(cdl.getDownloadTimeJMT(), 1000);
     });
+
+    describe('getOtherAppApiReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), undefined);
+      });
+
+      it('returns undefined if it is less than 0', () => {
+        cdl.saveLatency('internal.other.app.api.time', 0);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.other.app.api.time', 123);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.other.app.api.time', 321.44);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), 321);
+      });
+    });
   });
 });

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics.ts

@@ -223,6 +223,43 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should build origin correctly with browserLaunchMethod', () => {
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
+
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {
+            subClientType: 'WEB_APP',
+            clientType: 'TEAMS_CLIENT',
+            newEnvironment: 'test-new-env',
+            clientLaunchMethod: 'url-handler',
+            browserLaunchMethod: 'thinclient',
+          },
+          fakeMeeting.id
+        );
+
+        assert.deepEqual(res, {
+          clientInfo: {
+            browser: getBrowserName(),
+            browserVersion: getBrowserVersion(),
+            clientType: 'TEAMS_CLIENT',
+            clientVersion: 'webex-js-sdk/webex-version',
+            publicNetworkPrefix: '1.1.1.1',
+            localNetworkPrefix: '1.1.1.1',
+            os: getOSNameInternal(),
+            osVersion: getOSVersion(),
+            subClientType: 'WEB_APP',
+            clientLaunchMethod: 'url-handler',
+            browserLaunchMethod: 'thinclient',
+          },
+          environment: 'meeting_evn',
+          newEnvironment: 'test-new-env',
+          name: 'endpoint',
+          networkType: 'unknown',
+          userAgent,
+        });
+      });
+
       it('should build origin correctly with no meeting', () => {
         sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
 
@@ -302,6 +339,11 @@ describe('internal-plugin-metrics', () => {
 
     describe('#getIdentifiers', () => {
       it('should build identifiers correctly', () => {
+        webex.internal.device = {
+          ...webex.internal.device,
+          config: {installationId: 'installationId'},
+        };
+
         const res = cd.getIdentifiers({
           mediaConnections: [
             {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
@@ -315,6 +357,7 @@ describe('internal-plugin-metrics', () => {
           locusId: 'url',
           locusStartTime: 'lastActive',
           locusUrl: 'locus/url',
+          machineId: 'installationId',
           mediaAgentAlias: 'mediaAgentAlias',
           mediaAgentGroupId: 'mediaAgentGroupId',
           orgId: 'orgId',
@@ -498,7 +541,10 @@ describe('internal-plugin-metrics', () => {
     it('should prepare diagnostic event successfully', () => {
       const options = {meetingId: fakeMeeting.id};
       const getOriginStub = sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
-      const clearEmptyKeysRecursivelyStub = sinon.stub(CallDiagnosticUtils, 'clearEmptyKeysRecursively');
+      const clearEmptyKeysRecursivelyStub = sinon.stub(
+        CallDiagnosticUtils,
+        'clearEmptyKeysRecursively'
+      );
 
       const res = cd.prepareDiagnosticEvent(
         {
@@ -715,7 +761,7 @@ describe('internal-plugin-metrics', () => {
         ]);
       });
 
-      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', async () => {
+      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
@@ -853,11 +899,13 @@ describe('internal-plugin-metrics', () => {
           options
         );
         assert.notCalled(submitToCallDiagnosticsSpy);
-        assert.calledWith(submitToCallDiagnosticsPreLoginSpy, {
+        assert.calledWith(
+          submitToCallDiagnosticsPreLoginSpy,
+          {
             eventId: 'my-fake-id',
             version: 1,
-            origin: { origin: 'fake-origin' },
-            originTime: { triggered: now.toISOString(), sent: 'not_defined_yet' },
+            origin: {origin: 'fake-origin'},
+            originTime: {triggered: now.toISOString(), sent: 'not_defined_yet'},
             senderCountryCode: 'UK',
             event: {
               name: 'client.alert.displayed',
@@ -869,12 +917,14 @@ describe('internal-plugin-metrics', () => {
                 orgId: 'orgId',
                 locusUrl: 'locus-url',
                 webexConferenceIdStr: 'webexConferenceIdStr1',
-                globalMeetingId: 'globalMeetingId1'
+                globalMeetingId: 'globalMeetingId1',
               },
-              eventData: { webClientDomain: 'whatever' },
-              loginType: 'login-ci'
+              eventData: {webClientDomain: 'whatever'},
+              loginType: 'login-ci',
             },
-        }, options.preLoginId);
+          },
+          options.preLoginId
+        );
       });
 
       it('should use meeting loginType if present and meetingId provided', () => {
@@ -1339,7 +1389,7 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe("#submitToCallDiagnostics", () => {
+    describe('#submitToCallDiagnostics', () => {
       it('should send request to call diagnostic batcher', () => {
         const requestStub = sinon.stub();
         //@ts-ignore
@@ -1348,7 +1398,7 @@ describe('internal-plugin-metrics', () => {
         cd.submitToCallDiagnostics({event: 'test'});
         assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
       });
-    })
+    });
 
     describe('#submitMQE', () => {
       it('submits the event correctly', () => {
@@ -1801,6 +1851,27 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should override custom properties for an unknown error', () => {
+        const error = new Error('bad times');
+
+        (error as any).payloadOverrides = {
+          shownToUser: true,
+          category: 'expected',
+        };
+
+        const res = cd.generateClientEventErrorPayload(error);
+        assert.deepEqual(res, {
+          category: 'expected',
+          errorDescription: 'UnknownError',
+          fatal: true,
+          name: 'other',
+          shownToUser: true,
+          serviceErrorCode: 9999,
+          errorCode: 9999,
+          rawErrorMessage: 'bad times',
+        });
+      });
+
       it('should override custom properties for a NetworkOrCORSError', () => {
         const error = new WebexHttpError.NetworkOrCORSError({
           url: 'https://example.com',
@@ -1942,12 +2013,16 @@ describe('internal-plugin-metrics', () => {
 
       describe('httpStatusCode', () => {
         it('should include httpStatusCode for browser media errors', () => {
-          const res = cd.generateClientEventErrorPayload({name: 'PermissionDeniedError', message: 'bad times', statusCode: 401});
+          const res = cd.generateClientEventErrorPayload({
+            name: 'PermissionDeniedError',
+            message: 'bad times',
+            statusCode: 401,
+          });
           assert.deepEqual(res, {
             category: 'expected',
             errorCode: 4032,
             errorData: {
-              errorName: 'PermissionDeniedError'
+              errorName: 'PermissionDeniedError',
             },
             errorDescription: 'CameraPermissionDenied',
             fatal: true,
@@ -1960,12 +2035,16 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for SdpOfferCreationErrors', () => {
-          const res = cd.generateClientEventErrorPayload({name: 'SdpOfferCreationError', message: 'bad times', statusCode: 404});
+          const res = cd.generateClientEventErrorPayload({
+            name: 'SdpOfferCreationError',
+            message: 'bad times',
+            statusCode: 404,
+          });
           assert.deepEqual(res, {
             category: 'media',
             errorCode: 2050,
             errorData: {
-              errorName: 'SdpOfferCreationError'
+              errorName: 'SdpOfferCreationError',
             },
             errorDescription: 'SdpOfferCreationError',
             fatal: true,
@@ -1978,7 +2057,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {errorCode: 58400}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {errorCode: 58400},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'signaling',
             errorCode: 4100,
@@ -1993,7 +2076,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for locus service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {errorCode: 2403001}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2403001},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'expected',
             errorCode: 3007,
@@ -2008,7 +2095,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for meetingInfo service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {data: {meetingInfo: {}}}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {data: {meetingInfo: {}}},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'signaling',
             errorCode: 4100,
@@ -2023,8 +2114,10 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for network errors', () => {
-          const error = new WebexHttpError.NetworkOrCORSError(
-            {statusCode: 400, options: {service: '', headers: {}}});
+          const error = new WebexHttpError.NetworkOrCORSError({
+            statusCode: 400,
+            options: {service: '', headers: {}},
+          });
           const res = cd.generateClientEventErrorPayload(error);
           assert.deepEqual(res, {
             category: 'network',
@@ -2040,8 +2133,10 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for unauthorized errors', () => {
-          const error = new WebexHttpError.Unauthorized(
-            {statusCode: 401, options: {service: '', headers: {}}});
+          const error = new WebexHttpError.Unauthorized({
+            statusCode: 401,
+            options: {service: '', headers: {}},
+          });
           const res = cd.generateClientEventErrorPayload(error);
           assert.deepEqual(res, {
             category: 'network',
@@ -2244,7 +2339,7 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe("#submitToCallDiagnosticsPreLogin", () => {
+    describe('#submitToCallDiagnosticsPreLogin', () => {
       it('should send request to call diagnostic batcher and saves preLoginId', () => {
         const requestStub = sinon.stub();
         //@ts-ignore
@@ -2257,7 +2352,7 @@ describe('internal-plugin-metrics', () => {
         assert.calledWith(cd.preLoginMetricsBatcher.savePreLoginId, preLoginId);
         assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
       });
-    })
+    });
 
     describe('#isServiceErrorExpected', () => {
       it('returns true for code mapped to "expected"', () => {

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics.util.ts

@@ -301,17 +301,31 @@ describe('internal-plugin-metrics', () => {
 
     [
       ['client.exit.app', {}],
-      ['client.webexapp.launched', {
-        joinTimes: {
-          downloadTime: undefined,
-        }
-      }],
+      [
+        'client.login.end',
+        {
+          joinTimes: {
+            otherAppApiReqResp: undefined,
+            exchangeCITokenJMT: undefined,
+          },
+        },
+      ],
+      [
+        'client.webexapp.launched',
+        {
+          joinTimes: {
+            downloadTime: undefined,
+          },
+        },
+      ],
       [
         'client.interstitial-window.launched',
         {
           joinTimes: {
             clickToInterstitial: undefined,
             meetingInfoReqResp: undefined,
+            refreshCaptchaServiceReqResp: undefined,
+            downloadIntelligenceModelsReqResp: undefined,
           },
         },
       ],
@@ -322,6 +336,8 @@ describe('internal-plugin-metrics', () => {
             showInterstitialTime: undefined,
             meetingInfoReqResp: undefined,
             registerWDMDeviceJMT: undefined,
+            getU2CTime: undefined,
+            getReachabilityClustersReqResp: undefined,
           },
         },
       ],
@@ -332,13 +348,12 @@ describe('internal-plugin-metrics', () => {
             meetingInfoReqResp: undefined,
             callInitJoinReq: undefined,
             joinReqResp: undefined,
-            joinReqSentReceived: undefined,
             pageJmt: undefined,
             clickToInterstitial: undefined,
             interstitialToJoinOK: undefined,
             totalJmt: undefined,
             clientJmt: undefined,
-            downloadTime: undefined
+            downloadTime: undefined,
           },
         },
       ],
@@ -600,6 +615,12 @@ describe('internal-plugin-metrics', () => {
         turnServerUsed: true,
         errorCode: DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
       },
+      {
+        signalingState: 'stable',
+        iceConnectionState: 'disconnected',
+        turnServerUsed: true,
+        errorCode: DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
+      },
       {
         signalingState: 'stable',
         iceConnectionState: 'failed',

package/test/unit/spec/client-metrics-prelogin-batcher.ts

@@ -0,0 +1,54 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import Metrics from '@webex/internal-plugin-metrics';
+import PreLoginMetricsBatcher from '@webex/internal-plugin-metrics';
+import ClientMetricsPreloginBatcher from '@webex/internal-plugin-metrics';
+
+
+describe('internal-plugin-metrics', () => {
+  describe('ClientMetricsPreloginBatcher', () => {
+    let webex;
+
+    beforeEach(() => {
+      //@ts-ignore
+      webex = new MockWebex({
+        children: {
+            metrics: Metrics,
+        },
+      });
+
+      webex.request = (options) =>
+        Promise.resolve({body: {items: []}, waitForServiceTimeout: 15, options});
+
+      sinon.spy(webex, 'request');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('should be an instance of PreLoginMetricsBatcher', () => {
+      const clientMetricsPreloginBatcher = new ClientMetricsPreloginBatcher();
+      assert.instanceOf(clientMetricsPreloginBatcher, PreLoginMetricsBatcher);
+    });
+
+
+    it('checks prepareItem', async () => {
+        const testItem = {id: 1};
+        const resultPromise = await webex.internal.metrics.clientMetricsPreloginBatcher.prepareItem(testItem);
+        assert.strictEqual(resultPromise, testItem);
+    });
+
+    it('checks prepareRequest', async () => {
+        const testQueue = [];
+
+        const resultPromise = await webex.internal.metrics.clientMetricsPreloginBatcher.prepareRequest(testQueue);
+        assert.strictEqual(resultPromise, testQueue);
+    });
+  });
+});