@webex/plugin-meetings 2.59.8-next.2 → 2.60.0-next.1

package/test/unit/spec/recording-controller/util.js

@@ -1,102 +1,229 @@
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
 import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
-import { assert } from 'chai';
+import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
+
+import {assert} from 'chai';
 
 describe('plugin-meetings', () => {
-    describe('recording-controller tests', () => {
-        describe('recording util tests', () => {
-
-            let locusInfo;
-        
-            beforeEach(() => {
-              locusInfo = {
-                parsedLocus: {
-                  info: {
-                    userDisplayHints: [],
-                  },
-                },
-              };
-            });
-        
-            describe('canUserStart', () => {
-              it('can start recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
-
-                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserPause', () => {
-              it('can pause recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
-
-                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserStop', () => {
-              it('can stop recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
-
-                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserResume', () => {
-              it('can start recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
-
-                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('deriveRecordingStates', () => {
-              it('gets the correct values for a start recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Start), {recording: true, paused: false});
-              });
-
-              it('gets the correct values for a stop recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Stop), {recording: false, paused: false});
-              });
-
-              it('gets the correct values for a resume recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Resume), {recording: true, paused: false});
-              });
-
-              it('gets the correct values for a paused recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Pause), {recording: true, paused: true});
-              });
-            });
-
-            describe('extractLocusId', () => {
-              it('gets the correct id from the url param', () => {
-                assert.equal(RecordingUtil.extractLocusId('test/id'), 'id');
-              });
-
-              it('works with empty string parameters passed', () => {
-                assert.equal(RecordingUtil.extractLocusId(''), '');
-              });
-
-              it('works with no parameters passed', () => {
-                assert.isUndefined(RecordingUtil.extractLocusId(undefined));
-              });
-            });
+  describe('recording-controller tests', () => {
+    describe('recording util tests', () => {
+      let locusInfo;
+
+      beforeEach(() => {
+        locusInfo = {
+          parsedLocus: {
+            info: {
+              userDisplayHints: [],
+            },
+          },
+        };
+      });
+
+      describe('canUserStart', () => {
+        it('can start recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can start recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserPause', () => {
+        it('can pause recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can pause recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserStop', () => {
+        it('can stop recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can stop recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP', {
+            [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+          });
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP', {
+            [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+          });
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserResume', () => {
+        it('can start recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can start recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('deriveRecordingStates', () => {
+        it('gets the correct values for a start recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Start), {
+            recording: true,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a stop recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Stop), {
+            recording: false,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a resume recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Resume), {
+            recording: true,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a paused recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Pause), {
+            recording: true,
+            paused: true,
+          });
+        });
+      });
+
+      describe('extractLocusId', () => {
+        it('gets the correct id from the url param', () => {
+          assert.equal(RecordingUtil.extractLocusId('test/id'), 'id');
+        });
+
+        it('works with empty string parameters passed', () => {
+          assert.equal(RecordingUtil.extractLocusId(''), '');
+        });
+
+        it('works with no parameters passed', () => {
+          assert.isUndefined(RecordingUtil.extractLocusId(undefined));
         });
+      });
     });
-});
+  });
+});

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

@@ -1,50 +1,55 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
-import {ROAP} from '@webex/plugin-meetings/src/constants';
+import MockWebex from '@webex/test-helper-mock-webex';
 
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
-import RoapHandler from '@webex/plugin-meetings/src/roap/handler';
 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';
 
 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'} as Meeting;
-
-      const doTurnDiscoveryStub = sinon
-        .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
-        .resolves(RESULT);
+    [false, true].forEach(function (isReconnecting) {
+      [false, true, undefined].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments when isReconnecting = ${isReconnecting} and isForced = ${isForced}`, async () => {
+          const webex = new MockWebex({});
 
-      const roap = new Roap({}, {parent: 'fake'});
+          const RESULT = {something: 'some value'};
+          const meeting = {id: 'some meeting id'} as Meeting;
 
-      // call with isReconnecting: true
-      const result = await roap.doTurnDiscovery(meeting, true);
+          const doTurnDiscoveryStub = sinon
+            .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
+            .resolves(RESULT);
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
-      assert.deepEqual(result, RESULT);
+          const roap = new Roap({}, {parent: webex});
 
-      doTurnDiscoveryStub.resetHistory();
+          const result = await roap.doTurnDiscovery(meeting, isReconnecting, isForced);
 
-      // and with isReconnecting: false
-      const result2 = await roap.doTurnDiscovery(meeting, false);
+          assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
+          assert.deepEqual(result, RESULT);
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
-      assert.deepEqual(result2, RESULT);
-
-      sinon.restore();
+          sinon.restore();
+        });
+      });
     });
   });
 
   describe('sendRoapMediaRequest', () => {
     let sendRoapStub;
-    let roapHandlerSubmitStub;
-
     let meeting;
 
+    let webex;
+    let roap;
+
+    const fakeLocus = {id: 'fake locus'};
+
     beforeEach(() => {
+      webex = new MockWebex({});
       meeting = {
         id: 'some meeting id',
         correlationId: 'correlation id',
@@ -56,76 +61,194 @@ describe('Roap', () => {
         video: {
           isLocallyMuted: () => false,
         },
+        isMultistream: true,
         setRoapSeq: sinon.stub(),
-        config: {experimental: {enableTurnDiscovery: false}},
-        webex: {meetings: {reachability: {isAnyClusterReachable: () => true}}},
+        locusMediaRequest: {fake: true},
+        webex: {meetings: {reachability: {isAnyPublicClusterReachable: () => true}}},
+        updateMediaConnections: sinon.stub(),
       };
 
-      beforeEach(() => {
-        sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
-        roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
-        meeting.setRoapSeq.resetHistory();
-      });
+      sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
 
-      afterEach(() => {
-        sinon.restore();
-      });
+      sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
+      meeting.setRoapSeq.resetHistory();
 
-      [
-        {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-        {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
-        {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-        {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
-      ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
-        it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
-          reconnect ? '' : 'not '
-        }reconnecting and TURN discovery is ${
-          turnDiscoverySkipped ? 'skipped' : 'not skipped'
-        }`, async () => {
-          const roap = new Roap({}, {parent: 'fake'});
-
-          sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(turnDiscoverySkipped);
-
-          await roap.sendRoapMediaRequest({
-            meeting,
-            sdp: 'sdp',
-            reconnect,
-            roapSeq: 1,
-          });
+      roap = new Roap({}, {parent: webex});
+      sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(false);
+    });
 
-          const expectedRoapMessage = {
-            messageType: 'OFFER',
-            sdps: ['sdp'],
-            version: '2',
-            seq: 2,
-            tieBreaker: 4294967294,
-          };
+    afterEach(() => {
+      sinon.restore();
+    });
 
-          assert.calledOnce(sendRoapStub);
-          assert.calledWith(sendRoapStub, {
+    [
+      {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+      {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
+      {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+      {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
+    ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
+      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
+        reconnect ? '' : 'not '
+      }reconnecting and TURN discovery is ${
+        turnDiscoverySkipped ? 'skipped' : 'not skipped'
+      }`, async () => {
+        roap.turnDiscovery.isSkipped.resolves(turnDiscoverySkipped);
+
+        await roap.sendRoapMediaRequest({
+          meeting,
+          sdp: 'sdp',
+          reconnect,
+          seq: 2,
+          tieBreaker: 4294967294,
+        });
+
+        const expectedRoapMessage = {
+          messageType: 'OFFER',
+          sdps: ['sdp'],
+          version: '2',
+          seq: 2,
+          tieBreaker: 4294967294,
+          headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+        };
+
+        assert.calledOnce(sendRoapStub);
+        assert.calledWith(
+          sendRoapStub,
+          sinon.match({
             roapMessage: expectedRoapMessage,
-            correlationId: meeting.correlationId,
             locusSelfUrl: meeting.selfUrl,
             mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-            audioMuted: meeting.audio?.isLocallyMuted(),
-            videoMuted: meeting.video?.isLocallyMuted(),
             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,
           });
 
-          assert.calledTwice(roapHandlerSubmitStub);
-          assert.calledWith(roapHandlerSubmitStub, {
-            type: ROAP.SEND_ROAP_MSG,
-            msg: expectedRoapMessage,
-            correlationId: meeting.correlationId,
+          const result = await roap.sendRoapMediaRequest({
+            meeting,
+            sdp: 'sdp',
+            reconnect: false,
+            seq: 1,
+            tieBreaker: 4294967294,
           });
-          assert.calledWith(roapHandlerSubmitStub, {
-            type: ROAP.SEND_ROAP_MSG_SUCCESS,
-            seq: 2,
-            correlationId: meeting.correlationId,
+
+          assert.calledOnce(sendRoapStub);
+          assert.deepEqual(result, {
+            locus: fakeLocus,
+            roapAnswer: undefined,
           });
 
-          assert.calledOnce(meeting.setRoapSeq);
-          assert.calledWith(meeting.setRoapSeq, 2);
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+            {
+              correlationId: meeting.correlationId,
+              messageType: 'ANSWER',
+              isMultistream: meeting.isMultistream,
+            }
+          );
         })
       );
     });