@webex/internal-plugin-metrics 3.12.0-next.4 → 3.12.0-next.40

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

@@ -460,6 +460,33 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
+    it('logs a Milestone entry when event name is present', () => {
+      const logSpy = sinon.spy(webex.logger, 'log');
+      const eventName = 'client.call.initiated';
+      const eventPayload = {event: {name: eventName}};
+
+      prepareDiagnosticMetricItem(webex, {eventPayload, type: ['diagnostic-event']});
+
+      assert.isTrue(
+        logSpy.calledWith('Milestone,CallDiagnostic', eventName),
+        'expected logger.log to be called with Milestone,CallDiagnostic and the event name'
+      );
+      sinon.restore();
+    });
+
+    it('does not log a Milestone entry when event name is absent', () => {
+      const logSpy = sinon.spy(webex.logger, 'log');
+      const eventPayload = {event: {}};
+
+      prepareDiagnosticMetricItem(webex, {eventPayload, type: ['diagnostic-event']});
+
+      assert.isFalse(
+        logSpy.calledWith('Milestone,CallDiagnostic', sinon.match.any),
+        'expected logger.log not to be called with Milestone,CallDiagnostic when event name is absent'
+      );
+      sinon.restore();
+    });
+
     it('sets buildType and upgradeChannel correctly', () => {
       const item: any = {
         eventPayload: {

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

@@ -1,8 +1,12 @@
 import {assert} from '@webex/test-helper-chai';
-import {NewMetrics, CallDiagnosticLatencies} from '@webex/internal-plugin-metrics';
+import {
+  NewMetrics,
+  CallDiagnosticLatencies,
+  AutomatedUserUtils,
+  Utils,
+} from '@webex/internal-plugin-metrics';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import {Utils} from '@webex/internal-plugin-metrics';
 
 describe('internal-plugin-metrics', () => {
 
@@ -69,6 +73,32 @@ describe('internal-plugin-metrics', () => {
 
       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'});
+    });
   });
 
   describe('new-metrics', () => {
@@ -110,6 +140,13 @@ describe('internal-plugin-metrics', () => {
       assert.isDefined(webex.internal.newMetrics.businessMetrics);
     })
 
+    it('returns the automated user classification', () => {
+      assert.strictEqual(
+        webex.internal.newMetrics.isAutomatedUser(),
+        AutomatedUserUtils.isAutomatedUser()
+      );
+    });
+
     it('passes the table through to the business metrics', () => {
       assert.isUndefined(webex.internal.newMetrics.businessMetrics)
       webex.internal.newMetrics.isReadyToSubmitBusinessEvents();

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

@@ -64,45 +64,36 @@ describe('internal-plugin-metrics', () => {
         //@ts-ignore
         assert.calledOnce(webex.request);
 
-        // matching because the request includes a symbol key: value pair and sinon cannot handle to compare it..
-        assert.match(webexRequestArgs, {
-          //@ts-ignore
-          body: {
-            metrics: [
-              {
-                eventPayload: {
-                  event: {
-                    joinTimes: {
-                      meetingInfoReqResp: undefined,
-                      clickToInterstitial: undefined,
-                      refreshCaptchaServiceReqResp: undefined,
-                      downloadIntelligenceModelsReqResp: undefined,
-                      clickToInterstitialWithUserDelay: undefined,
-                    },
-                    name: 'client.interstitial-window.launched',
-                  },
-                  origin: {
-                    buildType: 'test',
-                    networkType: 'unknown',
-                    upgradeChannel: 'test',
-                  },
-                  originTime: {
-                    sent: dateAfterBatcherWait.toISOString(),
-                  },
-                },
-                type: ['diagnostic-event'],
-              },
-            ],
+        assert.deepEqual(webexRequestArgs.headers, {
+          authorization: false,
+          'x-prelogin-userid': preLoginId,
+        });
+        assert.equal(webexRequestArgs.method, 'POST');
+        assert.equal(webexRequestArgs.resource, 'clientmetrics-prelogin');
+        assert.equal(webexRequestArgs.service, 'metrics');
+        assert.equal(webexRequestArgs.waitForServiceTimeout, 30);
+
+        assert.deepEqual(webexRequestArgs.body.metrics[0].eventPayload, {
+          event: {
+            joinTimes: {
+              meetingInfoReqResp: undefined,
+              clickToInterstitial: undefined,
+              refreshCaptchaServiceReqResp: undefined,
+              downloadIntelligenceModelsReqResp: undefined,
+              clickToInterstitialWithUserDelay: undefined,
+            },
+            name: 'client.interstitial-window.launched',
           },
-          headers: {
-            authorization: false,
-            'x-prelogin-userid': preLoginId,
+          origin: {
+            buildType: 'test',
+            networkType: 'unknown',
+            upgradeChannel: 'test',
+          },
+          originTime: {
+            sent: dateAfterBatcherWait.toISOString(),
           },
-          method: 'POST',
-          resource: 'clientmetrics-prelogin',
-          service: 'metrics',
-          waitForServiceTimeout: 30,
         });
+        assert.deepEqual(webexRequestArgs.body.metrics[0].type, ['diagnostic-event']);
         assert.lengthOf(
           webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.queue,
           0
@@ -320,5 +311,49 @@ describe('internal-plugin-metrics', () => {
         );
       });
     });
+
+    describe('#submitHttpRequest', () => {
+      it('calls webex.request with the correct parameters', async () => {
+        const payload = [
+          {
+            eventPayload: {event: 'my.event'},
+            type: ['diagnostic-event'],
+          },
+        ];
+
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.savePreLoginId(
+          preLoginId
+        );
+        webex.request = sinon.stub().resolves({statusCode: 200});
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.submitHttpRequest(
+            payload
+          );
+
+        await flushPromises();
+
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        const webexRequestArgs = webex.request.args[0][0];
+
+        assert.match(webexRequestArgs, {
+          //@ts-ignore
+          body: {
+            metrics: payload,
+          },
+          headers: {
+            authorization: false,
+            'x-prelogin-userid': preLoginId,
+          },
+          method: 'POST',
+          resource: 'clientmetrics-prelogin',
+          service: 'metrics',
+          waitForServiceTimeout: 30,
+        });
+      });
+    });
   });
 });