@webex/plugin-meetings 3.11.0 → 3.12.0

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

@@ -18,6 +18,7 @@ describe('member', () => {
     assert.exists(member.supportsBreakouts);
     assert.exists(member.supportLiveAnnotation);
     assert.exists(member.canReclaimHost);
+    assert.exists(member.canApproveAIEnablement);
   });
 
   describe('roles', () => {
@@ -47,17 +48,24 @@ describe('member', () => {
     it('checks that processParticipant calls canReclaimHost', () => {
       sinon.spy(MemberUtil, 'canReclaimHost');
       member.processParticipant(participant);
-  
+
       assert.calledOnceWithExactly(MemberUtil.canReclaimHost, participant);
     });
 
     it('checks that processParticipant calls isPresenterAssignmentProhibited', () => {
       sinon.spy(MemberUtil, 'isPresenterAssignmentProhibited');
       member.processParticipant(participant);
-  
+
       assert.calledOnceWithExactly(MemberUtil.isPresenterAssignmentProhibited, participant);
     });
-  })
+
+    it('checks that processParticipant calls canApproveAIEnablement', () => {
+      sinon.spy(MemberUtil, 'canApproveAIEnablement');
+      member.processParticipant(participant);
+
+      assert.calledOnceWithExactly(MemberUtil.canApproveAIEnablement, participant);
+    });
+  });
 
   describe('#processMember', () => {
     it('checks that processMember calls isRemovable', () => {
@@ -80,5 +88,21 @@ describe('member', () => {
 
       assert.calledOnceWithExactly(MemberUtil.extractMediaStatus, participant);
     });
-  })
+  });
+
+  describe('canApproveAIEnablement integration', () => {
+    it('sets canApproveAIEnablement to the value returned by MemberUtil.canApproveAIEnablement', () => {
+      const testParticipant = {controls: {}, status: {}};
+
+      sinon.stub(MemberUtil, 'canApproveAIEnablement').returns(true);
+      const memberWithTrue = new Member(testParticipant);
+      assert.isTrue(memberWithTrue.canApproveAIEnablement);
+
+      MemberUtil.canApproveAIEnablement.restore();
+
+      sinon.stub(MemberUtil, 'canApproveAIEnablement').returns(false);
+      const memberWithFalse = new Member(testParticipant);
+      assert.isFalse(memberWithFalse.canApproveAIEnablement);
+    });
+  });
 });

package/test/unit/spec/member/util.js

@@ -82,6 +82,46 @@ describe('plugin-meetings', () => {
     });
   });
 
+  describe('MemberUtil.canApproveAIEnablement', () => {
+    it('returns false when there is no participant', () => {
+      assert.isFalse(MemberUtil.canApproveAIEnablement());
+    });
+
+    it('returns false when there is null participant', () => {
+      assert.isFalse(MemberUtil.canApproveAIEnablement(null));
+    });
+
+    it('returns true when attendeeRequestAiAssistantNotAllowed is false', () => {
+      const participant = {
+        attendeeRequestAiAssistantNotAllowed: false,
+      };
+
+      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
+    });
+
+    it('returns false when attendeeRequestAiAssistantNotAllowed is true', () => {
+      const participant = {
+        attendeeRequestAiAssistantNotAllowed: true,
+      };
+
+      assert.isFalse(MemberUtil.canApproveAIEnablement(participant));
+    });
+
+    it('returns true when attendeeRequestAiAssistantNotAllowed is undefined', () => {
+      const participant = {
+        attendeeRequestAiAssistantNotAllowed: undefined,
+      };
+
+      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
+    });
+
+    it('returns true when attendeeRequestAiAssistantNotAllowed is not present', () => {
+      const participant = {};
+
+      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
+    });
+  });
+
   describe('MemberUtil.extractControlRoles', () => {
     it('happy path extract control roles', () => {
       const participant = {
@@ -377,7 +417,6 @@ describe('plugin-meetings', () => {
       assert.isFalse(MemberUtil.isBrb(participant));
     });
 
-
     it('returns false when brb is not present', () => {
       const participant = {
         controls: {},
@@ -417,29 +456,28 @@ describe('plugin-meetings', () => {
     });
   });
 
-describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
-  it('throws an error when there is no participant', () => {
-    assert.throws(() => {
-      MemberUtil.isSupportsSingleUserAutoEndMeeting();
-    }, 'Single user auto end meeting support could not be processed, participant is undefined.');
-  });
+  describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
+    it('throws an error when there is no participant', () => {
+      assert.throws(() => {
+        MemberUtil.isSupportsSingleUserAutoEndMeeting();
+      }, 'Single user auto end meeting support could not be processed, participant is undefined.');
+    });
 
-  it('returns true when single user auto end meeting is supported', () => {
-    const participant = {
-      supportsSingleUserAutoEndMeeting: {},
-    };
-    assert.isTrue(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
-  });
+    it('returns true when single user auto end meeting is supported', () => {
+      const participant = {
+        supportsSingleUserAutoEndMeeting: {},
+      };
+      assert.isTrue(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+    });
 
-  it('returns false when single user auto end meeting is not supported', () => {
-    const participant = {
-      doesNotSupportSingleUserAutoEndMeeting: {},
-    };
+    it('returns false when single user auto end meeting is not supported', () => {
+      const participant = {
+        doesNotSupportSingleUserAutoEndMeeting: {},
+      };
 
-    assert.isFalse(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+      assert.isFalse(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+    });
   });
-});
-
 
   describe('MemberUtil.isLiveAnnotationSupported', () => {
     it('throws an error when there is no participant', () => {
@@ -585,7 +623,7 @@ describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
   describe('MemberUtil.isPresenterAssignmentProhibited', () => {
     it('returns true when isPresenterAssignmentProhibited is true', () => {
       const participant = {
-        presenterAssignmentNotAllowed: true
+        presenterAssignmentNotAllowed: true,
       };
 
       assert.isTrue(MemberUtil.isPresenterAssignmentProhibited(participant));
@@ -610,16 +648,16 @@ describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
 describe('extractMediaStatus', () => {
   it('throws an error when there is no participant', () => {
     assert.throws(() => {
-      MemberUtil.extractMediaStatus()
+      MemberUtil.extractMediaStatus();
     }, 'Media status could not be extracted, participant is undefined.');
   });
 
   it('returns undefined media status when participant audio/video status is not present', () => {
     const participant = {
-      status: {}
+      status: {},
     };
 
-    const mediaStatus = MemberUtil.extractMediaStatus(participant)
+    const mediaStatus = MemberUtil.extractMediaStatus(participant);
 
     assert.deepEqual(mediaStatus, {audio: undefined, video: undefined});
   });
@@ -628,11 +666,11 @@ describe('extractMediaStatus', () => {
     const participant = {
       status: {
         audioStatus: 'RECVONLY',
-        videoStatus: 'SENDRECV'
-      }
+        videoStatus: 'SENDRECV',
+      },
     };
 
-    const mediaStatus = MemberUtil.extractMediaStatus(participant)
+    const mediaStatus = MemberUtil.extractMediaStatus(participant);
 
     assert.deepEqual(mediaStatus, {audio: 'RECVONLY', video: 'SENDRECV'});
   });

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -666,8 +666,8 @@ describe('MediaRequestManager', () => {
     ]);
   });
 
-  it('avoids sending duplicate requests and clears all the requests on reset()', () => {
-    // send some requests and commit them one by one
+  it('clears all the requests on reset()', () => {
+    // send some requests and commit them
     addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
     addReceiverSelectedRequest(1501, fakeReceiveSlots[1], MAX_FS_1080p, false);
     addActiveSpeakerRequest(
@@ -722,95 +722,12 @@ describe('MediaRequestManager', () => {
       },
     ]);
 
-    // check that when calling commit()
-    // all requests are not re-sent again (avoid duplicate requests)
-    mediaRequestManager.commit();
-
-    assert.notCalled(sendMediaRequestsCallback);
-
-    // now reset everything
-    mediaRequestManager.reset();
-
-    // calling commit now should not cause any requests to be sent out
-    mediaRequestManager.commit();
-    checkMediaRequestsSent([]);
-  });
-
-  it('makes sure to call requests correctly after reset was called and another request was added', () => {
-    addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
-
-    assert.notCalled(sendMediaRequestsCallback);
-
-    mediaRequestManager.commit();
-    checkMediaRequestsSent([
-      {
-        policy: 'receiver-selected',
-        csi: 1500,
-        receiveSlot: fakeWcmeSlots[0],
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
-        maxFs: MAX_FS_1080p,
-        maxMbps: MAX_MBPS_1080p,
-      },
-    ]);
-
     // now reset everything
     mediaRequestManager.reset();
 
     // calling commit now should not cause any requests to be sent out
     mediaRequestManager.commit();
     checkMediaRequestsSent([]);
-
-    //add new request
-    addReceiverSelectedRequest(1501, fakeReceiveSlots[1], MAX_FS_1080p, false);
-
-    // commit
-    mediaRequestManager.commit();
-
-    // check the new request was sent
-    checkMediaRequestsSent([
-      {
-        policy: 'receiver-selected',
-        csi: 1501,
-        receiveSlot: fakeWcmeSlots[1],
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
-        maxFs: MAX_FS_1080p,
-        maxMbps: MAX_MBPS_1080p,
-      },
-    ]);
-  });
-
-  it('can send same media request after previous requests have been cleared', () => {
-    // add a request and commit
-    addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
-    mediaRequestManager.commit();
-    checkMediaRequestsSent([
-      {
-        policy: 'receiver-selected',
-        csi: 1500,
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
-        receiveSlot: fakeWcmeSlots[0],
-        maxFs: MAX_FS_1080p,
-        maxMbps: MAX_MBPS_1080p,
-      },
-    ]);
-
-    // clear previous requests
-    mediaRequestManager.clearPreviousRequests();
-
-    // commit same request
-    mediaRequestManager.commit();
-
-    // check the request was sent
-    checkMediaRequestsSent([
-      {
-        policy: 'receiver-selected',
-        csi: 1500,
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
-        receiveSlot: fakeWcmeSlots[0],
-        maxFs: MAX_FS_1080p,
-        maxMbps: MAX_MBPS_1080p,
-      },
-    ]);
   });
 
   it('re-sends media requests after degradation preferences are set', () => {

package/test/unit/spec/multistream/remoteMediaManager.ts

@@ -965,6 +965,36 @@ describe('RemoteMediaManager', () => {
       );
     });
 
+    it('allocates 25 video slots for AllEqual25 layout', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+      config.video.layouts['AllEqual25'] = {
+        activeSpeakerVideoPaneGroups: [
+          {id: 'main', numPanes: 25, size: 'best', priority: 255},
+        ],
+      };
+      config.video.initialLayoutId = 'AllEqual25';
+
+      let slotCount = 0;
+      fakeReceiveSlotManager.allocateSlot.callsFake((mediaType: MediaType) => {
+        if (mediaType === MediaType.VideoMain) {
+          slotCount += 1;
+          return Promise.resolve(new FakeSlot(mediaType, `fake video ${slotCount}`));
+        }
+        return Promise.resolve(fakeAudioSlot);
+      });
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      assert.strictEqual(remoteMediaManager.getLayoutId(), 'AllEqual25');
+      assert.strictEqual(remoteMediaManager.slots.video.activeSpeaker.length, 25);
+    });
+
     it('releases slots when switching to layout that requires less active speaker slots', async () => {
       // start with "AllEqual" layout that needs just 9 video slots
       const config = cloneDeep(DefaultTestConfiguration);

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

@@ -1,5 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
+import { CapabilityState, WebCapabilities } from '@webex/web-capabilities';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
@@ -8,6 +9,7 @@ import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import Metrics from '@webex/plugin-meetings/src/metrics';
+import * as InternalMediaCore from '@webex/internal-media-core';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
@@ -466,11 +468,13 @@ describe('gatherReachability', () => {
   let clock;
   let clusterReachabilityCtorStub;
   let mockClusterReachabilityInstances: Record<string, MockClusterReachability>;
+  let supportsRTCPeerConnectionStub;
 
   beforeEach(async () => {
     webex = new MockWebex();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
+    supportsRTCPeerConnectionStub = sinon.stub(WebCapabilities, 'supportsRTCPeerConnection').returns(CapabilityState.CAPABLE);
 
     await webex.boundedStorage.put(
       'Reachability',
@@ -545,6 +549,25 @@ describe('gatherReachability', () => {
     await assert.isRejected(reachability.gatherReachability('test'), 'enableReachabilityChecks is disabled in config');
   });
 
+  [CapabilityState.NOT_CAPABLE, CapabilityState.UNKNOWN].forEach((capabilityState) =>
+    it(`returns empty object if WebRTC API is not available (capabilityState=${capabilityState}`, async () => {
+      supportsRTCPeerConnectionStub.returns(capabilityState);
+
+      const reachability = new Reachability(webex);
+
+      const result = await reachability.gatherReachability('test');
+
+      assert.deepEqual(result, {});
+
+      // Verify that no new reachability result was stored - old results should remain unchanged
+      // This check is mainly to ensure that we don't put any "unreachable" results into storage
+      const storedResults = await webex.boundedStorage.get('Reachability', 'reachability.result');
+      assert.equal(storedResults, JSON.stringify({old: 'results'}));
+
+      assert.equal(await reachability.isWebexMediaBackendUnreachable(), false);
+    })
+  );
+
   [
     // ========================================================================
     {

package/test/unit/spec/reconnection-manager/index.js

@@ -54,8 +54,8 @@ describe('plugin-meetings', () => {
           webrtcMediaConnection: fakeMediaConnection,
         },
         mediaRequestManagers: {
-          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
-          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          audio: {commit: sinon.stub()},
+          video: {commit: sinon.stub()},
         },
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
@@ -179,26 +179,22 @@ describe('plugin-meetings', () => {
       });
     });
 
-    it('does not clear previous requests and re-request media for non-multistream meetings', async () => {
+    it('does not re-request media for non-multistream meetings', async () => {
       fakeMeeting.isMultistream = false;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
-      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
-      assert.notCalled(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.notCalled(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.notCalled(fakeMeeting.mediaRequestManagers.video.commit);
     });
 
-    it('does clear previous requests and re-request media for multistream meetings', async () => {
+    it('does re-request media for multistream meetings', async () => {
       fakeMeeting.isMultistream = true;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
-      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
-      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.video.commit);
     });