@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -1,11 +1,9 @@
-import {assert} from '@webex/test-helper-chai';
+import {assert, expect} from '@webex/test-helper-chai';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import Webinar from '@webex/plugin-meetings/src/webinar';
 import MockWebex from '@webex/test-helper-mock-webex';
 import uuid from 'uuid';
 import sinon from 'sinon';
-import {DataChannelTokenType} from '@webex/internal-plugin-llm';
-import {LLM_PRACTICE_SESSION, SHARE_STATUS} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
     describe('Webinar', () => {
@@ -28,20 +26,7 @@ describe('plugin-meetings', () => {
             webex.meetings = {};
             webex.credentials.getUserToken = getUserTokenStub;
             webex.meetings.getMeetingByType = sinon.stub();
-            webex.internal.voicea.announce = sinon.stub();
-
-      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(),
-        on: sinon.stub(),
-        getLocusUrl: sinon.stub().returns('old-locus-url'),
-        getDatachannelUrl: sinon.stub().returns('old-dc-url'),
-        registerAndConnect: sinon.stub().resolves('REGISTER_AND_CONNECT_RESULT'),
-      };
+
         });
 
         afterEach(() => {
@@ -162,399 +147,20 @@ describe('plugin-meetings', () => {
           assert.equal(result.isPromoted, false, 'should not indicate promotion');
           assert.equal(result.isDemoted, false, 'should not indicate demotion');
         });
-
-      it('handles missing role payload safely', () => {
-        const updateStatusByRoleStub = sinon.stub(webinar, 'updateStatusByRole');
-
-        const result = webinar.updateRoleChanged(undefined);
-
-        assert.equal(webinar.selfIsPanelist, false);
-        assert.equal(webinar.selfIsAttendee, false);
-        assert.equal(webinar.canManageWebcast, false);
-        assert.deepEqual(result, {isPromoted: false, isDemoted: false});
-        assert.calledOnceWithExactly(updateStatusByRoleStub, {isPromoted: false, isDemoted: false});
-      });
-    });
-
-    describe('#cleanUp', () => {
-      it('delegates to cleanupPSDataChannel', () => {
-        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
-
-        webinar.cleanUp();
-
-        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
-      });
-    });
-
-    describe('#cleanupPSDataChannel', () => {
-      let meeting;
-
-      beforeEach(() => {
-        meeting = {
-          processRelayEvent: sinon.stub(),
-        };
-
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
-      });
-
-      it('disconnects the practice session channel and removes the relay listener', async () => {
-        await webinar.cleanupPSDataChannel();
-
-        assert.calledOnceWithExactly(
-          webex.internal.llm.disconnectLLM,
-          {code: 3050, reason: 'done (permanent)'},
-          LLM_PRACTICE_SESSION
-        );
-        assert.calledOnceWithExactly(
-          webex.internal.llm.off,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting.processRelayEvent
-        );
-      });
-
-      it('removes a pending online listener if one exists', async () => {
-        const listener = sinon.stub();
-        webinar._pendingOnlineListener = listener;
-
-        await webinar.cleanupPSDataChannel();
-
-        assert.calledWith(webex.internal.llm.off, 'online', listener);
-        assert.isNull(webinar._pendingOnlineListener);
-      });
-
-      it('skips online listener removal when none is pending', async () => {
-        webinar._pendingOnlineListener = null;
-
-        await webinar.cleanupPSDataChannel();
-
-        // 'off' should only be called for the relay event, not for 'online'
-        const onlineOffCalls = webex.internal.llm.off.args.filter(([event]) => event === 'online');
-        assert.equal(onlineOffCalls.length, 0);
-      });
-    });
-
-    describe('#updatePSDataChannel', () => {
-      let meeting;
-      let processRelayEvent;
-
-      beforeEach(() => {
-        processRelayEvent = sinon.stub();
-        meeting = {
-          isJoined: sinon.stub().returns(true),
-          processRelayEvent,
-          locusInfo: {
-            url: 'locus-url',
-            info: {practiceSessionDatachannelUrl: 'dc-url'},
-          },
-        };
-
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
-
-        // Default session is connected by default; practice session is not
-        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
-        });
-
-        // Token is pre-saved into LLM by saveDataChannelToken
-        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
-          if (tokenType === DataChannelTokenType.PracticeSession) return 'ps-token';
-          return undefined;
-        });
-
-        // Ensure connect path is eligible
-        webinar.selfIsPanelist = true;
-        webinar.practiceSessionEnabled = true;
-        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(false);
-        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();
-
-        const result = await webinar.updatePSDataChannel();
-
-        assert.isUndefined(result);
-        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-      });
-
-      it('no-ops when meeting is not joined', async () => {
-        meeting.isJoined.returns(false);
-        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
-
-        const result = await webinar.updatePSDataChannel();
-
-        assert.isUndefined(result);
-        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-      });
-
-      it('no-ops when practiceSessionDatachannelUrl is missing', async () => {
-        meeting.locusInfo.info.practiceSessionDatachannelUrl = undefined;
-
-        const result = await webinar.updatePSDataChannel();
-
-        assert.isUndefined(result);
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-      });
-
-      it('no-ops when already connected to the same endpoints', async () => {
-        webex.internal.llm.isConnected.returns(true);
-        webex.internal.llm.getLocusUrl.returns('locus-url');
-        webex.internal.llm.getDatachannelUrl.returns('dc-url');
-        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
-
-        const result = await webinar.updatePSDataChannel();
-
-        assert.isUndefined(result);
-        assert.notCalled(cleanupPSDataChannelStub);
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-      });
-
-      it('connects when eligible', async () => {
-        const result = await webinar.updatePSDataChannel();
-
-        assert.calledOnce(webex.internal.llm.registerAndConnect);
-        assert.calledWith(
-          webex.internal.llm.registerAndConnect,
-          'locus-url',
-          'dc-url',
-          'ps-token',
-          LLM_PRACTICE_SESSION
-        );
-        assert.calledOnceWithExactly(webex.internal.voicea.announce);
-        assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
-      });
-
-      it('uses token from LLM', async () => {
-        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
-          if (tokenType === DataChannelTokenType.PracticeSession) return 'cached-token';
-          return undefined;
-        });
-
-        await webinar.updatePSDataChannel();
-
-        assert.calledWithExactly(
-          webex.internal.llm.getDatachannelToken,
-          DataChannelTokenType.PracticeSession
-        );
-        assert.notCalled(webex.internal.llm.setDatachannelToken);
-        assert.calledWith(
-          webex.internal.llm.registerAndConnect,
-          'locus-url',
-          'dc-url',
-          'cached-token',
-          LLM_PRACTICE_SESSION
-        );
-      });
-
-      it('cleans up the existing practice session channel before reconnecting to new endpoints', async () => {
-        webex.internal.llm.isConnected.returns(true);
-        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
-
-        await webinar.updatePSDataChannel();
-
-        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
-        assert.calledOnce(webex.internal.llm.registerAndConnect);
-      });
-
-      it('rebinds relay listener after successful connect', async () => {
-        await webinar.updatePSDataChannel();
-
-        assert.calledWith(
-          webex.internal.llm.off,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
-        );
-        assert.calledWith(
-          webex.internal.llm.on,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
-        );
-      });
-
-      it('subscribes to transcription when caption intent is enabled', async () => {
-        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(true);
-
-        await webinar.updatePSDataChannel();
-
-        assert.calledOnceWithExactly(webex.internal.voicea.updateSubchannelSubscriptions, { subscribe: ['transcription'] });
-      });
-
-      it('does not subscribe to transcription when caption intent is disabled', async () => {
-        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(false);
-
-        await webinar.updatePSDataChannel();
-
-        assert.notCalled(webex.internal.voicea.updateSubchannelSubscriptions);
-      });
-
-      it('defers connect when default session is not yet connected', async () => {
-        // Default session is not connected initially
-        webex.internal.llm.isConnected = sinon.stub().returns(false);
-
-        const result = await webinar.updatePSDataChannel();
-
-        // Should return undefined immediately (deferred)
-        assert.isUndefined(result);
-        // Should register an 'online' listener but NOT call registerAndConnect yet
-        assert.calledWith(webex.internal.llm.on, 'online', sinon.match.func);
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-        // Should store the pending listener
-        assert.isNotNull(webinar._pendingOnlineListener);
-      });
-
-      it('does not register duplicate online listeners on repeated calls', async () => {
-        webex.internal.llm.isConnected = sinon.stub().returns(false);
-
-        await webinar.updatePSDataChannel();
-        await webinar.updatePSDataChannel();
-        await webinar.updatePSDataChannel();
-
-        // Only one 'online' listener should have been registered
-        const onlineCalls = webex.internal.llm.on.args.filter(([event]) => event === 'online');
-        assert.equal(onlineCalls.length, 1, 'should register exactly one online listener');
-      });
-
-      it('re-invokes updatePSDataChannel when default session comes online', async () => {
-        // Default session is not connected initially
-        webex.internal.llm.isConnected = sinon.stub().returns(false);
-
-        const updatePSDataChannelSpy = sinon.spy(webinar, 'updatePSDataChannel');
-
-        // First call defers
-        await webinar.updatePSDataChannel();
-
-        // Capture the 'online' listener
-        const onlineCall = webex.internal.llm.on.args.find(([event]) => event === 'online');
-        assert.isDefined(onlineCall, 'should have registered an online listener');
-
-        // Now simulate default session coming online
-        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
-        });
-
-        // Fire the captured listener
-        onlineCall[1]();
-
-        // The listener should have cleared itself, removed itself, and re-called updatePSDataChannel
-        assert.isNull(webinar._pendingOnlineListener);
-        assert.calledWith(webex.internal.llm.off, 'online', sinon.match.func);
-        assert.equal(updatePSDataChannelSpy.callCount, 2);
-      });
-
-      it('does not reconnect with stale data if demoted before default session comes online', async () => {
-        // Default session is not connected initially
-        webex.internal.llm.isConnected = sinon.stub().returns(false);
-
-        await webinar.updatePSDataChannel();
-
-        // Capture the 'online' listener
-        const onlineCall = webex.internal.llm.on.args.find(([event]) => event === 'online');
-        assert.isDefined(onlineCall);
-
-        // Simulate demotion while waiting
-        webinar.selfIsPanelist = false;
-
-        // Now default session comes online
-        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
-        });
-
-        // Fire the listener — re-invokes updatePSDataChannel which will see isPracticeSession = false
-        onlineCall[1]();
-
-        // Should NOT have called registerAndConnect since the user is no longer eligible
-        assert.notCalled(webex.internal.llm.registerAndConnect);
-      });
-
-      it('proceeds immediately when default session is already connected', async () => {
-        // Default session already connected, practice session not
-        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
-        });
-
-        const result = await webinar.updatePSDataChannel();
-
-        // The 'online' listener is registered then immediately removed since default session is already connected
-        assert.calledWith(webex.internal.llm.on, 'online', sinon.match.func);
-        assert.calledWith(webex.internal.llm.off, 'online', sinon.match.func);
-        assert.isNull(webinar._pendingOnlineListener);
-        assert.calledOnce(webex.internal.llm.registerAndConnect);
-        assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
-      });
       });
 
       describe('#updateStatusByRole', () => {
+        let updateLLMConnection;
         let updateMediaShares;
         beforeEach(() => {
+          // @ts-ignore
+          updateLLMConnection = sinon.stub();
           updateMediaShares = sinon.stub()
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
-              isJoined: sinon.stub().returns(false),
-              updateLLMConnection: sinon.stub(),
-              shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
+              updateLLMConnection: updateLLMConnection,
+              shareStatus: 'whiteboard_share_active',
               locusInfo: {
                 mediaShares: 'mediaShares',
                 updateMediaShares: updateMediaShares
@@ -567,20 +173,40 @@ describe('plugin-meetings', () => {
           sinon.restore();
         });
 
+        it('trigger updateLLMConnection if PS started', () => {
+
+          webinar.practiceSessionEnabled = true;
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.calledOnce(updateLLMConnection);
+        });
+
+        it('Not trigger updateLLMConnection if PS not started', () => {
+
+          webinar.practiceSessionEnabled = false;
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.notCalled(updateLLMConnection);
+        });
+
         it('trigger updateMediaShares if promoted', () => {
 
           const roleChange = {isPromoted: true, isDemoted: false};
 
-          webinar.updateStatusByRole(roleChange);
+          const result = webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
+          assert.calledOnce(updateMediaShares);
         });
 
         it('Not trigger updateMediaShares if no role change', () => {
 
           const roleChange = {isPromoted: false, isDemoted: false};
 
-          webinar.updateStatusByRole(roleChange);
+          const result = webinar.updateStatusByRole(roleChange);
 
           assert.notCalled(updateMediaShares);
         });
@@ -588,18 +214,18 @@ describe('plugin-meetings', () => {
 
           const roleChange = {isPromoted: true, isDemoted: false};
 
-          webinar.updateStatusByRole(roleChange);
+          const result = webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
+          assert.calledOnce(updateMediaShares);
         });
 
         it('trigger updateMediaShares if is attendee with whiteboard share', () => {
 
           const roleChange = {isPromoted: false, isDemoted: true};
 
-          webinar.updateStatusByRole(roleChange);
+          const result = webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
+          assert.calledOnce(updateMediaShares);
         });
 
         it('Not trigger updateMediaShares if is attendee with screen share', () => {
@@ -607,9 +233,8 @@ describe('plugin-meetings', () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
-              isJoined: sinon.stub().returns(false),
-              updateLLMConnection: sinon.stub(),
-              shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
+              updateLLMConnection: updateLLMConnection,
+              shareStatus: 'remote_share_active',
               locusInfo: {
                 mediaShares: 'mediaShares',
                 updateMediaShares: updateMediaShares
@@ -619,18 +244,10 @@ describe('plugin-meetings', () => {
 
           const roleChange = {isPromoted: false, isDemoted: true};
 
-          webinar.updateStatusByRole(roleChange);
+          const result = webinar.updateStatusByRole(roleChange);
 
           assert.notCalled(updateMediaShares);
         });
-
-      it('updates PS data channel based on join eligibility', () => {
-        const updatePSDataChannelStub = sinon.stub(webinar, 'updatePSDataChannel').resolves();
-
-        webinar.updateStatusByRole({isPromoted: false, isDemoted: false});
-
-        assert.calledOnceWithExactly(updatePSDataChannelStub);
-      });
       });
 
       describe("#setPracticeSessionState", () => {
@@ -706,14 +323,6 @@ describe('plugin-meetings', () => {
 
           assert.equal(webinar.practiceSessionEnabled, false);
         });
-      it('triggers PS data channel update using computed eligibility', () => {
-        webinar.selfIsPanelist = true;
-        const updatePSDataChannelStub = sinon.stub(webinar, 'updatePSDataChannel').resolves();
-
-        webinar.updatePracticeSessionStatus({enabled: true});
-
-        assert.calledOnceWithExactly(updatePSDataChannelStub);
-      });
       });
 
       describe("#startWebcast", () => {
@@ -1022,111 +631,5 @@ describe('plugin-meetings', () => {
           }
         });
       });
-
-      describe("#searchLargeScaleWebinarAttendees", () => {
-        const attendeeSearchUrl = 'https://locusUrl/attendees/search';
-        const params = {
-          queryString: 'queryString',
-          limit: 50,
-          next: null,
-        };
-        beforeEach(() => {
-          // @ts-ignore
-          webinar.webex.meetings = {
-            getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
-              locusInfo: {
-                links:{
-                  resources: {
-                    attendeeSearch: {
-                      url: attendeeSearchUrl
-                    }
-                  }
-                }
-              }
-            })
-          };
-        });
-
-        it('throws an error if attendeeSearchUrl is not available', async () => {
-          webinar.webex.meetings = {
-            getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
-              locusInfo: {
-                links:{
-                  resources: {
-                    attendeeSearch: {
-                      url: null
-                    }
-                  }
-                }
-              }
-            })
-          };
-          try {
-            await webinar.searchLargeScaleWebinarAttendees(params);
-            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
-          } catch (error) {
-            assert.equal(error.message,'Meeting:webinar5k#Attendee search url is not available', 'should throw the correct error');
-          }
-        });
-
-        it('sends a GET request to search the large scale webinar attendees', async () => {
-          const result = await webinar.searchLargeScaleWebinarAttendees(params);
-          assert.calledOnce(webex.request);
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            uri: `${attendeeSearchUrl}?search_text=${encodeURIComponent(params.queryString)}&limit=50`,
-            headers: {
-              authorization: 'test-token',
-              trackingId: 'webex-js-sdk_test-uuid',
-            },
-          });
-          assert.equal(
-            result,
-            'REQUEST_RETURN_VALUE',
-            'should return the resolved value from the request'
-          );
-        });
-
-        it('queryString is empty string', async () => {
-          params.queryString = '';
-          const result = await webinar.searchLargeScaleWebinarAttendees(params);
-          assert.calledOnce(webex.request);
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            uri: `${attendeeSearchUrl}?limit=50`,
-            headers: {
-              authorization: 'test-token',
-              trackingId: 'webex-js-sdk_test-uuid',
-            },
-          });
-          assert.equal(
-            result,
-            'REQUEST_RETURN_VALUE',
-            'should return the resolved value from the request'
-          );
-        });
-
-        it('handles API call failures gracefully', async () => {
-          webex.request.rejects(new Error('API_ERROR'));
-          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
-
-          try {
-            await webinar.searchLargeScaleWebinarAttendees(params);
-            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
-          } catch (error) {
-            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
-            assert.calledOnce(errorLogger);
-            assert.calledWith(
-              errorLogger,
-              'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed',
-              sinon.match.instanceOf(Error)
-            );
-          } finally {
-            errorLogger.restore();
-          }
-        });
-      });
     })
 })