@webex/plugin-meetings 3.12.0-next.5 → 3.12.0-next.50

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

@@ -5,6 +5,8 @@ import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
+const multipartSitePrefixList = ['.my.', '.mydmz.', '.mybts.', '.mydev.', '.myats2.', '.myats.'];
+
 describe('plugin-meetings', () => {
   beforeEach(() => {
     sinon.stub(Metrics, 'sendBehavioralMetric');
@@ -75,6 +77,28 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#getSiteName', () => {
+      it('gets the site name from a standard Webex site', () => {
+        assert.equal(MeetingsUtil.getSiteName('go.webex.com', multipartSitePrefixList), 'go');
+      });
+
+      it('gets the site name from a my Webex site', () => {
+        assert.equal(MeetingsUtil.getSiteName('go.my.webex.com', multipartSitePrefixList), 'go.my');
+      });
+
+      it('uses the configured multipart site prefix list', () => {
+        assert.equal(MeetingsUtil.getSiteName('go.custom.webex.com', ['.custom.']), 'go.custom');
+      });
+
+      it('falls back to the first label when the multipart site prefix list does not match', () => {
+        assert.equal(MeetingsUtil.getSiteName('go.my.webex.com', ['.custom.']), 'go');
+      });
+
+      it('returns null when the site is empty', () => {
+        assert.equal(MeetingsUtil.getSiteName('', multipartSitePrefixList), null);
+      });
+    });
+
     describe('#getThisDevice', () => {
       it('return null if no devices in self', () => {
         const newLocus = {};
@@ -128,6 +152,143 @@ describe('plugin-meetings', () => {
         };
         assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
       });
+
+      it('returns true if newLocus.info.isBreakout is true', () => {
+        const newLocus = {
+          info: {
+            isBreakout: true,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
+      });
+
+      it('returns false if newLocus.info.isBreakout is false', () => {
+        const newLocus = {
+          info: {
+            isBreakout: false,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
+      });
+
+      it('returns true if both sessionType is BREAKOUT and info.isBreakout is true', () => {
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'BREAKOUT',
+            },
+          },
+          info: {
+            isBreakout: true,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
+      });
+    });
+
+    describe('#isMainAssociatedWithBreakout', () => {
+      it('returns true when breakout control url matches main locus breakout url', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), true);
+      });
+
+      it('returns true when breakout self device replaces the main locus url', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {},
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'other-breakout-url',
+            },
+          },
+          self: {
+            deviceUrl: 'device-url-1',
+            devices: [
+              {
+                url: 'device-url-1',
+                replaces: [{locusUrl: 'main-locus-url'}],
+              },
+            ],
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), true);
+      });
+
+      it('returns false when breakout locus is not associated with the main locus', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'different-breakout-url',
+            },
+          },
+          self: {
+            deviceUrl: 'device-url-1',
+            devices: [
+              {
+                url: 'device-url-1',
+                replaces: [{locusUrl: 'another-main-locus-url'}],
+              },
+            ],
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), false);
+      });
+    });
+
+    describe('#isWholeMeetingEnded', () => {
+      [
+        {description: 'state is INACTIVE with no endMeetingReason', fullState: {state: 'INACTIVE'}, expected: true},
+        {description: 'state is INACTIVE with endMeetingReason OTHER', fullState: {state: 'INACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}, expected: true},
+        {description: 'state is INACTIVE with endMeetingReason BREAKOUT_ENDED', fullState: {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'}, expected: false},
+        {description: 'state is not INACTIVE', fullState: {state: 'ACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}, expected: false},
+      ].forEach(({description, fullState, expected}) => {
+        it(`returns ${expected} when ${description}`, () => {
+          assert.equal(MeetingsUtil.isWholeMeetingEnded(fullState), expected);
+        });
+      });
+    });
+
+    describe('#isSelfMovedOrBreakoutEnded', () => {
+      [
+        {description: 'locus is undefined', locus: undefined, expected: false},
+        {description: 'self state is JOINED', locus: {self: {state: 'JOINED', reason: 'OTHER'}}, expected: false},
+        {description: 'self state is LEFT with reason MOVED', locus: {self: {state: 'LEFT', reason: 'MOVED'}}, expected: true},
+        {description: 'fullState is INACTIVE with BREAKOUT_ENDED', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'}}, expected: true},
+        {description: 'fullState is INACTIVE with different endMeetingReason', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}}, expected: false},
+        {description: 'fullState is missing', locus: {self: {state: 'LEFT', reason: 'OTHER'}}, expected: false},
+        {description: 'endMeetingReason is missing', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE'}}, expected: false},
+      ].forEach(({description, locus, expected}) => {
+        it(`returns ${expected} when ${description}`, () => {
+          assert.equal(MeetingsUtil.isSelfMovedOrBreakoutEnded(locus), expected);
+        });
+      });
     });
 
     describe('#joinedOnThisDevice', () => {

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

@@ -59,6 +59,13 @@ describe('member', () => {
       assert.calledOnceWithExactly(MemberUtil.isPresenterAssignmentProhibited, participant);
     });
 
+    it('checks that processParticipant calls isAttendeeAssignmentProhibited', () => {
+      sinon.spy(MemberUtil, 'isAttendeeAssignmentProhibited');
+      member.processParticipant(participant);
+
+      assert.calledOnceWithExactly(MemberUtil.isAttendeeAssignmentProhibited, participant);
+    });
+
     it('checks that processParticipant calls canApproveAIEnablement', () => {
       sinon.spy(MemberUtil, 'canApproveAIEnablement');
       member.processParticipant(participant);

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

@@ -643,6 +643,30 @@ describe('plugin-meetings', () => {
       assert.isUndefined(MemberUtil.isPresenterAssignmentProhibited(participant));
     });
   });
+
+  describe('MemberUtil.isAttendeeAssignmentProhibited', () => {
+    it('returns true when attendeeAssignmentNotAllowed is true', () => {
+      const participant = {
+        attendeeAssignmentNotAllowed: true,
+      };
+
+      assert.isTrue(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+
+    it('returns false when attendeeAssignmentNotAllowed is false', () => {
+      const participant = {
+        attendeeAssignmentNotAllowed: false,
+      };
+
+      assert.isFalse(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+
+    it('returns false when attendeeAssignmentNotAllowed is undefined', () => {
+      const participant = {};
+
+      assert.isFalse(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+  });
 });
 
 describe('extractMediaStatus', () => {

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

@@ -35,6 +35,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           request = {
             request: sinon.stub().returns(Promise.resolve()),
+            locusDeltaRequest: sinon.stub().returns(Promise.resolve()),
           };
 
           controller = new RecordingController(request);
@@ -69,13 +70,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.startRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -103,13 +104,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.stopRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: false, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -139,13 +140,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.pauseRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: true}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -176,13 +177,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.resumeRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
       });

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

@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
       webex.internal.llm = {
         getDatachannelToken: sinon.stub().returns(undefined),
         setDatachannelToken: sinon.stub(),
+        isDataChannelTokenEnabled: sinon.stub().resolves(false),
         isConnected: sinon.stub().returns(false),
         disconnectLLM: sinon.stub().resolves(),
         off: sinon.stub(),
@@ -175,6 +176,42 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#getValidatedWebinarMeeting', () => {
+      it('returns the meeting when its locusUrl matches the webinar locusUrl', () => {
+        const meeting = {locusUrl: 'locusUrl'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.equal(webinar.getValidatedWebinarMeeting(), meeting);
+      });
+
+      it('returns undefined and warns when the resolved meeting locusUrl does not match', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'other-locus-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+
+      it('returns undefined when no meeting is resolved', () => {
+        webex.meetings.getMeetingByType = sinon.stub().returns(undefined);
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+      });
+
+      it('returns undefined and warns when webinar locusUrl is not yet initialized', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'some-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = undefined;
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+    });
+
     describe('#cleanUp', () => {
       it('delegates to cleanupPSDataChannel', () => {
         const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
@@ -186,17 +223,14 @@ describe('plugin-meetings', () => {
     });
 
     describe('#cleanupPSDataChannel', () => {
-      let meeting;
+      let relayListener;
 
       beforeEach(() => {
-        meeting = {
-          processRelayEvent: sinon.stub(),
-        };
-
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        relayListener = sinon.stub();
+        webinar._practiceSessionRelayListener = relayListener;
       });
 
-      it('disconnects the practice session channel and removes the relay listener', async () => {
+      it('disconnects the practice session channel and removes the tracked relay listener', async () => {
         await webinar.cleanupPSDataChannel();
 
         assert.calledOnceWithExactly(
@@ -207,8 +241,28 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(
           webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting.processRelayEvent
+          relayListener
+        );
+        assert.isNull(webinar._practiceSessionRelayListener);
+      });
+
+      it('skips relay listener removal when no listener has been tracked', async () => {
+        webinar._practiceSessionRelayListener = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        const relayOffCalls = webex.internal.llm.off.args.filter(
+          ([event]) => event === `event:relay.event:${LLM_PRACTICE_SESSION}`
         );
+        assert.equal(relayOffCalls.length, 0);
+      });
+
+      it('does not consult the meeting collection during cleanup', async () => {
+        webex.meetings.getMeetingByType = sinon.stub();
+
+        await webinar.cleanupPSDataChannel();
+
+        assert.notCalled(webex.meetings.getMeetingByType);
       });
 
       it('removes a pending online listener if one exists', async () => {
@@ -239,6 +293,7 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         processRelayEvent = sinon.stub();
         meeting = {
+          locusUrl: 'locusUrl',
           isJoined: sinon.stub().returns(true),
           processRelayEvent,
           locusInfo: {
@@ -267,6 +322,65 @@ describe('plugin-meetings', () => {
         webex.internal.voicea.updateSubchannelSubscriptions = sinon.stub();
       });
 
+      it('refreshes practice-session token before register when cached token is missing', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
+          if (tokenType === DataChannelTokenType.PracticeSession) return undefined;
+
+          return undefined;
+        });
+        meeting.refreshDataChannelToken = sinon.stub().resolves({
+          body: {
+            datachannelToken: 'ps-token-from-refresh',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledOnceWithExactly(meeting.refreshDataChannelToken);
+        assert.calledWithExactly(
+          webex.internal.llm.setDatachannelToken,
+          'ps-token-from-refresh',
+          DataChannelTokenType.PracticeSession
+        );
+        assert.calledWith(
+          webex.internal.llm.registerAndConnect,
+          'locus-url',
+          'dc-url',
+          'ps-token-from-refresh',
+          LLM_PRACTICE_SESSION
+        );
+      });
+
+      it('does not reconnect if practice-session eligibility changes during async token refresh', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().returns(undefined);
+
+        let resolveRefresh;
+        meeting.refreshDataChannelToken = sinon.stub().returns(
+          new Promise((resolve) => {
+            resolveRefresh = resolve;
+          })
+        );
+
+        const updatePromise = webinar.updatePSDataChannel();
+
+        webinar.practiceSessionEnabled = false;
+
+        resolveRefresh({
+          body: {
+            datachannelToken: 'stale-ps-token',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        const result = await updatePromise;
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
       it('no-ops when practice session join eligibility is false', async () => {
         webinar.practiceSessionEnabled = false;
         const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
@@ -358,19 +472,30 @@ describe('plugin-meetings', () => {
         assert.calledOnce(webex.internal.llm.registerAndConnect);
       });
 
-      it('rebinds relay listener after successful connect', async () => {
+      it('tracks and binds the relay listener after successful connect', async () => {
         await webinar.updatePSDataChannel();
 
+        // Stores the exact listener reference for deterministic cleanup
+        assert.equal(webinar._practiceSessionRelayListener, processRelayEvent);
         assert.calledWith(
-          webex.internal.llm.off,
+          webex.internal.llm.on,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
           processRelayEvent
         );
+      });
+
+      it('removes a previously tracked relay listener before re-binding on reconnect', async () => {
+        const previousListener = sinon.stub();
+        webinar._practiceSessionRelayListener = previousListener;
+
+        await webinar.updatePSDataChannel();
+
         assert.calledWith(
-          webex.internal.llm.on,
+          webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
+          previousListener
         );
+        assert.equal(webinar._practiceSessionRelayListener, processRelayEvent);
       });
 
       it('subscribes to transcription when caption intent is enabled', async () => {
@@ -491,7 +616,7 @@ describe('plugin-meetings', () => {
           updateMediaShares = sinon.stub()
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
@@ -546,7 +671,7 @@ describe('plugin-meetings', () => {
 
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
@@ -974,7 +1099,7 @@ describe('plugin-meetings', () => {
           // @ts-ignore
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {
@@ -991,7 +1116,7 @@ describe('plugin-meetings', () => {
         it('throws an error if attendeeSearchUrl is not available', async () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {