@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -1,229 +1,102 @@
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
 import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
-import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
-
-import {assert} from 'chai';
+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('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));
+    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));
+              });
+            });
         });
-      });
     });
-  });
-});
+});

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

@@ -1,55 +1,49 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
-import MockWebex from '@webex/test-helper-mock-webex';
+import {ROAP} from '@webex/plugin-meetings/src/constants';
 
 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', () => {
-    [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({});
+    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 RESULT = {something: 'some value'};
-          const meeting = {id: 'some meeting id'} as Meeting;
+      const doTurnDiscoveryStub = sinon
+        .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
+        .resolves(RESULT);
 
-          const doTurnDiscoveryStub = sinon
-            .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
-            .resolves(RESULT);
+      const roap = new Roap({}, {parent: 'fake'});
 
-          const roap = new Roap({}, {parent: webex});
+      // call with isReconnecting: true
+      const result = await roap.doTurnDiscovery(meeting, true);
 
-          const result = await roap.doTurnDiscovery(meeting, isReconnecting, isForced);
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
+      assert.deepEqual(result, RESULT);
 
-          assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
-          assert.deepEqual(result, RESULT);
+      doTurnDiscoveryStub.resetHistory();
 
-          sinon.restore();
-        });
-      });
+      // and with isReconnecting: false
+      const result2 = await roap.doTurnDiscovery(meeting, false);
+
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
+      assert.deepEqual(result2, RESULT);
+
+      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',
@@ -61,180 +55,76 @@ describe('Roap', () => {
         video: {
           isLocallyMuted: () => false,
         },
-        isMultistream: true,
         setRoapSeq: sinon.stub(),
-        locusMediaRequest: {fake: 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(() => {
-      sinon.restore();
-    });
-
-    it(`sends roap OFFER`, async () => {
-      await roap.sendRoapMediaRequest({
-        meeting,
-        sdp: 'sdp',
-        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,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: 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'],
+        config: {experimental: {enableTurnDiscovery: false}},
+        webex: {meetings: {reachability: {isAnyClusterReachable: () => true}}},
       };
-      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,
+      beforeEach(() => {
+        sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
+        roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
+        meeting.setRoapSeq.resetHistory();
       });
 
-      assert.calledOnce(sendRoapStub);
-      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
-      assert.deepEqual(result, {
-        locus: fakeLocus,
-        roapAnswer: undefined,
+      afterEach(() => {
+        sinon.restore();
       });
-      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({
+        {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: false,
-            seq: 1,
-            tieBreaker: 4294967294,
+            reconnect,
+            roapSeq: 1,
           });
 
+          const expectedRoapMessage = {
+            messageType: 'OFFER',
+            sdps: ['sdp'],
+            version: '2',
+            seq: 2,
+            tieBreaker: 4294967294,
+          };
+
           assert.calledOnce(sendRoapStub);
-          assert.deepEqual(result, {
-            locus: fakeLocus,
-            roapAnswer: undefined,
+          assert.calledWith(sendRoapStub, {
+            roapMessage: expectedRoapMessage,
+            correlationId: meeting.correlationId,
+            locusSelfUrl: meeting.selfUrl,
+            mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+            audioMuted: meeting.audio?.isLocallyMuted(),
+            videoMuted: meeting.video?.isLocallyMuted(),
+            meetingId: meeting.id,
+          });
+
+          assert.calledTwice(roapHandlerSubmitStub);
+          assert.calledWith(roapHandlerSubmitStub, {
+            type: ROAP.SEND_ROAP_MSG,
+            msg: expectedRoapMessage,
+            correlationId: meeting.correlationId,
+          });
+          assert.calledWith(roapHandlerSubmitStub, {
+            type: ROAP.SEND_ROAP_MSG_SUCCESS,
+            seq: 2,
+            correlationId: meeting.correlationId,
           });
 
-          assert.calledOnceWithExactly(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
-            {
-              correlationId: meeting.correlationId,
-              messageType: 'ANSWER',
-              isMultistream: meeting.isMultistream,
-            }
-          );
+          assert.calledOnce(meeting.setRoapSeq);
+          assert.calledWith(meeting.setRoapSeq, 2);
         })
       );
     });