@webex/plugin-meetings 3.0.0-beta.24 → 3.0.0-beta.241

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

@@ -1,114 +1,231 @@
-import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
-import Metrics from '@webex/plugin-meetings/src/metrics';
-
+import Meetings from '@webex/plugin-meetings';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
-
-
-describe('RoapRequest', () => {
-  describe('attachRechabilityData', () => {
-    let webex;
-
-    beforeEach(() => {
-      webex = new MockWebex();
+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,
+      },
     });
-    
-    it('attaches the reachability data when it exists', async () => {
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
-
-      const sdp = {some: 'attribute'};
 
-      const reachabilitData = {reachability: 'data'};
+    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',
-        'reachability.result',
-        JSON.stringify(reachabilitData)
-      );
+    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',
+        },
+      })
+    );
+  });
 
-      const newSdp = await roapRequest.attachRechabilityData(sdp);
+  describe('#attachReachabilityData', () => {
+    it('returns the correct reachability data', async () => {
+      const res = await roapRequest.attachReachabilityData({});
 
-      assert.deepEqual(newSdp, {
-        some: 'attribute',
-        reachability: reachabilitData
-      })
+      assert.deepEqual(res.localSdp, {
+        reachability: {
+          clusterId: {
+            udp: 'test',
+          },
+        },
+      });
+      assert.deepEqual(res.joinCookie, {
+        anycastEntryPoint: 'aws-eu-west-1',
+      });
     });
-  
-    it('handles the case when realiability data does not exist', async () => {
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
 
-      const sdp = {some: 'attribute'};
+    it('handles the case when reachability data does not exist', async () => {
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
 
-      const newSdp = await roapRequest.attachRechabilityData(sdp);
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
+      const sdp = {
+        some: 'attribute',
+      };
+
+      const result = await roapRequest.attachReachabilityData(sdp);
 
-      assert.deepEqual(newSdp, sdp);
+      assert.deepEqual(result, {
+        joinCookie: undefined,
+        localSdp: {
+          some: 'attribute',
+        },
+      });
     });
   });
 
   describe('sendRoap', () => {
-    let webex;
-
-    beforeEach(() => {
-      webex = new MockWebex();
-    });
+    it('includes joinCookie in the request correctly', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
+      const ipVersion = IP_VERSION.unknown;
 
-    it('calls attachReliabilityData', async () => {
-      Metrics.postEvent = sinon.stub();
-
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        ipVersion,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        meetingId: 'meeting-id',
+        locusMediaRequest,
+      });
 
-      const newSdp = {new: 'sdp'}
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.request',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
 
-      roapRequest.attachRechabilityData = sinon.stub().returns(Promise.resolve(newSdp));
-      webex.request.returns(Promise.resolve({
-        body: {
-          locus: {}
-        }
-      }))
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.response',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
 
-      const result = await roapRequest.sendRoap({
-        roapMessage: {seq: 1},
-        locusSelfUrl: 'locusSelfUrl',
+      const requestParams = locusMediaRequest.send.getCall(0).args[0];
+      assert.deepEqual(requestParams, {
+        type: 'RoapMessage',
+        selfUrl: locusUrl,
+        ipVersion,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
         mediaId: 'mediaId',
-        correlationId: 'correlationId',
-        audioMuted: true,
-        videoMuted: true,
-        meetingId: 'meetingId',
-        preferTranscoding: true
+        roapMessage: {
+          seq: 'seq',
+        },
+        reachability: {clusterId: {udp: 'test'}},
       });
+    });
 
-      assert.calledOnceWithExactly(webex.request, {
-        uri: 'locusSelfUrl/media',
-        method: 'PUT',
-        body: {
-          device: {
-            url: undefined,
-            deviceType: undefined,
+    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',
           },
-          correlationId: 'correlationId',
-          localMedias: [{
-            localSdp: JSON.stringify(newSdp),
-            mediaId: 'mediaId'
-          }],
-          clientMediaPreferences: {preferTranscoding: true}
-        },
-      });
+          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'},
+          },
+        });
+      }
+    });
+  });
 
-      assert.calledOnceWithExactly(roapRequest.attachRechabilityData, {
-        roapMessage: {seq: 1},
-        audioMuted: true,
-        videoMuted: true
+  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
+    });
 
-      assert.deepEqual(result, {
-        locus: {
-          roapSeq: 1
-        }
-      });
+    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,6 +25,7 @@ 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}),
@@ -40,14 +43,21 @@ describe('TurnDiscovery', () => {
       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: () => Promise.resolve(false)}}},
-      isMultistream: false
+      webex: {meetings: {reachability: {
+        isAnyClusterReachable: () => Promise.resolve(false),
+      }}},
+      isMultistream: false,
+      locusMediaRequest: { fake: true },
     };
   });
 
@@ -64,20 +74,24 @@ describe('TurnDiscovery', () => {
     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,
-      preferTranscoding: !testMeeting.isMultistream
-    });
+      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
@@ -363,6 +377,27 @@ describe('TurnDiscovery', () => {
     });
   });
 
+  describe('isSkipped', () => {
+    [
+      {enabledInConfig: true, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: true, isAnyClusterReachable: false, expectedIsSkipped: false},
+      {enabledInConfig: false, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: false, isAnyClusterReachable: false, expectedIsSkipped: true},
+    ].forEach(({enabledInConfig, isAnyClusterReachable, expectedIsSkipped}) => {
+      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyClusterReachable() returns ${isAnyClusterReachable ? 'true' : 'false'}`, async () => {
+        testMeeting.config.experimental.enableTurnDiscovery = enabledInConfig;
+
+        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyClusterReachable').resolves(isAnyClusterReachable);
+
+        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", () => {
       const td = new TurnDiscovery(mockRoapRequest);

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

@@ -0,0 +1,68 @@
+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 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('checkMetrics should send metrics if any exist in the queue', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    (metrics as any).checkMetrics();
+
+    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);
+  });
+});

package/test/unit/spec/stats-analyzer/index.js

@@ -53,7 +53,12 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
+        statsAnalyzer = new StatsAnalyzer(
+          initialConfig,
+          () => ({}),
+          networkQualityMonitor,
+          defaultStats
+        );
 
         sandBoxSpy = sandbox.spy(
           statsAnalyzer.networkQualityMonitor,
@@ -84,6 +89,7 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
+      let mqeData;
 
       let receivedEventsData = {
         local: {},
@@ -153,6 +159,9 @@ describe('plugin-meetings', () => {
                     type: 'inbound-rtp',
                     framesDecoded: 0,
                     bytesReceived: 1,
+                    frameHeight: 720,
+                    frameWidth: 1280,
+                    framesReceived: 1,
                   },
                 ],
               },
@@ -184,7 +193,7 @@ describe('plugin-meetings', () => {
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, () => ({}), networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -198,6 +207,9 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
+        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
+          mqeData = data;
+        });
       });
 
       afterEach(() => {
@@ -224,6 +236,12 @@ describe('plugin-meetings', () => {
         assert.deepEqual(receivedEventsData.remote.stopped, expected.remote?.stopped);
       };
 
+      const checkMqeData = () => {
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedFrameSize, 3600);
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedHeight, 720);
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedWidth, 1280);
+      };
+
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for audio', async () => {
         await startStatsAnalyzer({expected: {sendAudio: true}});
 
@@ -303,6 +321,15 @@ describe('plugin-meetings', () => {
 
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
+
+      it('emits the correct MEDIA_QUALITY events', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        // Check that the mqe data has been emitted and is correctly computed.
+        checkMqeData();
+      });
     });
   });
 });

package/test/utils/constants.js

@@ -0,0 +1,9 @@
+// MOVE TO TEST CONSTANTS
+export const MEDIA_SERVERS = {
+  // The homer media server for converged multistream meetings.
+  HOMER: 'homer',
+  // The linus media server
+  LINUS: 'linus',
+  // The calliope media server for transcoded meetings
+  CALLIOPE: 'calliope',
+};

package/test/utils/integrationTestUtils.js

@@ -0,0 +1,46 @@
+import {assert} from '@webex/test-helper-chai';
+import {Defer} from '@webex/common';
+
+const addMedia = async (user, options = {}) => {
+
+  const {microphone, camera} = options;
+
+  if (options.multistream) {
+    await user.meeting.addMedia({localTracks: {microphone, camera}});
+  } else {
+    const mediaReadyPromises = Array.isArray(options.expectedMediaReadyTypes)
+      ? options.expectedMediaReadyTypes.reduce((output, expectedMediaReadyType) => {
+        if (typeof expectedMediaReadyType !== 'string') {
+          return output;
+        }
+
+        output[expectedMediaReadyType] = new Defer();
+
+        return output;
+      }, {})
+      : {remoteAudio: new Defer(), remoteVideo: new Defer()};
+
+    const mediaReady = (media) => {
+      if (!media) {
+        return;
+      }
+      if (mediaReadyPromises[media.type]) {
+        mediaReadyPromises[media.type].resolve();
+      }
+    };
+
+    user.meeting.on('media:ready', mediaReady);
+
+    await user.meeting.addMedia({localTracks: {microphone, camera}});
+    await Promise.all(Object.values(mediaReadyPromises).map((defer) => defer.promise));
+ };
+
+
+  assert.exists(user.meeting.mediaProperties.audioTrack, 'audioTrack not present');
+  assert.exists(user.meeting.mediaProperties.videoTrack, 'videoTrack not present');
+
+};
+
+export default {
+  addMedia
+};

package/test/utils/testUtils.js

@@ -1,5 +1,3 @@
-import {assert} from '@webex/test-helper-chai';
-import {Defer} from '@webex/common';
 
 const max = 30000;
 const waitForSpy = (spy, event) => {
@@ -195,49 +193,7 @@ const delayedTest = (callback, timeout) =>
     }, timeout);
   });
 
-const addMedia = (user) => {
-  const mediaReadyPromises = {
-    local: new Defer(),
-    remoteAudio: new Defer(),
-    remoteVideo: new Defer(),
-  };
-  const mediaReady = (media) => {
-    if (!media) {
-      return;
-    }
-    if (mediaReadyPromises[media.type]) {
-      mediaReadyPromises[media.type].resolve();
-    }
-  };
-
-  user.meeting.on('media:ready', mediaReady);
 
-  return user.meeting
-    .getMediaStreams({
-      sendAudio: true,
-      sendVideo: true,
-      sendShare: false,
-    })
-    .then(([localStream, localShare]) =>
-      user.meeting.addMedia({
-        mediaSettings: {
-          sendAudio: true,
-          sendVideo: true,
-          sendShare: false,
-          receiveShare: true,
-          receiveAudio: true,
-          receiveVideo: true,
-        },
-        localShare,
-        localStream,
-      })
-    )
-    .then(() => Promise.all(Object.values(mediaReadyPromises).map((defer) => defer.promise)))
-    .then(() => {
-      assert.exists(user.meeting.mediaProperties.audioTrack, 'audioTrack not present');
-      assert.exists(user.meeting.mediaProperties.videoTrack, 'videoTrack not present');
-    });
-};
 
 const waitUntil = (waitTime) =>
   new Promise((resolve) => {
@@ -279,7 +235,6 @@ export default {
   waitForEvents,
   checkParticipantUpdatedStatus,
   delayedPromise,
-  addMedia,
   waitUntil,
   delayedTest,
   flushPromises,