@webex/internal-plugin-voicea 3.12.0-next.9 → 3.12.0-task-refactor.1

package/test/unit/spec/voicea.js

@@ -7,11 +7,7 @@ import Mercury from '@webex/internal-plugin-mercury';
 import LLMChannel from '@webex/internal-plugin-llm';
 
 import VoiceaService from '../../../src/index';
-import {
-  EVENT_TRIGGERS,
-  LLM_PRACTICE_SESSION,
-  TOGGLE_MANUAL_CAPTION_STATUS,
-} from '../../../src/constants';
+import {EVENT_TRIGGERS, TOGGLE_MANUAL_CAPTION_STATUS} from '../../../src/constants';
 
 describe('plugin-voicea', () => {
   const locusUrl = 'locusUrl';
@@ -32,7 +28,6 @@ describe('plugin-voicea', () => {
       voiceaService.connect = sinon.stub().resolves(true);
       voiceaService.webex.internal.llm.isConnected = sinon.stub().returns(true);
       voiceaService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
-      voiceaService.webex.internal.llm.getSocket = sinon.stub().returns(undefined);
       voiceaService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
 
       voiceaService.request = sinon.stub().resolves({
@@ -92,34 +87,7 @@ describe('plugin-voicea', () => {
 
         voiceaService.sendAnnouncement();
 
-        assert.calledTwice(spy);
-        assert.calledWith(spy, 'event:relay.event', sinon.match.func);
-        assert.calledWith(spy, `event:relay.event:${LLM_PRACTICE_SESSION}`, sinon.match.func);
-      });
-
-      it('includes captionServiceId in headers when set', () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.announceStatus = 'idle';
-        voiceaService.captionServiceId = 'svc-123';
-
-        voiceaService.sendAnnouncement();
-
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
-          id: '1',
-          type: 'publishRequest',
-          recipients: {route: undefined},
-          headers: {to: 'svc-123'},
-          data: {
-            clientPayload: {
-              version: 'v2',
-            },
-            eventType: 'relay.event',
-            relayType: 'client.annc',
-          },
-          trackingId: sinon.match.string,
-        });
+        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func);
       });
     });
 
@@ -221,32 +189,32 @@ describe('plugin-voicea', () => {
         assert.notCalled(voiceaService.webex.internal.llm.socket.send);
       });
     });
+
     describe('#deregisterEvents', () => {
       beforeEach(async () => {
         const mockWebSocket = new MockWebSocket();
+
         voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.isCaptionBoxOn = true;
       });
 
-      it('deregisters voicea service and resets caption state', async () => {
+      it('deregisters voicea service', async () => {
         voiceaService.listenToEvents();
         await voiceaService.toggleTranscribing(true);
 
+        // eslint-disable-next-line no-underscore-dangle
         voiceaService.webex.internal.llm._emit('event:relay.event', {
           headers: {from: 'ws'},
           data: {relayType: 'voicea.annc', voiceaPayload: {}},
         });
 
         assert.equal(voiceaService.areCaptionsEnabled, true);
-        assert.equal(voiceaService.captionServiceId, 'ws');
-        assert.equal(voiceaService.isCaptionBoxOn, true);
+        assert.equal(voiceaService.vmcDeviceId, 'ws');
 
         voiceaService.deregisterEvents();
         assert.equal(voiceaService.areCaptionsEnabled, false);
-        assert.equal(voiceaService.captionServiceId, undefined);
+        assert.equal(voiceaService.vmcDeviceId, undefined);
         assert.equal(voiceaService.announceStatus, 'idle');
         assert.equal(voiceaService.captionStatus, 'idle');
-        assert.equal(voiceaService.isCaptionBoxOn, false);
       });
     });
     describe('#processAnnouncementMessage', () => {
@@ -276,7 +244,7 @@ describe('plugin-voicea', () => {
         });
       });
 
-      it('works on empty payload', async () => {
+      it('works on non-empty payload', async () => {
         const spy = sinon.spy();
 
         voiceaService.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
@@ -318,28 +286,6 @@ describe('plugin-voicea', () => {
           trackingId: sinon.match.string,
         });
       });
-
-      it('uses captionServiceId as "to" header when set', () => {
-        voiceaService.captionServiceId = 'svc-456';
-
-        voiceaService.requestLanguage('fr');
-
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
-          id: '1',
-          type: 'publishRequest',
-          recipients: {route: undefined},
-          headers: {to: 'svc-456'},
-          data: {
-            clientPayload: {
-              translationLanguage: 'fr',
-              id: sinon.match.string,
-            },
-            eventType: 'relay.event',
-            relayType: 'voicea.transl.req',
-          },
-          trackingId: sinon.match.string,
-        });
-      });
     });
 
     describe('#setSpokenLanguage', () => {
@@ -408,7 +354,6 @@ describe('plugin-voicea', () => {
 
       it('turns on captions', async () => {
         const announcementSpy = sinon.spy(voiceaService, 'announce');
-        const updateSubchannelSubscriptionsAndSyncCaptionStateSpy = sinon.spy(voiceaService, 'updateSubchannelSubscriptionsAndSyncCaptionState');
 
         const triggerSpy = sinon.spy();
 
@@ -429,11 +374,6 @@ describe('plugin-voicea', () => {
         assert.calledOnceWithExactly(triggerSpy);
 
         assert.calledOnce(announcementSpy);
-        assert.calledOnceWithExactly(
-          updateSubchannelSubscriptionsAndSyncCaptionStateSpy,
-          { subscribe: ['transcription'] },
-          true
-        );
       });
 
       it("should handle request fail", async () => {
@@ -468,61 +408,17 @@ describe('plugin-voicea', () => {
       });
     });
 
-    describe('#isLLMConnected', () => {
-      it('returns true when the default llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? false : true
-        );
-
-        assert.equal(voiceaService.isLLMConnected(), true);
-      });
-
-      it('returns true when only the practice session llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
-        );
-
-        assert.equal(voiceaService.isLLMConnected(), true);
-      });
-
-      it('returns false when neither llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.returns(false);
-
-        assert.equal(voiceaService.isLLMConnected(), false);
-      });
-    });
-
-    describe('#getIsCaptionBoxOn', () => {
-      beforeEach(() => {
-        voiceaService.isCaptionBoxOn = false;
-      });
-
-      it('returns false when captions are disabled', () => {
-        voiceaService.isCaptionBoxOn = false;
-
-        const result = voiceaService.getIsCaptionBoxOn();
-
-        assert.equal(result, false);
-      });
-
-      it('returns true when captions are enabled', () => {
-        voiceaService.isCaptionBoxOn = true;
-
-        const result = voiceaService.getIsCaptionBoxOn();
-
-        assert.equal(result, true);
-      });
-    });
-
     describe("#announce", () => {
-      let isAnnounceProcessed, sendAnnouncement;
+      let isAnnounceProcessing, sendAnnouncement;
       beforeEach(() => {
+        voiceaService.webex.internal.llm.isConnected.returns(true);
         sendAnnouncement = sinon.stub(voiceaService, 'sendAnnouncement');
-        isAnnounceProcessed = sinon.stub(voiceaService, 'isAnnounceProcessed').returns(false)
+        isAnnounceProcessing = sinon.stub(voiceaService, 'isAnnounceProcessing').returns(false)
       });
 
       afterEach(() => {
-        isAnnounceProcessed.restore();
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        isAnnounceProcessing.restore();
         sendAnnouncement.restore();
       });
 
@@ -537,18 +433,8 @@ describe('plugin-voicea', () => {
         assert.notCalled(sendAnnouncement);
       });
 
-      it('announce to llm data channel when only practice session is connected', ()=> {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
-        );
-
-        voiceaService.announce();
-
-        assert.calledOnce(sendAnnouncement);
-      });
-
       it('should not announce duplicate', () => {
-        isAnnounceProcessed.returns(true);
+        isAnnounceProcessing.returns(true);
         voiceaService.announce();
         assert.notCalled(sendAnnouncement);
       })
@@ -577,11 +463,13 @@ describe('plugin-voicea', () => {
       beforeEach(() => {
         requestTurnOnCaptions = sinon.stub(voiceaService, 'requestTurnOnCaptions');
         voiceaService.captionStatus = 'idle';
+        voiceaService.webex.internal.llm.isConnected.returns(true);
       });
 
       afterEach(() => {
         requestTurnOnCaptions.restore();
         voiceaService.captionStatus = 'idle';
+        voiceaService.webex.internal.llm.isConnected.returns(true);
       });
 
       it('call request turn on captions', () => {
@@ -590,27 +478,13 @@ describe('plugin-voicea', () => {
         assert.calledOnce(requestTurnOnCaptions);
       });
 
-      it('throws before turning on captions when llm is not connected', async () => {
+      it("turns on captions before llm connected", () => {
         voiceaService.captionStatus = 'idle';
-        voiceaService.webex.internal.llm.isConnected.returns(false);
-
-        await assert.isRejected(
-          voiceaService.turnOnCaptions(),
-          'can not turn on captions before llm connected'
-        );
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        // assert.throws(() => voiceaService.turnOnCaptions(), "can not turn on captions before llm connected");
         assert.notCalled(requestTurnOnCaptions);
       });
 
-      it('turns on captions when only the practice session llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
-        );
-
-        voiceaService.turnOnCaptions();
-
-        assert.calledOnce(requestTurnOnCaptions);
-      });
-
       it('should not turn on duplicate when processing', () => {
         voiceaService.captionStatus = 'sending';
         voiceaService.turnOnCaptions();
@@ -1227,357 +1101,5 @@ describe('plugin-voicea', () => {
         assert.calledOnceWithExactly(triggerSpy, {languageCode, meetingId: '123'});
       });
     });
-
-    describe('#onCaptionServiceIdUpdate', () => {
-      let mockWebSocket;
-
-      beforeEach(() => {
-        mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.webex.internal.llm.isConnected.returns(true);
-        voiceaService.seqNum = 1;
-      });
-
-      it('does nothing when serviceId is falsy', () => {
-        voiceaService.captionServiceId = 'existing-id';
-        voiceaService.currentCaptionLanguage = 'en';
-
-        voiceaService.onCaptionServiceIdUpdate(undefined);
-        voiceaService.onCaptionServiceIdUpdate('');
-
-        assert.equal(voiceaService.captionServiceId, 'existing-id');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
-      });
-
-      it('sets captionServiceId when no currentCaptionLanguage', () => {
-        voiceaService.captionServiceId = undefined;
-        voiceaService.currentCaptionLanguage = undefined;
-
-        voiceaService.onCaptionServiceIdUpdate('svc-new');
-
-        assert.equal(voiceaService.captionServiceId, 'svc-new');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
-      });
-
-      it('re-sends language when serviceId changes and currentCaptionLanguage is set', () => {
-        voiceaService.captionServiceId = 'old-svc';
-        voiceaService.currentCaptionLanguage = 'es';
-
-        voiceaService.onCaptionServiceIdUpdate('new-svc');
-
-        assert.equal(voiceaService.captionServiceId, 'new-svc');
-        assert.calledOnce(voiceaService.webex.internal.llm.socket.send);
-
-        const callArgs = voiceaService.webex.internal.llm.socket.send.getCall(0).args[0];
-        expect(callArgs).to.have.nested.property('headers.to', 'new-svc');
-        expect(callArgs).to.have.nested.property('data.clientPayload.translationLanguage', 'es');
-      });
-
-      it('does not re-send language when serviceId is unchanged', () => {
-        voiceaService.captionServiceId = 'same-svc';
-        voiceaService.currentCaptionLanguage = 'de';
-
-        voiceaService.onCaptionServiceIdUpdate('same-svc');
-
-        assert.equal(voiceaService.captionServiceId, 'same-svc');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
-      });
-    });
-
-    describe('#updateSubchannelSubscriptions', () => {
-      beforeEach(() => {
-        const mockWebSocket = new MockWebSocket();
-
-        sinon.stub(voiceaService, 'getPublishTransport').returns({
-          socket: mockWebSocket,
-          datachannelUrl: 'mock-datachannel-uri',
-        });
-
-        voiceaService.seqNum = 1;
-
-        voiceaService.isLLMConnected = sinon.stub().returns(true);
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
-      });
-
-      it('sends subchannelSubscriptionRequest with subscribe and unsubscribe lists', async () => {
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
-          unsubscribe: ['polls'],
-        });
-
-        const socket = voiceaService.getPublishTransport().socket;
-
-        sinon.assert.calledOnceWithExactly(
-          socket.send,
-          {
-            id: '1',
-            type: 'subchannelSubscriptionRequest',
-            data: {
-              datachannelUri: 'mock-datachannel-uri',
-              subscribe: ['transcription'],
-              unsubscribe: ['polls'],
-            },
-            trackingId: sinon.match.string,
-          }
-        );
-
-        sinon.assert.match(voiceaService.seqNum, 2);
-      });
-
-      it('sends empty arrays when no subscribe/unsubscribe provided', async () => {
-        await voiceaService.updateSubchannelSubscriptions({});
-
-        const socket = voiceaService.getPublishTransport().socket;
-
-        sinon.assert.calledOnceWithExactly(
-          socket.send,
-          {
-            id: '1',
-            type: 'subchannelSubscriptionRequest',
-            data: {
-              datachannelUri: 'mock-datachannel-uri',
-              subscribe: [],
-              unsubscribe: [],
-            },
-            trackingId: sinon.match.string,
-          }
-        );
-
-        sinon.assert.match(voiceaService.seqNum, 2);
-      });
-
-      it('does nothing when LLM is not connected', async () => {
-        voiceaService.isLLMConnected = sinon.stub().returns(false);
-
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
-        });
-
-        const socket = voiceaService.getPublishTransport().socket;
-
-        sinon.assert.notCalled(socket.send);
-        sinon.assert.match(voiceaService.seqNum, 1);
-      });
-
-      it('does nothing when dataChannelToken is not enabled', async () => {
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
-
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
-        });
-
-        const socket = voiceaService.getPublishTransport().socket;
-
-        sinon.assert.notCalled(socket.send);
-        sinon.assert.match(voiceaService.seqNum, 1);
-      });
-    });
-
-
-    describe('#updateSubchannelSubscriptionsAndSyncCaptionState', () => {
-      beforeEach(() => {
-        const mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-
-        voiceaService.webex.internal.llm.getDatachannelUrl = sinon.stub().returns('mock-datachannel-uri');
-
-        voiceaService.seqNum = 1;
-
-        voiceaService.isLLMConnected = sinon.stub().returns(true);
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
-
-        sinon.spy(voiceaService, 'updateSubchannelSubscriptions');
-      });
-
-      afterEach(() => {
-        sinon.restore();
-      });
-
-      it('updates caption intent and forwards subscribe/unsubscribe to updateSubchannelSubscriptions', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          {
-            subscribe: ['transcription'],
-            unsubscribe: ['polls'],
-          },
-          true
-        );
-
-        assert.equal(voiceaService.isCaptionBoxOn, true);
-
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          {
-            subscribe: ['transcription'],
-            unsubscribe: ['polls'],
-          }
-        );
-      });
-
-      it('sets caption intent to false when isCCBoxOpen is false', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          { subscribe: ['transcription'] },
-          false
-        );
-
-        assert.equal(voiceaService.isCaptionBoxOn, false);
-
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          { subscribe: ['transcription'] }
-        );
-      });
-
-      it('defaults subscribe/unsubscribe to empty arrays when options is empty', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState({}, true);
-
-        assert.equal(voiceaService.isCaptionBoxOn, true);
-
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          {}
-        );
-      });
-
-      it('still updates caption intent even if updateSubchannelSubscriptions does nothing (e.g., LLM not connected)', async () => {
-        voiceaService.isLLMConnected = sinon.stub().returns(false);
-
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          { subscribe: ['transcription'] },
-          true
-        );
-
-        assert.equal(voiceaService.isCaptionBoxOn, true);
-
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          { subscribe: ['transcription'] }
-        );
-      });
-    });
-
-    describe('#multiple llm connections', () => {
-      let defaultSocket;
-      let practiceSocket;
-      let isPracticeSessionConnected;
-
-      beforeEach(() => {
-        defaultSocket = new MockWebSocket();
-        practiceSocket = new MockWebSocket();
-        isPracticeSessionConnected = true;
-
-        voiceaService.webex.internal.llm.socket = defaultSocket;
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? isPracticeSessionConnected : true
-        );
-        voiceaService.webex.internal.llm.getSocket.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? practiceSocket : undefined
-        );
-        voiceaService.webex.internal.llm.getBinding.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? 'practice-binding' : 'default-binding'
-        );
-        voiceaService.seqNum = 1;
-      });
-
-      it('sendAnnouncement uses the practice session socket and binding when available', () => {
-        voiceaService.announceStatus = 'idle';
-
-        voiceaService.sendAnnouncement();
-
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
-
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
-      });
-
-      it('sendAnnouncement falls back to the default socket and binding when the practice session is not connected', () => {
-        voiceaService.announceStatus = 'idle';
-        isPracticeSessionConnected = false;
-
-        voiceaService.sendAnnouncement();
-
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
-
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
-      });
-
-      it('requestLanguage uses the practice session socket and binding when available', () => {
-        voiceaService.requestLanguage('fr');
-
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
-
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
-        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
-      });
-
-      it('requestLanguage falls back to the default socket and binding when the practice session is not connected', () => {
-        isPracticeSessionConnected = false;
-
-        voiceaService.requestLanguage('fr');
-
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
-
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
-        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
-      });
-
-      it('sendManualClosedCaption uses the practice session socket and binding when available', () => {
-        voiceaService.sendManualClosedCaption('caption', 123, [456], true);
-
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
-
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
-        expect(sent).to.have.nested.property(
-          'data.transcriptPayload.type',
-          'manual_caption_final_result'
-        );
-      });
-
-      it('sendManualClosedCaption falls back to the default socket and binding when the practice session is not connected', () => {
-        isPracticeSessionConnected = false;
-
-        voiceaService.sendManualClosedCaption('caption', 123, [456], false);
-
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
-
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
-        expect(sent).to.have.nested.property(
-          'data.transcriptPayload.type',
-          'manual_caption_interim_result'
-        );
-      });
-
-      it('processes relay events from the practice session channel', async () => {
-        const announcementSpy = sinon.spy(voiceaService, 'processAnnouncementMessage');
-
-        voiceaService.listenToEvents();
-
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit(`event:relay.event:${LLM_PRACTICE_SESSION}`, {
-          headers: {from: 'svc-practice'},
-          data: {
-            relayType: 'voicea.annc',
-            voiceaPayload: {
-              translation: {allowed_languages: ['en'], max_languages: 1},
-              ASR: {spoken_languages: ['en']},
-            },
-          },
-          sequenceNumber: 10,
-        });
-
-        assert.calledOnce(announcementSpy);
-        assert.equal(voiceaService.captionServiceId, 'svc-practice');
-      });
-    });
   });
 });