@webex/plugin-meetings 3.7.0 → 3.8.0-next.10

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

@@ -221,7 +221,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can start premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -238,14 +252,28 @@ describe('plugin-meetings', () => {
             assert.isRejected(result);
           });
 
-          it('can start recording when the correct display hint is present', () => {
+          it('can stop recording when the correct display hint is present', () => {
             controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
 
             const result = controller.stopRecording();
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can stop premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -269,7 +297,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can pause premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -293,7 +335,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can resume premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 

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

@@ -1,5 +1,5 @@
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
-import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
+import { RecordingAction } from '@webex/plugin-meetings/src/recording-controller/enums';
 import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
 
 import {assert} from 'chai';
@@ -29,6 +29,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can start premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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');
 
@@ -69,6 +78,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can pause premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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');
 
@@ -109,6 +127,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can stop premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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,
@@ -142,7 +169,7 @@ describe('plugin-meetings', () => {
       });
 
       describe('canUserResume', () => {
-        it('can start recording when the correct display hint is present', () => {
+        it('can resume recording when the correct display hint is present', () => {
           locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
 
           assert.equal(
@@ -151,7 +178,16 @@ describe('plugin-meetings', () => {
           );
         });
 
-        it('can start recording when the correct display hint is present and the policy is true', () => {
+        it('can resume premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can resume recording when the correct display hint is present and the policy is true', () => {
           locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
 
           assert.equal(

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

@@ -161,7 +161,7 @@ describe('Roap', () => {
           roapMessage: expectedRoapMessage,
           locusSelfUrl: meeting.selfUrl,
           mediaId: meeting.mediaId,
-          meetingId: meeting.id,
+          isMultistream: meeting.isMultistream,
           locusMediaRequest: meeting.locusMediaRequest,
         })
       );
@@ -251,6 +251,53 @@ describe('Roap', () => {
       );
     });
 
+    it('handles the case when there is some other (not an answer) roap message type in the http response', async () => {
+      const roapError = {
+        seq: 1,
+        messageType: 'ERROR',
+        sdps: [],
+        errorType: 'error type',
+        errorCause: 'error cause',
+        headers: ['header1', 'header2'],
+      };
+      const fakeMediaConnections = [
+        {
+          remoteSdp: JSON.stringify({
+            roapMessage: roapError,
+          }),
+        },
+      ];
+
+      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'},

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

@@ -4,6 +4,7 @@ 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 MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings/roap', () => {
@@ -23,6 +24,11 @@ describe('plugin-meetings/roap', () => {
       regionCode: 'WEST-COAST',
     };
 
+    webex.meetings.reachability = {
+      getReachabilityReportToAttachToRoap: sinon.stub().resolves({}),
+      getClientMediaPreferences: sinon.stub().resolves({}),
+    };
+
     webex.internal = {
       services: {
         get: sinon.mock().returns(locusUrl),
@@ -36,6 +42,8 @@ describe('plugin-meetings/roap', () => {
       },
     };
 
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.ipv4_and_ipv6);
+
     // @ts-ignore
     roapRequest = new RoapRequest({webex});
 
@@ -74,146 +82,80 @@ describe('plugin-meetings/roap', () => {
     );
   });
 
-  describe('#attachReachabilityData', () => {
-    it('returns the correct reachability data', async () => {
-      const res = await roapRequest.attachReachabilityData({});
-
-      assert.deepEqual(res.localSdp, {
-        reachability: {
-          clusterId: {
-            udp: {
-              reachable: 'true',
-              latencyInMilliseconds: '10',
-            },
-            tcp: {
-              reachable: 'false',
-            },
-            xtls: {
-              untested: 'true',
-            }
-          },
-        },
-      });
-      assert.deepEqual(res.joinCookie, {
-        anycastEntryPoint: 'aws-eu-west-1',
-      });
-    });
+  afterEach(() => {
+    sinon.restore();
+  })
 
-    it('handles the case when reachability data does not exist', async () => {
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
+  describe('sendRoap', () => {
+    it('includes clientMediaPreferences and reachability in the request correctly', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
 
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
-      const sdp = {
-        some: 'attribute',
+      const FAKE_REACHABILITY_REPORT = {
+        id: 'fake reachability report',
+      };
+      const FAKE_CLIENT_MEDIA_PREFERENCES = {
+        id: 'fake client media preferences',
       };
 
-      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: {}}})};
-      const ipVersion = IP_VERSION.unknown;
+      webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
+      webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
 
       await roapRequest.sendRoap({
         locusSelfUrl: locusUrl,
-        ipVersion,
         mediaId: 'mediaId',
         roapMessage: {
           seq: 'seq',
         },
         meetingId: 'meeting-id',
+        isMultistream: true,
         locusMediaRequest,
       });
 
+      assert.calledOnceWithExactly(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+      assert.calledOnceWithExactly(webex.meetings.reachability.getClientMediaPreferences, true, IP_VERSION.ipv4_and_ipv6);
+
       const requestParams = locusMediaRequest.send.getCall(0).args[0];
       assert.deepEqual(requestParams, {
         type: 'RoapMessage',
         selfUrl: locusUrl,
-        ipVersion,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
-        },
+        clientMediaPreferences: FAKE_CLIENT_MEDIA_PREFERENCES,
         mediaId: 'mediaId',
         roapMessage: {
           seq: 'seq',
         },
-        reachability: {
-          clusterId: {
-            tcp: {
-              reachable: 'false',
-            },
-            udp: {
-              latencyInMilliseconds: '10',
-              reachable: 'true',
-            },
-            xtls: {
-              untested: 'true',
-            },
-          },
-        },
+        reachability: FAKE_REACHABILITY_REPORT,
       });
     });
-  });
 
-  it('calls attachReachabilityData when sendRoap', async () => {
-    const locusMediaRequest = { send: sinon.stub().resolves({body: {locus: {}}})};
+    it('includes default clientMediaPreferences if calls to reachability fail', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
 
-    const newSdp = {
-      new: 'sdp',
-      reachability: { someResult: 'whatever' }
-    };
-    const ipVersion = IP_VERSION.only_ipv6;
+      webex.meetings.reachability.getClientMediaPreferences.rejects(new Error('fake error'));
 
-    roapRequest.attachReachabilityData = sinon.stub().returns(
-      Promise.resolve({
-        localSdp: newSdp,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
         },
-      })
-    );
-
-    await roapRequest.sendRoap({
-      roapMessage: {
-        seq: 1,
-      },
-      locusSelfUrl: 'locusSelfUrl',
-      ipVersion,
-      mediaId: 'mediaId',
-      meetingId: 'meetingId',
-      preferTranscoding: true,
-      locusMediaRequest
-    });
-
-    const requestParams = locusMediaRequest.send.getCall(0).args[0];
+        meetingId: 'meeting-id',
+        isMultistream: true,
+        locusMediaRequest,
+      });
 
-    assert.deepEqual(requestParams, {
-      type: 'RoapMessage',
-      selfUrl: 'locusSelfUrl',
-      ipVersion,
-      joinCookie: {
-        anycastEntryPoint: 'aws-eu-west-1',
-      },
-      mediaId: 'mediaId',
-      roapMessage: {
-        seq: 1,
-      },
-      reachability: { someResult: 'whatever' },
-    });
+      assert.calledOnce(webex.meetings.reachability.getClientMediaPreferences);
 
-    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
-      roapMessage: {
-        seq: 1,
-      },
+      const requestParams = locusMediaRequest.send.getCall(0).args[0];
+      assert.deepEqual(requestParams, {
+        type: 'RoapMessage',
+        selfUrl: locusUrl,
+        clientMediaPreferences: {ipver: 0, joinCookie: undefined, preferTranscoding: false},
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        reachability: undefined,
+      });
     });
   });
 });