@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.171

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

@@ -0,0 +1,225 @@
+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 {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',
+        },
+      })
+    );
+  });
+
+  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: {}}})};
+
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        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,
+        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' }
+    };
+
+    roapRequest.attachReachabilityData = sinon.stub().returns(
+      Promise.resolve({
+        localSdp: newSdp,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+      })
+    );
+
+    await roapRequest.sendRoap({
+      roapMessage: {
+        seq: 1,
+      },
+      locusSelfUrl: 'locusSelfUrl',
+      mediaId: 'mediaId',
+      meetingId: 'meetingId',
+      preferTranscoding: true,
+      locusMediaRequest
+    });
+
+    const requestParams = locusMediaRequest.send.getCall(0).args[0];
+
+    assert.deepEqual(requestParams, {
+      type: 'RoapMessage',
+      selfUrl: 'locusSelfUrl',
+      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

@@ -40,13 +40,19 @@ 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: () => false}}},
+      webex: {meetings: {reachability: {isAnyClusterReachable: () => Promise.resolve(false)}}},
+      isMultistream: false,
+      locusMediaRequest: { fake: true },
     };
   });
 
@@ -69,12 +75,10 @@ describe('TurnDiscovery', () => {
         version: '2',
         seq: expectedSeq,
       },
-      correlationId: testMeeting.correlationId,
       locusSelfUrl: testMeeting.selfUrl,
       mediaId: expectedMediaId,
-      audioMuted: testMeeting.isAudioMuted(),
-      videoMuted: testMeeting.isVideoMuted(),
       meetingId: testMeeting.id,
+      locusMediaRequest: testMeeting.locusMediaRequest
     });
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
@@ -97,39 +101,44 @@ describe('TurnDiscovery', () => {
   };
 
   describe('doTurnDiscovery', () => {
-    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK', async () => {
-      const td = new TurnDiscovery(mockRoapRequest);
+    [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 result = td.doTurnDiscovery(testMeeting, false);
+        const td = new TurnDiscovery(mockRoapRequest);
 
-      // check that TURN_DISCOVERY_REQUEST was sent
-      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+        const result = td.doTurnDiscovery(testMeeting, false);
 
-      mockRoapRequest.sendRoap.resetHistory();
+        // check that TURN_DISCOVERY_REQUEST was sent
+        await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
 
-      // 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}`,
-        ],
-      });
+        // @ts-ignore
+        mockRoapRequest.sendRoap.resetHistory();
 
-      await testUtils.flushPromises();
+        // 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}`,
+          ]
+        });
 
-      // check that we've sent OK
-      await checkRoapMessageSent('OK', 0);
+        await testUtils.flushPromises();
 
-      const {turnServerInfo, turnDiscoverySkippedReason} = await result;
+        // check that we've sent OK
+        await checkRoapMessageSent('OK', 0);
 
-      assert.deepEqual(turnServerInfo, {
-        url: FAKE_TURN_URL,
-        username: FAKE_TURN_USERNAME,
-        password: FAKE_TURN_PASSWORD,
-      });
+        const {turnServerInfo, turnDiscoverySkippedReason} = await result;
 
-      assert.isUndefined(turnDiscoverySkippedReason);
+        assert.deepEqual(turnServerInfo, {
+          url: FAKE_TURN_URL,
+          username: FAKE_TURN_USERNAME,
+          password: FAKE_TURN_PASSWORD
+        });
+
+        assert.isUndefined(turnDiscoverySkippedReason);
+      });
     });
 
     it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
@@ -141,6 +150,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
@@ -173,7 +183,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
@@ -206,7 +216,7 @@ describe('TurnDiscovery', () => {
       const prevConfigValue = testMeeting.config.experimental.enableTurnDiscovery;
 
       testMeeting.config.experimental.enableTurnDiscovery = false;
-
+      // @ts-ignore
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
@@ -236,7 +246,7 @@ describe('TurnDiscovery', () => {
 
     it('resolves with undefined when cluster is reachable', async () => {
       const prev = testMeeting.webex.meetings.reachability.isAnyClusterReachable;
-      testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => true;
+      testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => Promise.resolve(true);
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
@@ -267,6 +277,8 @@ 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: [
@@ -286,6 +298,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({});
 
@@ -301,6 +315,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({headers: []});
 
@@ -317,9 +333,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
@@ -347,6 +365,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/stats-analyzer/index.js

@@ -2,7 +2,7 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 
 import {StatsAnalyzer, EVENTS} from '../../../../src/statsAnalyzer';
 import NetworkQualityMonitor from '../../../../src/networkQualityMonitor';
@@ -24,14 +24,15 @@ describe('plugin-meetings', () => {
       };
 
       const defaultStats = {
+        resolutions: {},
         internal: {
-          video: {
+          'video-send-1': {
             send: {
               totalPacketsLostOnReceiver: 10,
             },
           },
         },
-        video: {
+        'video-send-1': {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
@@ -52,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,
@@ -65,12 +71,12 @@ describe('plugin-meetings', () => {
       });
 
       it('should trigger determineUplinkNetworkQuality with specific arguments', async () => {
-        await statsAnalyzer.parseGetStatsResult(statusResult, 'video');
+        await statsAnalyzer.parseGetStatsResult(statusResult, 'video-send-1', true);
 
         assert.calledOnce(statsAnalyzer.networkQualityMonitor.determineUplinkNetworkQuality);
         assert(
           sandBoxSpy.calledWith({
-            mediaType: 'video',
+            mediaType: 'video-send-1',
             remoteRtpResults: statusResult,
             statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
           })
@@ -83,6 +89,7 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
+      let mqeData;
 
       let receivedEventsData = {
         local: {},
@@ -110,57 +117,83 @@ describe('plugin-meetings', () => {
         // bytesReceived and bytesSent need to be non-zero in order for StatsAnalyzer to parse any other values
         fakeStats = {
           audio: {
-            receiver: {
-              type: 'inbound-rtp',
-              packetsReceived: 0,
-              bytesReceived: 1,
-            },
-            sender: {
-              type: 'outbound-rtp',
-              packetsSent: 0,
-              bytesSent: 1,
-            },
+            senders: [
+              {
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    packetsSent: 0,
+                    bytesSent: 1,
+                  },
+                ],
+              },
+            ],
+            receivers: [
+              {
+                report: [
+                  {
+                    type: 'inbound-rtp',
+                    packetsReceived: 0,
+                    bytesReceived: 1,
+                  },
+                ],
+              },
+            ],
           },
           video: {
-            receiver: {
-              type: 'inbound-rtp',
-              framesDecoded: 0,
-              bytesReceived: 1,
-            },
-            sender: {
-              type: 'outbound-rtp',
-              framesSent: 0,
-              bytesSent: 1,
-            },
+            senders: [
+              {
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    framesSent: 0,
+                    bytesSent: 1,
+                  },
+                ],
+              },
+            ],
+            receivers: [
+              {
+                report: [
+                  {
+                    type: 'inbound-rtp',
+                    framesDecoded: 0,
+                    bytesReceived: 1,
+                    frameHeight: 720,
+                    frameWidth: 1280,
+                    framesReceived: 1,
+                  },
+                ],
+              },
+            ],
           },
         };
 
         pc = {
-          getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
           getTransceiverStats: sinon.stub().resolves({
             audio: {
-              sender: [fakeStats.audio.sender],
-              receiver: [fakeStats.audio.receiver],
-              currentDirection: 'sendrecv',
-              localTrackLabel: 'fake mic',
+              senders: [fakeStats.audio.senders[0]],
+              receivers: [fakeStats.audio.receivers[0]],
             },
             video: {
-              sender: [fakeStats.video.sender],
-              receiver: [fakeStats.video.receiver],
-              currentDirection: 'sendrecv',
-              localTrackLabel: 'fake camera',
+              senders: [fakeStats.video.senders[0]],
+              receivers: [fakeStats.video.receivers[0]],
+            },
+            screenShareAudio: {
+              senders: [],
+              receivers: [],
             },
             screenShareVideo: {
-              sender: [],
-              receiver: [],
-              currentDirection: 'sendrecv',
+              senders: [],
+              receivers: [],
             },
           }),
         };
 
         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;
@@ -174,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(() => {
@@ -200,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}});
 
@@ -207,7 +249,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.sender.packetsSent += 10;
+        fakeStats.audio.senders[0].report[0].packetsSent += 10;
 
         await progressTime();
 
@@ -227,7 +269,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.sender.framesSent += 1;
+        fakeStats.video.senders[0].report[0].framesSent += 1;
 
         await progressTime();
 
@@ -247,7 +289,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.receiver.packetsReceived += 5;
+        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for audio
@@ -267,7 +309,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.receiver.framesDecoded += 1;
+        fakeStats.video.receivers[0].report[0].framesDecoded += 1;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for video
@@ -279,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',
+};