@webex/internal-plugin-metrics 3.0.0-beta.26 → 3.0.0-beta.260

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

@@ -0,0 +1,479 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import * as CallDiagnosticUtils from '../../../../src/call-diagnostic/call-diagnostic-metrics.util';
+import CallDiagnosticLatencies from '../../../../src/call-diagnostic/call-diagnostic-metrics-latencies';
+
+const  {
+  clearEmptyKeysRecursively,
+  extractVersionMetadata,
+  getBuildType,
+  isBrowserMediaErrorName,
+  isLocusServiceErrorCode,
+  isMeetingInfoServiceError,
+  prepareDiagnosticMetricItem,
+  setMetricTimings,
+} = CallDiagnosticUtils;
+
+describe('internal-plugin-metrics', () => {
+  describe('clearEmptyKeysRecursively', () => {
+    it('should clear empty objects and empty nested objects recursively', () => {
+      const obj: any = {
+        foo: '',
+        bar: {},
+        baz: [],
+        nested: {
+          prop: {},
+          arr: ['test'],
+        },
+      };
+      clearEmptyKeysRecursively(obj);
+      console.log(obj);
+      assert.deepEqual(obj, {nested: {arr: ['test']}});
+    });
+
+    it('should not modify non-empty objects and arrays', () => {
+      const obj = {
+        foo: 'bar',
+        arr: [1, 2, 3],
+      };
+      clearEmptyKeysRecursively(obj);
+      assert.deepEqual(obj, {foo: 'bar', arr: [1, 2, 3]});
+    });
+
+    it('should not modify non-object and non-array values', () => {
+      const obj = {
+        prop1: 'value1',
+        prop2: 123,
+      };
+      clearEmptyKeysRecursively(obj);
+      assert.deepEqual(obj, {prop1: 'value1', prop2: 123});
+    });
+
+    it('should handle nested empty objects and arrays', () => {
+      const obj: any = {
+        foo: {
+          bar: {},
+          baz: [],
+        },
+      };
+      clearEmptyKeysRecursively(obj);
+      assert.deepEqual(obj, {foo: {}});
+    });
+
+    it('should handle an empty input object', () => {
+      const obj = {};
+      clearEmptyKeysRecursively(obj);
+      assert.deepEqual(obj, {});
+    });
+  });
+
+  describe('isLocusServiceErrorCode', () => {
+    [
+      [10000, false],
+      [2400000, true],
+      ['2400000', true],
+      [2400001, true],
+      ['2400001', true],
+      [240000, false],
+      [14000000, false],
+    ].forEach(([error, expected]) => {
+      it(`for code ${error} returns the correct result`, () => {
+        //@ts-ignore
+        assert.deepEqual(isLocusServiceErrorCode(error), expected);
+      });
+    });
+  });
+
+  describe('isMeetingInfoServiceError', () => {
+    [
+      [{body: {data: {meetingInfo: 'something'}}}, true],
+      [{body: {url: 'abcde-123-wbxappapi-efgh'}}, true],
+      [{body: {data: {meetingInformation: 'something'}}}, false],
+      [{body: {uri: 'abcde-123-wbxappap-efgh'}}, false],
+      ['2400001', false],
+      [2400001, false],
+      [{}, false],
+    ].forEach(([rawError, expected]) => {
+      it(`for rawError ${rawError} returns the correct result`, () => {
+        //@ts-ignore
+        assert.deepEqual(isMeetingInfoServiceError(rawError), expected);
+      });
+    });
+  });
+
+  describe('isBrowserMediaErrorName', () => {
+    [
+      ['PermissionDeniedError', true],
+      ['PermissionDeniedErrors', false],
+      ['NotAllowedError', true],
+      ['NotAllowedErrors', false],
+      ['NotReadableError', true],
+      ['NotReadableErrors', false],
+      ['AbortError', true],
+      ['AbortErrors', false],
+      ['NotFoundError', true],
+      ['NotFoundErrors', false],
+      ['OverconstrainedError', true],
+      ['OverconstrainedErrors', false],
+      ['SecurityError', true],
+      ['SecurityErrors', false],
+      ['TypeError', true],
+      ['TypeErrors', false],
+      ['', false],
+      ['SomethingElse', false],
+      [{name: 'SomethingElse'}, false],
+
+    ].forEach(([errorName, expected]) => {
+      it(`for rawError ${errorName} returns the correct result`, () => {
+        //@ts-ignore
+        assert.deepEqual(isBrowserMediaErrorName(errorName), expected);
+      });
+    });
+  });
+
+  describe('getBuildType', () => {
+    beforeEach(() => {
+      process.env.NODE_ENV = 'production';
+    });
+
+    [
+      ['https://localhost', undefined, 'test'],
+      ['https://127.0.0.1', undefined, 'test'],
+      ['https://web.webex.com', undefined, 'prod'],
+      ['https://web.webex.com', true, 'test'],
+    ].forEach(([webClientDomain, markAsTestEvent, expected]) => {
+      it(`returns expected result for ${webClientDomain}`, () => {
+        assert.deepEqual(getBuildType(webClientDomain, markAsTestEvent as any), expected);
+      });
+    });
+
+    it('returns "test" for NODE_ENV "foo"', () => {
+      process.env.NODE_ENV = 'foo';
+      assert.deepEqual(getBuildType('production'), 'test');
+    });
+
+    it('returns "test" for NODE_ENV "production" and markAsTestEvent = true', () => {
+      process.env.NODE_ENV = 'production';
+      assert.deepEqual(getBuildType('my.domain', true), '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: 'prod',
+            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);
+      });
+    });
+
+    it('calls getBuildType correctly', () => {
+      const getBuildTypeSpy = sinon.spy(CallDiagnosticUtils, 'getBuildType');
+      const markAsTestEvent = true;
+      const webClientDomain = 'https://web.webex.com';
+
+      // just submit any event
+      prepareDiagnosticMetricItem(webex, {
+        eventPayload: {
+          event: {name: 'client.exit.app', eventData: {markAsTestEvent, webClientDomain}}
+        },
+        type: ['diagnostic-event'],
+      });
+
+      assert.calledOnceWithExactly(getBuildTypeSpy, webClientDomain, markAsTestEvent);
+    })
+  });
+
+  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 = {
+        json: true,
+        body: JSON.stringify({
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+          ],
+        }),
+      };
+
+      const expectedOptions = {
+        json: true,
+        body: JSON.stringify({
+          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 = {
+        json: true,
+        body: JSON.stringify({
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 777,
+                  sent: 888,
+                },
+              },
+            },
+          ],
+        }),
+      };
+
+      const expectedOptions = {
+        json: true,
+        body: JSON.stringify({
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: now.toISOString(),
+                  sent: now.toISOString(),
+                },
+              },
+            },
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: now.toISOString(),
+                  sent: now.toISOString(),
+                },
+              },
+            },
+          ],
+        }),
+      };
+
+      check(options, expectedOptions);
+      sinon.restore();
+    });
+
+    it(`returns expected options when json is falsey`, () => {
+      const now = new Date();
+      sinon.useFakeTimers(now.getTime());
+
+      const options = {
+        body: JSON.stringify({
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+          ],
+        }),
+      };
+
+      const expectedOptions = {
+        body: JSON.stringify({
+          metrics: [
+            {
+              eventPayload: {
+                originTime: {
+                  triggered: 555,
+                  sent: 666,
+                },
+              },
+            },
+          ],
+        }),
+      };
+
+      check(options, expectedOptions);
+      sinon.restore();
+    });
+
+    it(`does not throw when there is no body`, () => {
+      const options = {};
+
+      const expectedOptions = {};
+
+      check(options, expectedOptions);
+    });
+
+    it(`does not throw when body is empty`, () => {
+      const options = {body: '"{}"'};
+
+      const expectedOptions = {body: '"{}"'};
+
+      check(options, expectedOptions);
+    });
+  });
+
+  describe('extractVersionMetadata', () => {
+    [
+      ['1.2.3', {majorVersion: 1, minorVersion: 2}],
+      ['0.0.1', {majorVersion: 0, minorVersion: 0}],
+      ['0.0.0', {majorVersion: 0, minorVersion: 0}],
+      ['1.2', {majorVersion: 1, minorVersion: 2}],
+      ['1', {majorVersion: 1, minorVersion: NaN}],
+      ['foo', {majorVersion: NaN, minorVersion: NaN}],
+      ['1.foo', {majorVersion: 1, minorVersion: NaN}],
+      ['foo.1', {majorVersion: NaN, minorVersion: 1}],
+      ['foo.bar', {majorVersion: NaN, minorVersion: NaN}],
+    ].forEach(([version, expected]) => {
+      it(`returns expected result for ${version}`, () => {
+        assert.deepEqual(extractVersionMetadata(version as string), expected);
+      });
+    });
+  });
+});

package/test/unit/spec/metrics.js

@@ -8,6 +8,9 @@ import {Token, Credentials} from '@webex/webex-core';
 import FakeTimers from '@sinonjs/fake-timers';
 import sinon from 'sinon';
 import Metrics, {config} from '@webex/internal-plugin-metrics';
+import {BrowserDetection} from '@webex/common';
+
+const {getOSVersion} = BrowserDetection();
 
 function promiseTick(count) {
   let promise = Promise.resolve();
@@ -102,7 +105,6 @@ describe('plugin-metrics', () => {
       sinon.spy(webex, 'request');
       sinon.spy(metrics, 'postPreLoginMetric');
       sinon.spy(metrics, 'aliasUser');
-      sinon.spy(metrics, 'submitCallDiagnosticEvents');
     });
 
     describe('#submit()', () => {
@@ -131,6 +133,67 @@ describe('plugin-metrics', () => {
       });
     });
 
+    describe('#getClientMetricsPayload()', () => {
+      it('returns the expected payload', () => {
+        webex.credentials.supertoken = new Token(
+          {
+            access_token: 'a_b_orgid',
+          },
+          {parent: webex}
+        );
+
+        const testPayload = {
+          tags: {success: true},
+          fields: {perceivedDurationInMillis: 314},
+          context: {},
+          eventPayload: {value: 'splunk business metric payload'},
+        };
+        const date = clock.now;
+
+        const result = metrics.getClientMetricsPayload('test', testPayload);
+
+        assert.deepEqual(result, {
+          context: {
+            app: {
+              version: undefined,
+            },
+            locale: 'en-US',
+            os: {
+              name: 'other',
+              version: getOSVersion(),
+            },
+          },
+          eventPayload: {
+            value: 'splunk business metric payload',
+          },
+          fields: {
+            browser_version: '',
+            client_id: 'fake',
+            os_version: getOSVersion(),
+            perceivedDurationInMillis: 314,
+            platform: 'Web',
+            sdk_version: undefined,
+            spark_user_agent: 'webex-js-sdk appName/appVersion appPlatform',
+          },
+          metricName: 'test',
+          tags: {
+            browser: '',
+            domain: 'whatever',
+            os: 'other',
+            success: true,
+          },
+          timestamp: 0,
+          type: ['operational'],
+        });
+      });
+
+      it('throws when no event name is specified', () => {
+        assert.throws(() => {
+          metrics.getClientMetricsPayload();
+        }, 'Missing behavioral metric name. Please provide one');
+      });
+    });
+
     describe('#submitClientMetrics()', () => {
       describe('before login', () => {
         it('posts pre-login metric', () => {
@@ -199,17 +262,15 @@ describe('plugin-metrics', () => {
               assert.property(metric, 'eventPayload');
 
               assert.property(metric.tags, 'browser');
-              assert.property(metric.tags, 'org_id');
               assert.property(metric.tags, 'os');
               assert.property(metric.tags, 'domain');
-              assert.property(metric.tags, 'client_id');
-              assert.property(metric.tags, 'user_id');
 
               assert.property(metric.fields, 'browser_version');
               assert.property(metric.fields, 'os_version');
               assert.property(metric.fields, 'sdk_version');
               assert.property(metric.fields, 'platform');
               assert.property(metric.fields, 'spark_user_agent');
+              assert.property(metric.fields, 'client_id');
 
               assert.property(metric.context, 'app');
               assert.property(metric.context, 'locale');
@@ -269,98 +330,5 @@ describe('plugin-metrics', () => {
           assert.match(params, {alias: true});
         }));
     });
-
-    describe('#submitCallDiagnosticEvents()', () => {
-      it('submits a call diagnostic event', () => {
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'test');
-          });
-      });
-
-      it('submits a call diagnostic event with buildType set in the payload', () => {
-        const promise = metrics.submitCallDiagnosticEvents({
-          ...mockCallDiagnosticEvent,
-          origin: {
-            buildType: 'prod',
-          },
-        });
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'prod');
-          });
-      });
-
-      xit('submits a call diagnostic event with a test domain', () => {
-        global.window.location.hostname = 'test.webex.com';
-
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'test');
-          });
-      });
-
-      // Skip because it's current unable to overwrite NODE_ENV
-      // However doing `NODE_ENV=test npm run test ...` will get this test case to pass
-      xit('submits a call diagnostic event with a NODE_ENV=production', () => {
-        process.env.NODE_ENV = 'production';
-
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'prod');
-          });
-      });
-    });
   });
 });