@webex/internal-plugin-metrics 3.0.0-beta.196 → 3.0.0-beta.198

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

@@ -1,13 +1,18 @@
 import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
 import {
   clearEmptyKeysRecursively,
+  getBuildType,
   isLocusServiceErrorCode,
+  prepareDiagnosticMetricItem,
+  setMetricTimings,
 } from '../../../../src/call-diagnostic/call-diagnostic-metrics.util';
+import CallDiagnosticLatencies from '../../../../src/call-diagnostic/call-diagnostic-metrics-latencies';
 
 describe('internal-plugin-metrics', () => {
   describe('clearEmptyKeysRecursively', () => {
     it('should clear empty objects and empty nested objects recursively', () => {
-      const obj = {
+      const obj: any = {
         foo: '',
         bar: {},
         baz: [],
@@ -40,7 +45,7 @@ describe('internal-plugin-metrics', () => {
     });
 
     it('should handle nested empty objects and arrays', () => {
-      const obj = {
+      const obj: any = {
         foo: {
           bar: {},
           baz: [],
@@ -73,4 +78,259 @@ describe('internal-plugin-metrics', () => {
       });
     });
   });
+
+  describe('getBuildType', () => {
+    beforeEach(() => {
+      process.env.NODE_ENV = 'production';
+    });
+
+    [
+      ['https://localhost', 'test'],
+      ['https://127.0.0.1', 'test'],
+      ['https://web.webex.com', 'production'],
+    ].forEach(([webClientDomain, expected]) => {
+      it(`returns expected result for ${webClientDomain}`, () => {
+        assert.deepEqual(getBuildType(webClientDomain), expected);
+      });
+    });
+
+    it('returns "test" for NODE_ENV "foo"', () => {
+      process.env.NODE_ENV = 'foo';
+      assert.deepEqual(getBuildType('production'), 'test');
+    });
+  });
+
+  describe('prepareDiagnosticMetricItem', async () => {
+    let webex: any;
+
+    const check = (eventName: string, expectedEvent: any) => {
+      const eventPayload = {event: {name: eventName}};
+      const item = prepareDiagnosticMetricItem(webex, {
+        eventPayload,
+        type: ['diagnostic-event'],
+      });
+
+      assert.deepEqual(item, {
+        eventPayload: {
+          origin: {
+            buildType: 'production',
+            networkType: 'unknown',
+          },
+          event: {name: eventName, ...expectedEvent},
+        },
+        type: ['diagnostic-event'],
+      });
+    };
+
+    before(async () => {
+      webex = {internal: {newMetrics: {}}};
+      webex.internal.newMetrics.callDiagnosticLatencies = new CallDiagnosticLatencies(
+        {},
+        {parent: webex}
+      );
+    });
+
+    beforeEach(() => {
+      process.env.NODE_ENV = 'production';
+    });
+
+    afterEach(() => {
+      process.env.NODE_ENV = 'test';
+    });
+
+    [
+      ['client.exit.app', {}],
+      [
+        'client.interstitial-window.launched',
+        {
+          joinTimes: {
+            clickToInterstitial: undefined,
+            meetingInfoReqResp: undefined,
+          },
+        },
+      ],
+      [
+        'client.call.initiated',
+        {
+          joinTimes: {
+            showInterstitialTime: undefined,
+            meetingInfoReqResp: undefined,
+          },
+        },
+      ],
+      [
+        'client.locus.join.response',
+        {
+          joinTimes: {
+            meetingInfoReqResp: undefined,
+            callInitJoinReq: undefined,
+            joinReqResp: undefined,
+            joinReqSentReceived: undefined,
+            pageJmt: undefined,
+            clickToInterstitial: undefined,
+            interstitialToJoinOK: undefined,
+            totalJmt: undefined,
+            clientJmt: undefined,
+          },
+        },
+      ],
+      [
+        'client.ice.end',
+        {
+          joinTimes: {
+            ICESetupTime: undefined,
+            audioICESetupTime: undefined,
+            videoICESetupTime: undefined,
+            shareICESetupTime: undefined,
+          },
+        },
+      ],
+      [
+        'client.media.rx.start',
+        {
+          joinTimes: {
+            localSDPGenRemoteSDPRecv: undefined,
+          },
+        },
+      ],
+      [
+        'client.media-engine.ready',
+        {
+          joinTimes: {
+            totalMediaJMT: undefined,
+            interstitialToMediaOKJMT: undefined,
+            callInitMediaEngineReady: undefined,
+            stayLobbyTime: undefined,
+          },
+        },
+      ],
+      [
+        'client.mediaquality.event',
+        {
+          audioSetupDelay: {
+            joinRespRxStart: undefined,
+            joinRespTxStart: undefined,
+          },
+          videoSetupDelay: {
+            joinRespRxStart: undefined,
+            joinRespTxStart: undefined,
+          },
+        },
+      ],
+    ].forEach(([eventName, expectedEvent]) => {
+      it(`returns expected result for ${eventName}`, () => {
+        check(eventName as string, expectedEvent);
+      });
+    });
+  });
+
+  describe('setMetricTimings', async () => {
+    let webex: any;
+
+    const check = (options: any, expectedOptions: any) => {
+      const newOptions = setMetricTimings(options);
+
+      assert.deepEqual(newOptions, expectedOptions);
+    };
+
+    it(`returns expected options`, () => {
+      const now = new Date();
+      sinon.useFakeTimers(now.getTime());
+
+      const options = {
+        body: {
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      const expectedOptions = {
+        body: {
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: now.toISOString(),
+                  sent: now.toISOString(),
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      check(options, expectedOptions);
+      sinon.restore();
+    });
+
+    it(`returns expected options for multiple metrics`, () => {
+      const now = new Date();
+      sinon.useFakeTimers(now.getTime());
+
+      const options = {
+        body: {
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 777,
+                  sent: 888,
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      const expectedOptions = {
+        body: {
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: now.toISOString(),
+                  sent: now.toISOString(),
+                },
+              },
+            },
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: now.toISOString(),
+                  sent: now.toISOString(),
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      check(options, expectedOptions);
+      sinon.restore();
+    });
+
+    it(`does not throw when data missing`, () => {
+      const options = {};
+
+      const expectedOptions = {};
+
+      check(options, expectedOptions);
+    });
+  });
 });

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

@@ -3,21 +3,21 @@ import {NewMetrics} from '@webex/internal-plugin-metrics';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 
-describe("internal-plugin-metrics", () => {
-  describe("new-metrics", () => {
+describe('internal-plugin-metrics', () => {
+  describe('new-metrics', () => {
     let webex;
 
     beforeEach(() => {
       //@ts-ignore
       webex = new MockWebex({
         children: {
-          newMetrics: NewMetrics
+          newMetrics: NewMetrics,
         },
         meetings: {
           meetingCollection: {
-            get: sinon.stub()
-          }
-        }
+            get: sinon.stub(),
+          },
+        },
       });
 
       webex.emit('ready');
@@ -26,6 +26,9 @@ describe("internal-plugin-metrics", () => {
       webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps = sinon.stub();
       webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent = sinon.stub();
       webex.internal.newMetrics.callDiagnosticMetrics.submitMQE = sinon.stub();
+      webex.internal.newMetrics.callDiagnosticMetrics.buildClientEventFetchRequestOptions =
+        sinon.stub();
+      webex.setTimingsAndFetch = sinon.stub();
     });
 
     it('submits Client Event successfully', () => {
@@ -36,10 +39,10 @@ describe("internal-plugin-metrics", () => {
         },
       });
 
-      assert.calledWith(
-        webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp,
-        {key: 'client.alert.displayed', options: {meetingId: '123'}}
-      );
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.alert.displayed',
+        options: {meetingId: '123'},
+      });
       assert.calledWith(webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent, {
         name: 'client.alert.displayed',
         payload: undefined,
@@ -54,20 +57,22 @@ describe("internal-plugin-metrics", () => {
         payload: {intervals: [{}]},
         options: {
           meetingId: '123',
-          networkType: 'wifi'
-        }
+          networkType: 'wifi',
+        },
       });
 
-      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {key: 'client.mediaquality.event'})
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.mediaquality.event',
+      });
       assert.calledWith(webex.internal.newMetrics.callDiagnosticMetrics.submitMQE, {
         name: 'client.mediaquality.event',
         //@ts-ignore
         payload: {intervals: [{}]},
         options: {
           meetingId: '123',
-          networkType: 'wifi'
-        }
-      })
+          networkType: 'wifi',
+        },
+      });
     });
 
     it('submits Internal Event successfully', () => {
@@ -75,8 +80,10 @@ describe("internal-plugin-metrics", () => {
         name: 'client.mediaquality.event',
       });
 
-      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {key: 'client.mediaquality.event'})
-      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps)
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.mediaquality.event',
+      });
+      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps);
     });
 
     it('submits Internal Event successfully for clearing the join latencies', () => {
@@ -84,8 +91,63 @@ describe("internal-plugin-metrics", () => {
         name: 'internal.reset.join.latencies',
       });
 
-      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp)
-      assert.calledOnce(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps)
+      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp);
+      assert.calledOnce(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps);
+    });
+
+    describe('#buildClientEventFetchRequestOptions', () => {
+      it('builds client event fetch options successfully', () => {
+        webex.internal.newMetrics.buildClientEventFetchRequestOptions({
+          name: 'client.alert.displayed',
+          options: {
+            meetingId: '123',
+          },
+        });
+
+        assert.calledWith(
+          webex.internal.newMetrics.callDiagnosticMetrics.buildClientEventFetchRequestOptions,
+          {
+            name: 'client.alert.displayed',
+            payload: undefined,
+            options: {meetingId: '123'},
+          }
+        );
+      });
+    });
+
+    describe('#setMetricTimingsAndFetch', () => {
+      beforeEach(() => {
+        global.fetch = sinon.stub();
+      });
+
+      it('calls fetch with the expected options', () => {
+        const now = new Date();
+        sinon.useFakeTimers(now.getTime());
+
+        webex.internal.newMetrics.setMetricTimingsAndFetch({
+          body: {metrics: [{eventPayload: {}}]},
+        });
+
+        const expected = {
+          body: {
+            metrics: [
+              {
+                eventPayload: {
+                  originTime: {
+                    triggered: now.toISOString(),
+                    sent: now.toISOString(),
+                  },
+                },
+              },
+            ],
+          },
+        };
+
+        sinon.assert.calledOnce(webex.setTimingsAndFetch);
+        sinon.assert.calledWith(webex.setTimingsAndFetch, expected);
+
+        sinon.restore();
+      });
     });
-  })
-})
+  });
+});