@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.20

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

@@ -4,12 +4,13 @@ import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
 
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import Roap from '@webex/plugin-meetings/src/roap/';
+import Meeting from '@webex/plugin-meetings/src/meeting';
 
 describe('Roap', () => {
   describe('doTurnDiscovery', () => {
     it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
       const RESULT = {something: 'some value'};
-      const meeting = {id: 'some meeting id'};
+      const meeting = {id: 'some meeting id'} as Meeting;
 
       const doTurnDiscoveryStub = sinon
         .stub(TurnDiscovery.prototype, 'doTurnDiscovery')

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

@@ -0,0 +1,114 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+
+
+describe('RoapRequest', () => {
+  describe('attachRechabilityData', () => {
+    let webex;
+
+    beforeEach(() => {
+      webex = new MockWebex();
+    });
+    
+    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'};
+
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(reachabilitData)
+      );
+
+      const newSdp = await roapRequest.attachRechabilityData(sdp);
+
+      assert.deepEqual(newSdp, {
+        some: 'attribute',
+        reachability: reachabilitData
+      })
+    });
+  
+    it('handles the case when realiability data does not exist', async () => {
+      // @ts-ignore
+      const roapRequest = new RoapRequest({}, {parent: webex});
+
+      const sdp = {some: 'attribute'};
+
+      const newSdp = await roapRequest.attachRechabilityData(sdp);
+
+      assert.deepEqual(newSdp, sdp);
+    });
+  });
+
+  describe('sendRoap', () => {
+    let webex;
+
+    beforeEach(() => {
+      webex = new MockWebex();
+    });
+
+    it('calls attachReliabilityData', async () => {
+      Metrics.postEvent = sinon.stub();
+
+      // @ts-ignore
+      const roapRequest = new RoapRequest({}, {parent: webex});
+
+      const newSdp = {new: 'sdp'}
+
+      roapRequest.attachRechabilityData = sinon.stub().returns(Promise.resolve(newSdp));
+      webex.request.returns(Promise.resolve({
+        body: {
+          locus: {}
+        }
+      }))
+
+      const result = await roapRequest.sendRoap({
+        roapMessage: {seq: 1},
+        locusSelfUrl: 'locusSelfUrl',
+        mediaId: 'mediaId',
+        correlationId: 'correlationId',
+        audioMuted: true,
+        videoMuted: true,
+        meetingId: 'meetingId',
+        preferTranscoding: true
+      });
+
+      assert.calledOnceWithExactly(webex.request, {
+        uri: 'locusSelfUrl/media',
+        method: 'PUT',
+        body: {
+          device: {
+            url: undefined,
+            deviceType: undefined,
+          },
+          correlationId: 'correlationId',
+          localMedias: [{
+            localSdp: JSON.stringify(newSdp),
+            mediaId: 'mediaId'
+          }],
+          clientMediaPreferences: {preferTranscoding: true}
+        },
+      });
+
+      assert.calledOnceWithExactly(roapRequest.attachRechabilityData, {
+        roapMessage: {seq: 1},
+        audioMuted: true,
+        videoMuted: true
+      })
+
+      assert.deepEqual(result, {
+        locus: {
+          roapSeq: 1
+        }
+      });
+    });
+  })
+});

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

@@ -25,15 +25,15 @@ describe('TurnDiscovery', () => {
     sinon.stub(Metrics, 'sendBehavioralMetric');
 
     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
-        }
+          enableTurnDiscovery: true,
+        },
       },
       correlationId: 'fake correlation id',
       selfUrl: 'fake self url',
@@ -46,7 +46,8 @@ describe('TurnDiscovery', () => {
         testMeeting.roapSeq = newSeq;
       }),
       updateMediaConnections: sinon.stub(),
-      webex: {meetings: {reachability: {isAnyClusterReachable: () => false}}}
+      webex: {meetings: {reachability: {isAnyClusterReachable: () => Promise.resolve(false)}}},
+      isMultistream: false
     };
   });
 
@@ -55,7 +56,11 @@ 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);
@@ -70,7 +75,8 @@ describe('TurnDiscovery', () => {
       mediaId: expectedMediaId,
       audioMuted: testMeeting.isAudioMuted(),
       videoMuted: testMeeting.isVideoMuted(),
-      meetingId: testMeeting.id
+      meetingId: testMeeting.id,
+      preferTranscoding: !testMeeting.isMultistream
     });
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
@@ -93,39 +99,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 () => {
@@ -137,6 +148,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 +157,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 +170,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 +181,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 +193,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,7 +205,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);
     });
@@ -202,7 +214,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;
@@ -232,7 +244,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;
@@ -242,10 +254,9 @@ describe('TurnDiscovery', () => {
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
       testMeeting.webex.meetings.reachability.isAnyClusterReachable = 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 +275,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 +296,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 +313,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 +331,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 +347,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();
@@ -345,7 +364,7 @@ describe('TurnDiscovery', () => {
   });
 
   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 +374,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/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';
@@ -20,31 +20,31 @@ describe('plugin-meetings', () => {
       let sandBoxSpy;
 
       const initialConfig = {
-        videoPacketLossRatioThreshold: 9
+        videoPacketLossRatioThreshold: 9,
       };
 
       const defaultStats = {
         internal: {
           video: {
             send: {
-              totalPacketsLostOnReceiver: 10
-            }
-          }
+              totalPacketsLostOnReceiver: 10,
+            },
+          },
         },
         video: {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
-            meanRoundTripTime: []
-          }
-        }
+            meanRoundTripTime: [],
+          },
+        },
       };
 
       const statusResult = {
         type: 'remote-inbound-rtp',
         packetsLost: 11,
         rttThreshold: 501,
-        jitterThreshold: 501
+        jitterThreshold: 501,
       };
 
       const sandbox = sinon.createSandbox();
@@ -54,7 +54,10 @@ describe('plugin-meetings', () => {
 
         statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
 
-        sandBoxSpy = sandbox.spy(statsAnalyzer.networkQualityMonitor, 'determineUplinkNetworkQuality');
+        sandBoxSpy = sandbox.spy(
+          statsAnalyzer.networkQualityMonitor,
+          'determineUplinkNetworkQuality'
+        );
       });
 
       afterEach(() => {
@@ -65,11 +68,13 @@ describe('plugin-meetings', () => {
         await statsAnalyzer.parseGetStatsResult(statusResult, 'video');
 
         assert.calledOnce(statsAnalyzer.networkQualityMonitor.determineUplinkNetworkQuality);
-        assert(sandBoxSpy.calledWith({
-          mediaType: 'video',
-          remoteRtpResults: statusResult,
-          statsAnalyzerCurrentStats: statsAnalyzer.statsResults
-        }));
+        assert(
+          sandBoxSpy.calledWith({
+            mediaType: 'video',
+            remoteRtpResults: statusResult,
+            statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
+          })
+        );
       });
     });
 
@@ -114,7 +119,7 @@ describe('plugin-meetings', () => {
               type: 'outbound-rtp',
               packetsSent: 0,
               bytesSent: 1,
-            }
+            },
           },
           video: {
             receiver: {
@@ -126,12 +131,12 @@ describe('plugin-meetings', () => {
               type: 'outbound-rtp',
               framesSent: 0,
               bytesSent: 1,
-            }
-          }
+            },
+          },
         };
 
         pc = {
-          getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
           getTransceiverStats: sinon.stub().resolves({
             audio: {
               sender: [fakeStats.audio.sender],
@@ -148,9 +153,9 @@ describe('plugin-meetings', () => {
             screenShareVideo: {
               sender: [],
               receiver: [],
-              currentDirection: 'sendrecv'
-            }
-          })
+              currentDirection: 'sendrecv',
+            },
+          }),
         };
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);

package/test/utils/cmr.js

@@ -1,4 +1,3 @@
-
 import uuid from 'uuid';
 import retry from '@webex/test-helper-retry';
 
@@ -23,16 +22,16 @@ CMR.reserve = (webex, claimed) => {
       authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
       'cisco-no-http-redirect': null,
       'spark-user-agent': null,
-      trackingid: `ITCLIENT_${uuid.v4()}_0_imi:true`
+      trackingid: `ITCLIENT_${uuid.v4()}_0_imi:true`,
     },
     body: {
       resourceType,
       requestMetaData: {
         emailAddress: `test${uuid.v4()}@wx2.example.com`,
-        loginType: 'loginGuest'
+        loginType: 'loginGuest',
       },
-      reservedBy: 'Webex JavaScript SDK Test Suite'
-    }
+      reservedBy: 'Webex JavaScript SDK Test Suite',
+    },
   };
 
   if (claimed) {
@@ -40,7 +39,8 @@ CMR.reserve = (webex, claimed) => {
   }
   console.log('USER ID ', webex.internal.device.userId);
 
-  return webex.request(requestBody)
+  return webex
+    .request(requestBody)
     .then((response) => {
       const cmr = response.body;
 
@@ -56,47 +56,49 @@ CMR.reserve = (webex, claimed) => {
 CMR.release = (webex, reservationUrl) => {
   console.log('releasing cmr');
 
-  return webex.request({
-    method: 'DELETE',
-    uri: reservationUrl,
-    headers: {
-      authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
-      'cisco-no-http-redirect': null,
-      'spark-user-agent': null
-    }
-  })
+  return webex
+    .request({
+      method: 'DELETE',
+      uri: reservationUrl,
+      headers: {
+        authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
+        'cisco-no-http-redirect': null,
+        'spark-user-agent': null,
+      },
+    })
     .then(() => console.log('released cmr'));
 };
 
-CMR.waitForHostToJoin = (webex, resourceUrl) => retry(() => {
-  console.log('checking if the host has joined');
-
-  return webex.request({
-    method: 'GET',
-    uri: resourceUrl,
-    headers: {
-      authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
-      'cisco-no-http-redirect': null,
-      'spark-user-agent': null
-    }
+CMR.waitForHostToJoin = (webex, resourceUrl) =>
+  retry(() => {
+    console.log('checking if the host has joined');
+
+    return webex
+      .request({
+        method: 'GET',
+        uri: resourceUrl,
+        headers: {
+          authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
+          'cisco-no-http-redirect': null,
+          'spark-user-agent': null,
+        },
+      })
+      .then((res) => {
+        if (res.body && res.body.meeting.hostPresent) {
+          console.log('the host has joined');
+
+          return;
+        }
+
+        console.log('the host has not joined');
+        throw new Error('Meeting host has not yet joined');
+      });
   })
-    .then((res) => {
-      if (res.body && res.body.meeting.hostPresent) {
-        console.log('the host has joined');
+    .then(() => true)
+    .catch((reason) => {
+      console.warn(reason);
 
-        return;
-      }
-
-      console.log('the host has not joined');
-      throw new Error('Meeting host has not yet joined');
+      return false;
     });
-})
-  .then(() => true)
-  .catch((reason) => {
-    console.warn(reason);
-
-    return false;
-  });
-
 
 export default CMR;