@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

package/test/unit/spec/roap/request.ts

@@ -0,0 +1,232 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings/roap', () => {
+  let roapRequest;
+  let webex;
+  const locusUrl = 'locusUrl';
+
+  beforeEach(async () => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns(locusUrl),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+      device: {
+        url: 'url',
+      },
+      newMetrics: {
+        submitClientEvent: sinon.stub()
+      },
+    };
+
+    // @ts-ignore
+    roapRequest = new RoapRequest({webex});
+
+    roapRequest.request = sinon.mock().returns(
+      Promise.resolve({
+        body: {
+          locus: {
+            roapSeq: '',
+            id: '',
+            url: 'url/path',
+            fullState: {
+              lastActive: 'lastActive',
+            },
+          },
+        },
+      })
+    );
+
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageJoinCookie,
+      JSON.stringify({
+        anycastEntryPoint: 'aws-eu-west-1',
+      })
+    );
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageResult,
+      JSON.stringify({
+        clusterId: {
+          udp: 'test',
+          isVideoMesh: false,
+        },
+      })
+    );
+  });
+
+  describe('#attachReachabilityData', () => {
+    it('returns the correct reachability data', async () => {
+      const res = await roapRequest.attachReachabilityData({});
+
+      assert.deepEqual(res.localSdp, {
+        reachability: {
+          clusterId: {
+            udp: 'test',
+          },
+        },
+      });
+      assert.deepEqual(res.joinCookie, {
+        anycastEntryPoint: 'aws-eu-west-1',
+      });
+    });
+
+    it('handles the case when reachability data does not exist', async () => {
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
+
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
+      const sdp = {
+        some: 'attribute',
+      };
+
+      const result = await roapRequest.attachReachabilityData(sdp);
+
+      assert.deepEqual(result, {
+        joinCookie: undefined,
+        localSdp: {
+          some: 'attribute',
+        },
+      });
+    });
+  });
+
+  describe('sendRoap', () => {
+    it('includes joinCookie in the request correctly', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
+      const ipVersion = IP_VERSION.unknown;
+
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        ipVersion,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        meetingId: 'meeting-id',
+        locusMediaRequest,
+      });
+
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.request',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
+
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.response',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
+
+      const requestParams = locusMediaRequest.send.getCall(0).args[0];
+      assert.deepEqual(requestParams, {
+        type: 'RoapMessage',
+        selfUrl: locusUrl,
+        ipVersion,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        reachability: {clusterId: {udp: 'test'}},
+      });
+    });
+
+    it('sends correct client event when fails', async () => {
+      const locusMediaRequest = {send: sinon.stub().rejects({code: 300, message: 'error'})};
+      try {
+        await roapRequest.sendRoap({
+          locusSelfUrl: locusUrl,
+          mediaId: 'mediaId',
+          roapMessage: {
+            seq: 'seq',
+          },
+          meetingId: 'meeting-id',
+          locusMediaRequest,
+        });
+      } catch (err) {
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.response',
+          options: {
+            meetingId: 'meeting-id',
+            rawError: {code: 300, message: 'error'},
+          },
+        });
+      }
+    });
+  });
+
+  it('calls attachReachabilityData when sendRoap', async () => {
+    const locusMediaRequest = { send: sinon.stub().resolves({body: {locus: {}}})};
+
+    const newSdp = {
+      new: 'sdp',
+      reachability: { someResult: 'whatever' }
+    };
+    const ipVersion = IP_VERSION.only_ipv6;
+
+    roapRequest.attachReachabilityData = sinon.stub().returns(
+      Promise.resolve({
+        localSdp: newSdp,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+      })
+    );
+
+    await roapRequest.sendRoap({
+      roapMessage: {
+        seq: 1,
+      },
+      locusSelfUrl: 'locusSelfUrl',
+      ipVersion,
+      mediaId: 'mediaId',
+      meetingId: 'meetingId',
+      preferTranscoding: true,
+      locusMediaRequest
+    });
+
+    const requestParams = locusMediaRequest.send.getCall(0).args[0];
+
+    assert.deepEqual(requestParams, {
+      type: 'RoapMessage',
+      selfUrl: 'locusSelfUrl',
+      ipVersion,
+      joinCookie: {
+        anycastEntryPoint: 'aws-eu-west-1',
+      },
+      mediaId: 'mediaId',
+      roapMessage: {
+        seq: 1,
+      },
+      reachability: { someResult: 'whatever' },
+    });
+
+    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
+      roapMessage: {
+        seq: 1,
+      },
+    });
+  });
+});

package/test/unit/spec/roap/turnDiscovery.ts

@@ -5,8 +5,10 @@ import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 
 import testUtils from '../../../utils/testUtils';
+import { IP_VERSION } from '../../../../src/constants';
 
 describe('TurnDiscovery', () => {
   let clock;
@@ -23,30 +25,34 @@ describe('TurnDiscovery', () => {
     clock = sinon.useFakeTimers();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
 
     mockRoapRequest = {
-      sendRoap: sinon.fake.resolves({mediaConnections: FAKE_MEDIA_CONNECTIONS_FROM_LOCUS})
+      sendRoap: sinon.fake.resolves({mediaConnections: FAKE_MEDIA_CONNECTIONS_FROM_LOCUS}),
     } as unknown as RoapRequest;
 
     testMeeting = {
       id: 'fake meeting id',
-      config: {
-        experimental: {
-          enableTurnDiscovery: true
-        }
-      },
       correlationId: 'fake correlation id',
       selfUrl: 'fake self url',
       mediaId: 'fake media id',
       locusUrl: `https://locus-a.wbx2.com/locus/api/v1/loci/${FAKE_LOCUS_ID}`,
       roapSeq: -1,
-      isAudioMuted: () => true,
-      isVideoMuted: () => false,
+      audio:{
+        isLocallyMuted: () => true,
+      },
+      video:{
+        isLocallyMuted: () => false,
+      },
       setRoapSeq: sinon.fake((newSeq) => {
         testMeeting.roapSeq = newSeq;
       }),
       updateMediaConnections: sinon.stub(),
-      webex: {meetings: {reachability: {isAnyClusterReachable: () => false}}}
+      webex: {meetings: {reachability: {
+        isAnyPublicClusterReachable: () => Promise.resolve(false),
+      }}},
+      isMultistream: false,
+      locusMediaRequest: { fake: true },
     };
   });
 
@@ -55,23 +61,32 @@ describe('TurnDiscovery', () => {
     sinon.restore();
   });
 
-  const checkRoapMessageSent = async (messageType, expectedSeq, expectedMediaId = testMeeting.mediaId) => {
+  const checkRoapMessageSent = async (
+    messageType,
+    expectedSeq,
+    expectedMediaId = testMeeting.mediaId
+  ) => {
     await testUtils.flushPromises();
 
     assert.calledOnce(mockRoapRequest.sendRoap);
-    assert.calledWith(mockRoapRequest.sendRoap, {
+
+    const expectedSendRoapArgs: any = {
       roapMessage: {
         messageType,
         version: '2',
         seq: expectedSeq,
       },
-      correlationId: testMeeting.correlationId,
       locusSelfUrl: testMeeting.selfUrl,
       mediaId: expectedMediaId,
-      audioMuted: testMeeting.isAudioMuted(),
-      videoMuted: testMeeting.isVideoMuted(),
-      meetingId: testMeeting.id
-    });
+      meetingId: testMeeting.id,
+      locusMediaRequest: testMeeting.locusMediaRequest,
+    };
+
+    if (messageType === 'TURN_DISCOVERY_REQUEST') {
+      expectedSendRoapArgs.ipVersion = 0;
+    }
+    
+    assert.calledWith(mockRoapRequest.sendRoap, expectedSendRoapArgs);
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
       // check also that we've applied the media connections from the response
@@ -93,16 +108,60 @@ describe('TurnDiscovery', () => {
   };
 
   describe('doTurnDiscovery', () => {
-    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK', async () => {
+    [false, true].forEach(function (enabledMultistream ) {
+      it('sends TURN_DISCOVERY_REQUEST'+  (enabledMultistream ? ' when enable Multistream':'') + ', waits for response and sends OK', async () => {
+        testMeeting.isMultistream = enabledMultistream;
+
+        const td = new TurnDiscovery(mockRoapRequest);
+
+        const result = td.doTurnDiscovery(testMeeting, false);
+
+        // check that TURN_DISCOVERY_REQUEST was sent
+        await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+
+        // @ts-ignore
+        mockRoapRequest.sendRoap.resetHistory();
+
+        // simulate the response
+        td.handleTurnDiscoveryResponse({
+          headers: [
+            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+            `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+          ]
+        });
+
+        await testUtils.flushPromises();
+
+        // check that we've sent OK
+        await checkRoapMessageSent('OK', 0);
+
+        const {turnServerInfo, turnDiscoverySkippedReason} = await result;
+
+        assert.deepEqual(turnServerInfo, {
+          url: FAKE_TURN_URL,
+          username: FAKE_TURN_USERNAME,
+          password: FAKE_TURN_PASSWORD
+        });
+
+        assert.isUndefined(turnDiscoverySkippedReason);
+      });
+    });
+
+    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK when isForced = true when cluster is reachable', async () => {
+      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = sinon.stub().resolves(true);
+
       const td = new TurnDiscovery(mockRoapRequest);
+      const result = td.doTurnDiscovery(testMeeting, false, true);
 
-      const result = td.doTurnDiscovery(testMeeting, false);
+      // We ignore reachability results so we don't get skip reason
+      assert.notCalled(testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable);
 
       // check that TURN_DISCOVERY_REQUEST was sent
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
-
+      // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
-
       // simulate the response
       td.handleTurnDiscoveryResponse({
         headers: [
@@ -111,21 +170,20 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
         ]
       });
-
       await testUtils.flushPromises();
-
       // check that we've sent OK
       await checkRoapMessageSent('OK', 0);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = await result;
-
       assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD
       });
-
       assert.isUndefined(turnDiscoverySkippedReason);
+
+      // restore previous callback
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
     });
 
     it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
@@ -137,6 +195,7 @@ describe('TurnDiscovery', () => {
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0, '');
 
       // the main part of the test is complete now, checking the remaining part of the flow just for completeness
+      // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
 
       // simulate the response
@@ -145,7 +204,7 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-        ]
+        ],
       });
 
       await testUtils.flushPromises();
@@ -158,7 +217,7 @@ describe('TurnDiscovery', () => {
       assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
-        password: FAKE_TURN_PASSWORD
+        password: FAKE_TURN_PASSWORD,
       });
       assert.isUndefined(turnDiscoverySkippedReason);
     });
@@ -169,7 +228,7 @@ describe('TurnDiscovery', () => {
 
       // check that TURN_DISCOVERY_REQUEST was sent
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
-
+      // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
 
       // simulate the response with some extra headers
@@ -181,7 +240,7 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           'another-header-at-the-end=12345',
-        ]
+        ],
       });
 
       await testUtils.flushPromises();
@@ -193,29 +252,11 @@ describe('TurnDiscovery', () => {
       assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
-        password: FAKE_TURN_PASSWORD
+        password: FAKE_TURN_PASSWORD,
       });
       assert.isUndefined(turnDiscoverySkippedReason);
     });
 
-    it('resolves with undefined if turn discovery feature is disabled in config', async () => {
-      const prevConfigValue = testMeeting.config.experimental.enableTurnDiscovery;
-
-      testMeeting.config.experimental.enableTurnDiscovery = false;
-
-      const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
-
-      const {turnServerInfo, turnDiscoverySkippedReason} = result;
-
-      assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, 'config');
-      assert.notCalled(mockRoapRequest.sendRoap);
-      assert.notCalled(Metrics.sendBehavioralMetric);
-
-      // restore previous config
-      testMeeting.config.experimental.enableTurnDiscovery = prevConfigValue;
-    });
-
     it('resolves with undefined if sending the request fails', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
@@ -231,8 +272,8 @@ describe('TurnDiscovery', () => {
     });
 
     it('resolves with undefined when cluster is reachable', async () => {
-      const prev = testMeeting.webex.meetings.reachability.isAnyClusterReachable;
-      testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => true;
+      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = () => Promise.resolve(true);
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
@@ -241,11 +282,10 @@ describe('TurnDiscovery', () => {
       assert.equal(turnDiscoverySkippedReason, 'reachability');
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
-      testMeeting.webex.meetings.reachability.isAnyClusterReachable = prev;
-
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
     });
 
-    it('resolves with undefined if we don\'t get a response within 10s', async () => {
+    it("resolves with undefined if we don't get a response within 10s", async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
       const promise = td.doTurnDiscovery(testMeeting, false);
@@ -264,12 +304,14 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
+      await testUtils.flushPromises();
+
       // simulate the response without the password
       td.handleTurnDiscoveryResponse({
         headers: [
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
-        ]
+        ],
       });
       await testUtils.flushPromises();
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
@@ -283,6 +325,8 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
+      await testUtils.flushPromises();
+
       // simulate the response without the headers
       td.handleTurnDiscoveryResponse({});
 
@@ -298,11 +342,13 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
+      await testUtils.flushPromises();
+
       // simulate the response without the headers
       td.handleTurnDiscoveryResponse({headers: []});
 
       await testUtils.flushPromises();
-      const {turnServerInfo, turnDiscoverySkippedReason}= await turnDiscoveryPromise;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
       assert.isUndefined(turnDiscoverySkippedReason);
@@ -314,9 +360,11 @@ describe('TurnDiscovery', () => {
 
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
+      await testUtils.flushPromises();
+
       // check that TURN_DISCOVERY_REQUEST was sent
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
-
+      // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
 
       // setup the mock so that sending of OK fails
@@ -328,7 +376,7 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-        ]
+        ],
       });
 
       await testUtils.flushPromises();
@@ -344,8 +392,25 @@ describe('TurnDiscovery', () => {
     });
   });
 
+  describe('isSkipped', () => {
+    [
+      {isAnyPublicClusterReachable: true, expectedIsSkipped: true},
+      {isAnyPublicClusterReachable: false, expectedIsSkipped: false},
+    ].forEach(({isAnyPublicClusterReachable, expectedIsSkipped}) => {
+      it(`returns ${expectedIsSkipped} when isAnyPublicClusterReachable() returns ${isAnyPublicClusterReachable ? 'true' : 'false'}`, async () => {
+        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyPublicClusterReachable').resolves(isAnyPublicClusterReachable);
+
+        const td = new TurnDiscovery(mockRoapRequest);
+
+        const isSkipped = await td.isSkipped(testMeeting);
+
+        assert.equal(isSkipped, expectedIsSkipped);
+      })
+    })
+  })
+
   describe('handleTurnDiscoveryResponse', () => {
-    it('doesn\'t do anything if turn discovery was not started', () => {
+    it("doesn't do anything if turn discovery was not started", () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
       // there is not much we can check, but we mainly want to make
@@ -355,7 +420,7 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-        ]
+        ],
       });
 
       assert.notCalled(mockRoapRequest.sendRoap);

package/test/unit/spec/rtcMetrics/index.ts

@@ -0,0 +1,73 @@
+import RtcMetrics from '@webex/plugin-meetings/src/rtcMetrics';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import RTC_METRICS from '../../../../src/rtcMetrics/constants';
+
+const FAKE_METRICS_ITEM = {payload: ['fake-metrics']};
+
+describe('RtcMetrics', () => {
+  let metrics: RtcMetrics;
+  let webex: MockWebex;
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+    webex = new MockWebex();
+    metrics = new RtcMetrics(webex, 'mock-meeting-id', 'mock-correlation-id');
+  });
+
+  it('sendMetrics should send a webex request', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    (metrics as any).sendMetrics();
+
+    assert.callCount(webex.request, 1);
+    assert.calledWithMatch(webex.request, sinon.match.has('headers', {
+      type: 'webrtcMedia',
+      appId: RTC_METRICS.APP_ID,
+    }));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].data[0].payload', FAKE_METRICS_ITEM.payload));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].meetingId', 'mock-meeting-id'));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].correlationId', 'mock-correlation-id'));
+  });
+
+  it('should have a defined sendMetricsInQueue function which is public', () => {
+    assert.isDefined(metrics.sendMetricsInQueue);
+    assert.isFunction(metrics.sendMetricsInQueue);
+  });
+
+  it('should send metrics requests over time', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    assert.deepEqual(metrics.metricsQueue, [FAKE_METRICS_ITEM]);
+    clock.tick(60 * 1000);
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should not send requests with no items in the queue', () => {
+    clock.tick(60 * 1000);
+    assert.notCalled(webex.request);
+  });
+
+  it('sendMetricsInQueue should send metrics if any exist in the queue', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    (metrics as any).sendMetricsInQueue();
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should clear out metrics on close', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    metrics.closeMetrics();
+
+    assert.callCount(webex.request, 1);
+  });
+});