@webex/plugin-meetings 3.0.0-beta.294 → 3.0.0-beta.296

package/test/unit/spec/meeting/index.js

@@ -58,6 +58,7 @@ import * as MeetingRequestImport from '@webex/plugin-meetings/src/meeting/reques
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
 import Media from '@webex/plugin-meetings/src/media/index';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
@@ -1193,7 +1194,7 @@ describe('plugin-meetings', () => {
 
         it('should send metrics and reset the statsAnalyzer to null if addMedia throws an error without a turn server retry', async () => {
           meeting.meetingState = 'ACTIVE';
-          
+
           meeting.webex.meetings.reachability = {
             getReachabilityMetrics: sinon.stub().resolves({
               someReachabilityMetric1: 'some value1',
@@ -2361,7 +2362,7 @@ describe('plugin-meetings', () => {
         let clock;
 
         beforeEach(() => {
-          clock = sinon.useFakeTimers(); 
+          clock = sinon.useFakeTimers();
 
           sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
 
@@ -2501,7 +2502,7 @@ describe('plugin-meetings', () => {
 
         // simulates a Roap OK being sent
         const simulateRoapOk = async () => {
-          const roapListener = getRoapListener(); 
+          const roapListener = getRoapListener();
 
           await roapListener({roapMessage: roapOKMessage});
           await stableState();
@@ -2523,7 +2524,7 @@ describe('plugin-meetings', () => {
               correlationId: meeting.correlationId,
               localMedias: [
                 {
-                  localSdp: `{"audioMuted":${audioMuted},"videoMuted":${videoMuted},"roapMessage":{"messageType":"OFFER","sdps":["${sdp}"],"version":"2","seq":"${seq}","tieBreaker":"${tieBreaker}"}}`,
+                  localSdp: `{"audioMuted":${audioMuted},"videoMuted":${videoMuted},"roapMessage":{"messageType":"OFFER","sdps":["${sdp}"],"version":"2","seq":"${seq}","tieBreaker":"${tieBreaker}","headers":["includeAnswerInHttpResponse","noOkInTransaction"]}}`,
                   mediaId: 'fake media id',
                 },
               ],
@@ -5746,34 +5747,20 @@ describe('plugin-meetings', () => {
           });
         });
 
-        describe('handles Event.ROAP_MESSAGE_TO_SEND correctly', () => {
-          let sendRoapOKStub;
-          let sendRoapMediaRequestStub;
-          let sendRoapAnswerStub;
-          let sendRoapErrorStub;
-
+        describe('handles SDP events correctly', () => {
           beforeEach(() => {
-            sendRoapOKStub = sinon.stub(meeting.roap, 'sendRoapOK').resolves({});
-            sendRoapMediaRequestStub = sinon
-              .stub(meeting.roap, 'sendRoapMediaRequest')
-              .resolves({});
-            sendRoapAnswerStub = sinon.stub(meeting.roap, 'sendRoapAnswer').resolves({});
-            sendRoapErrorStub = sinon.stub(meeting.roap, 'sendRoapError').resolves({});
-
             meeting.setupMediaConnectionListeners();
           });
 
-          it('handles OK message correctly', () => {
+          it('handles REMOTE_SDP_ANSWER_PROCESSED correctly', () => {
             const clock = sinon.useFakeTimers();
-            sinon.spy(clock, "clearTimeout");
+            sinon.spy(clock, 'clearTimeout');
             meeting.deferSDPAnswer = {
               resolve: sinon.stub(),
             };
             meeting.sdpResponseTimer = '1234';
 
-            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
-              roapMessage: {messageType: 'OK', seq: 1},
-            });
+            eventListeners[Event.REMOTE_SDP_ANSWER_PROCESSED]();
 
             assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
             assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
@@ -5781,13 +5768,6 @@ describe('plugin-meetings', () => {
               options: {meetingId: meeting.id},
             });
 
-            assert.calledOnce(sendRoapOKStub);
-            assert.calledWith(sendRoapOKStub, {
-              seq: 1,
-              mediaId: meeting.mediaId,
-              correlationId: meeting.correlationId,
-            });
-
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(
               Metrics.sendBehavioralMetric,
@@ -5799,15 +5779,70 @@ describe('plugin-meetings', () => {
               }
             );
 
-            assert.calledOnce(meeting.deferSDPAnswer.resolve)
-            assert.calledOnce(clock.clearTimeout)
-            assert.calledWith(clock.clearTimeout, '1234')
-            assert.equal(meeting.sdpResponseTimer, undefined)
+            assert.calledOnce(meeting.deferSDPAnswer.resolve);
+            assert.calledOnce(clock.clearTimeout);
+            assert.calledWith(clock.clearTimeout, '1234');
+            assert.equal(meeting.sdpResponseTimer, undefined);
           });
 
-          it('handles OFFER message correctly', () => {
+          it('handles LOCAL_SDP_OFFER_GENERATED correctly', () => {
             assert.equal(meeting.deferSDPAnswer, undefined);
 
+            eventListeners[Event.LOCAL_SDP_OFFER_GENERATED]();
+
+            assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media-engine.local-sdp-generated',
+              options: {meetingId: meeting.id},
+            });
+
+            assert.notEqual(meeting.deferSDPAnswer, undefined);
+          });
+
+          it('handles LOCAL_SDP_ANSWER_GENERATED correctly', () => {
+            eventListeners[Event.LOCAL_SDP_ANSWER_GENERATED]();
+
+            assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media-engine.remote-sdp-received',
+              options: {meetingId: meeting.id},
+            });
+          });
+        });
+
+        describe('handles Event.ROAP_MESSAGE_TO_SEND correctly', () => {
+          let sendRoapOKStub;
+          let sendRoapMediaRequestStub;
+          let sendRoapAnswerStub;
+          let sendRoapErrorStub;
+
+          beforeEach(() => {
+            sendRoapOKStub = sinon.stub(meeting.roap, 'sendRoapOK').resolves({});
+            sendRoapMediaRequestStub = sinon
+              .stub(meeting.roap, 'sendRoapMediaRequest')
+              .resolves({});
+            sendRoapAnswerStub = sinon.stub(meeting.roap, 'sendRoapAnswer').resolves({});
+            sendRoapErrorStub = sinon.stub(meeting.roap, 'sendRoapError').resolves({});
+
+            meeting.setupMediaConnectionListeners();
+          });
+
+          it('handles OK message correctly', () => {
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {messageType: 'OK', seq: 1},
+            });
+
+            assert.calledOnce(sendRoapOKStub);
+            assert.calledWith(sendRoapOKStub, {
+              seq: 1,
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId,
+            });
+          });
+
+          it('handles OFFER message correctly (no answer in the http response)', async () => {
+            sinon.stub(meeting, 'roapMessageReceived');
+
             eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'OFFER',
@@ -5817,11 +5852,7 @@ describe('plugin-meetings', () => {
               },
             });
 
-            assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
-            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
-              name: 'client.media-engine.local-sdp-generated',
-              options: {meetingId: meeting.id},
-            });
+            await testUtils.flushPromises();
 
             assert.calledOnce(sendRoapMediaRequestStub);
             assert.calledWith(sendRoapMediaRequestStub, {
@@ -5831,8 +5862,34 @@ describe('plugin-meetings', () => {
               meeting,
               reconnect: false,
             });
+            assert.notCalled(meeting.roapMessageReceived);
+          });
 
-            assert.notEqual(meeting.deferSDPAnswer, undefined);
+          it('handles OFFER message correctly (with an answer in the http response)', async () => {
+            const fakeAnswer = {messageType: 'answer', sdp: 'sdp'};
+            sendRoapMediaRequestStub.resolves({roapAnswer: fakeAnswer});
+            sinon.stub(meeting, 'roapMessageReceived');
+
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'OFFER',
+                seq: 1,
+                sdp: 'fake sdp',
+                tieBreaker: 12345,
+              },
+            });
+
+            await testUtils.flushPromises();
+
+            assert.calledOnce(sendRoapMediaRequestStub);
+            assert.calledWith(sendRoapMediaRequestStub, {
+              seq: 1,
+              sdp: 'fake sdp',
+              tieBreaker: 12345,
+              meeting,
+              reconnect: false,
+            });
+            assert.calledWith(meeting.roapMessageReceived, fakeAnswer);
           });
 
           it('handles ANSWER message correctly', () => {
@@ -5845,12 +5902,6 @@ describe('plugin-meetings', () => {
               },
             });
 
-            assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
-            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
-              name: 'client.media-engine.remote-sdp-received',
-              options: {meetingId: meeting.id},
-            });
-
             assert.calledOnce(sendRoapAnswerStub);
             assert.calledWith(sendRoapAnswerStub, {
               seq: 10,
@@ -9300,4 +9351,22 @@ describe('plugin-meetings', () => {
       assert.equal(returnValue, undefined);
     });
   });
+
+  describe('#roapMessageReceived', () => {
+    it('calls roapMessageReceived on the webrtc media connection', () => {
+      const fakeMessage = { messageType: 'fake', sdp: 'fake sdp'};
+
+      const getMediaServer = sinon.stub(MeetingsUtil, 'getMediaServer').returns('homer');
+
+      meeting.mediaProperties.webrtcMediaConnection = {
+        roapMessageReceived: sinon.stub()
+      };
+
+      meeting.roapMessageReceived(fakeMessage);
+
+      assert.calledOnceWithExactly(meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived, fakeMessage);
+      assert.calledOnceWithExactly(getMediaServer, 'fake sdp');
+      assert.equal(meeting.mediaProperties.webrtcMediaConnection.mediaServer, 'homer');
+    })
+  })
 });

package/test/unit/spec/meetings/utils.js

@@ -181,11 +181,7 @@ describe('plugin-meetings', () => {
         const meetingCollection = {
           getByKey: () => ({
             id: 'meeting-id',
-            mediaProperties: {
-              webrtcMediaConnection: {
-                roapMessageReceived
-              }
-            }
+            roapMessageReceived
           })
         };
 

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

@@ -7,6 +7,8 @@ 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';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 import { IP_VERSION } from '../../../../src/constants';
 
@@ -42,6 +44,9 @@ describe('Roap', () => {
     let meeting;
 
     let webex;
+    let roap;
+
+    const fakeLocus = {id: 'fake locus'};
 
     beforeEach(() => {
       webex = new MockWebex({});
@@ -50,21 +55,27 @@ describe('Roap', () => {
         correlationId: 'correlation id',
         selfUrl: 'self url',
         mediaId: 'media id',
-        audio:{
+        audio: {
           isLocallyMuted: () => true,
         },
-        video:{
+        video: {
           isLocallyMuted: () => false,
         },
+        isMultistream: true,
         setRoapSeq: sinon.stub(),
         locusMediaRequest: {fake: true},
-        webex: { meetings: { reachability: { isAnyPublicClusterReachable: () => true}}},
+        webex: {meetings: {reachability: {isAnyPublicClusterReachable: () => true}}},
+        updateMediaConnections: sinon.stub(),
       };
 
       sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
 
       sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
       meeting.setRoapSeq.resetHistory();
+
+      roap = new Roap({}, {parent: webex});
+      sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(false);
     });
 
     afterEach(() => {
@@ -82,9 +93,7 @@ describe('Roap', () => {
       }reconnecting and TURN discovery is ${
         turnDiscoverySkipped ? 'skipped' : 'not skipped'
       }`, async () => {
-        const roap = new Roap({}, {parent: webex});
-
-        sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(turnDiscoverySkipped);
+        roap.turnDiscovery.isSkipped.resolves(turnDiscoverySkipped);
 
         await roap.sendRoapMediaRequest({
           meeting,
@@ -100,17 +109,148 @@ describe('Roap', () => {
           version: '2',
           seq: 2,
           tieBreaker: 4294967294,
+          headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
         };
 
         assert.calledOnce(sendRoapStub);
-        assert.calledWith(sendRoapStub, sinon.match({
-          roapMessage: expectedRoapMessage,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-          meetingId: meeting.id,
-          locusMediaRequest: meeting.locusMediaRequest,
-        }));
+        assert.calledWith(
+          sendRoapStub,
+          sinon.match({
+            roapMessage: expectedRoapMessage,
+            locusSelfUrl: meeting.selfUrl,
+            mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+            meetingId: meeting.id,
+            locusMediaRequest: meeting.locusMediaRequest,
+          })
+        );
       })
     );
+
+    it('reads SDP answer from the http response', async () => {
+      const roapAnswer = {
+        seq: 5,
+        messageType: 'ANSWER',
+        sdps: ['sdp answer'],
+        errorType: 'error type', // normally ANSWER would not have errorType or errorCause (only error messages have these)
+        errorCause: 'error cause', // but we're just testing here that all the fields are forwarded to the caller of sendRoapMediaRequest()
+        headers: ['header1', 'header2'],
+      };
+      const fakeMediaConnections = [
+        {
+          remoteSdp: JSON.stringify({
+            roapMessage: roapAnswer,
+          }),
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
+
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: {
+          seq: 5,
+          messageType: 'ANSWER',
+          sdp: 'sdp answer',
+          errorType: 'error type',
+          errorCause: 'error cause',
+          headers: ['header1', 'header2'],
+        },
+      });
+    });
+
+    it('handles the case when there is no answer in the http response', async () => {
+      const fakeMediaConnections = [
+        {
+          // this is the actual value Locus returns to us when they don't send Roap ANSWER in the http response
+          remoteSdp:
+            '{"audioMuted":false,"videoMuted":false,"csis":[],"dtmfReceiveSupported":true,"type":"SDP"}',
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
+
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: undefined,
+      });
+      assert.calledOnceWithExactly(
+        Metrics.sendBehavioralMetric,
+        BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+        {
+          correlationId: meeting.correlationId,
+          messageType: 'ANSWER',
+          isMultistream: meeting.isMultistream,
+        }
+      );
+    });
+
+    describe('does not crash when http response is missing things', () => {
+      [
+        {mediaConnections: undefined, title: 'mediaConnections are undefined'},
+        {mediaConnections: [], title: 'mediaConnections are empty array'},
+        {mediaConnections: [{}], title: 'mediaConnections[0] has no remoteSdp'},
+        {
+          mediaConnections: [{remoteSdp: '{}'}],
+          title: 'mediaConnections[0].remoteSdp is an empty json',
+        },
+      ].forEach(({mediaConnections, title}) =>
+        it(title, async () => {
+          sendRoapStub.resolves({
+            mediaConnections,
+            locus: fakeLocus,
+          });
+
+          const result = await roap.sendRoapMediaRequest({
+            meeting,
+            sdp: 'sdp',
+            reconnect: false,
+            seq: 1,
+            tieBreaker: 4294967294,
+          });
+
+          assert.calledOnce(sendRoapStub);
+          assert.deepEqual(result, {
+            locus: fakeLocus,
+            roapAnswer: undefined,
+          });
+
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+            {
+              correlationId: meeting.correlationId,
+              messageType: 'ANSWER',
+              isMultistream: meeting.isMultistream,
+            }
+          );
+        })
+      );
+    });
   });
 });