@webex/internal-plugin-voicea 3.0.0-beta.4 → 3.0.0-beta.400

package/test/unit/spec/voicea.js

@@ -1,6 +1,7 @@
+import 'jsdom-global/register';
 import MockWebex from '@webex/test-helper-mock-webex';
 import MockWebSocket from '@webex/test-helper-mock-web-socket';
-import {assert} from '@webex/test-helper-chai';
+import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import Mercury from '@webex/internal-plugin-mercury';
 import LLMChannel from '@webex/internal-plugin-llm';
@@ -41,17 +42,26 @@ describe('plugin-voicea', () => {
       });
     });
 
+    describe("#constructor", () => {
+      it('should init status', () => {
+        assert.equal(voiceaService.announceStatus, 'idle');
+        assert.equal(voiceaService.captionStatus, 'idle');
+      });
+    });
+
     describe('#sendAnnouncement', () => {
       beforeEach(async () => {
         const mockWebSocket = new MockWebSocket();
 
         voiceaService.webex.internal.llm.socket = mockWebSocket;
+        voiceaService.announceStatus = "idle";
       });
 
       it("sends announcement if voicea hasn't joined", () => {
         const spy = sinon.spy(voiceaService, 'listenToEvents');
 
         voiceaService.sendAnnouncement();
+        assert.equal(voiceaService.announceStatus, 'joining');
         assert.calledOnce(spy);
 
         assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
@@ -98,16 +108,14 @@ describe('plugin-voicea', () => {
           data: {relayType: 'voicea.annc', voiceaPayload: {}},
         });
 
-        assert.equal(voiceaService.hasVoiceaJoined, true);
         assert.equal(voiceaService.areCaptionsEnabled, true);
-        assert.equal(voiceaService.isTranscribingEnabled, true);
         assert.equal(voiceaService.vmcDeviceId, 'ws');
 
         voiceaService.deregisterEvents();
-        assert.equal(voiceaService.hasVoiceaJoined, false);
         assert.equal(voiceaService.areCaptionsEnabled, false);
-        assert.equal(voiceaService.isTranscribingEnabled, false);
         assert.equal(voiceaService.vmcDeviceId, undefined);
+        assert.equal(voiceaService.announceStatus, 'idle');
+        assert.equal(voiceaService.captionStatus, 'idle');
       });
     });
     describe('#processAnnouncementMessage', () => {
@@ -194,28 +202,38 @@ describe('plugin-voicea', () => {
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
-            body: {languageCode},
+            body: {
+              transcribe: {
+                spokenLanguage: languageCode
+              }
+            },
           })
         );
       });
     });
 
-    describe('#turnOnCaptions', () => {
+    describe('#requestTurnOnCaptions', () => {
       beforeEach(async () => {
         const mockWebSocket = new MockWebSocket();
 
         voiceaService.webex.internal.llm.socket = mockWebSocket;
+        voiceaService.captionStatus = 'idle';
       });
 
+      afterEach( () => {
+        voiceaService.captionStatus = 'idle';
+      })
+
       it('turns on captions', async () => {
-        const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
+        const announcementSpy = sinon.spy(voiceaService, 'announce');
 
         const triggerSpy = sinon.spy();
 
         voiceaService.on(EVENT_TRIGGERS.CAPTIONS_TURNED_ON, triggerSpy);
         voiceaService.listenToEvents();
 
-        await voiceaService.turnOnCaptions();
+        await voiceaService.requestTurnOnCaptions();
+        assert.equal(voiceaService.captionStatus, 'enabled');
         sinon.assert.calledWith(
           voiceaService.request,
           sinon.match({
@@ -230,18 +248,119 @@ describe('plugin-voicea', () => {
         assert.calledOnce(announcementSpy);
       });
 
-      it("doesn't call API on captions", async () => {
-        await voiceaService.turnOnCaptions();
+      it("should handle request fail", async () => {
+        voiceaService.captionStatus = 'sending';
+        voiceaService.request = sinon.stub().rejects();
+        
+        try {
+          await voiceaService.requestTurnOnCaptions();
+        } catch (error) {
+          expect(error.message).to.include('turn on captions fail');
+          return;
+        }
+        assert.equal(voiceaService.captionStatus, 'idle');
+      });
+    });
 
-        // eslint-disable-next-line no-underscore-dangle
-        voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.annc', voiceaPayload: {}},
+    describe("#isAnnounceProcessing", () => {
+      afterEach(() => {
+        voiceaService.announceStatus = 'idle';
+      });
+
+      ['joining', 'joined'].forEach((status) => {
+        it(`should return true when status is ${status}`, () => {
+          voiceaService.announceStatus = status;
+          assert.equal(voiceaService.isAnnounceProcessing(), true);
         });
+      });
+
+      it('should return false when status is not processing status', () => {
+        voiceaService.announceStatus = 'idle';
+          assert.equal(voiceaService.isAnnounceProcessing(), false);
+      });
+    });
+
+    describe("#announce", () => {
+      let isAnnounceProcessing, sendAnnouncement;
+      beforeEach(() => {
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        sendAnnouncement = sinon.stub(voiceaService, 'sendAnnouncement');
+        isAnnounceProcessing = sinon.stub(voiceaService, 'isAnnounceProcessing').returns(false)
+      });
+
+      afterEach(() => {
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        isAnnounceProcessing.restore();
+        sendAnnouncement.restore();
+      });
+
+      it('announce to llm data channel', ()=> {
+        voiceaService.announce();
+        assert.calledOnce(sendAnnouncement);
+      });
+
+      it('announce to llm data channel before llm connected', ()=> {
+        voiceaService.webex.internal.llm.isConnected.returns(false);
+        assert.throws(() =>  voiceaService.announce(), "voicea can not announce before llm connected");
+        assert.notCalled(sendAnnouncement);
+      });
+
+      it('should not announce duplicate', () => {
+        isAnnounceProcessing.returns(true);
+        voiceaService.announce();
+        assert.notCalled(sendAnnouncement);
+      })
+    });
+
+    describe("#isCaptionProcessing", () => {
+      afterEach(() => {
+        voiceaService.captionStatus = 'idle';
+      });
+
+      ['sending', 'enabled'].forEach((status) => {
+        it(`should return true when status is ${status}`, () => {
+          voiceaService.captionStatus = status;
+          assert.equal(voiceaService.isCaptionProcessing(), true);
+        });
+      });
 
-        const response = await voiceaService.turnOnCaptions();
+      it('should return false when status is not processing status', () => {
+        voiceaService.captionStatus = 'idle';
+          assert.equal(voiceaService.isCaptionProcessing(), false);
+      });
+    });
+
+    describe('#turnOnCaptions', () => {
+      let requestTurnOnCaptions, isCaptionProcessing;
+      beforeEach(() => {
+        requestTurnOnCaptions = sinon.stub(voiceaService, 'requestTurnOnCaptions');
+        isCaptionProcessing = sinon.stub(voiceaService, 'isCaptionProcessing').returns(false);
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+      });
+
+      afterEach(() => {
+        requestTurnOnCaptions.restore();
+        isCaptionProcessing.restore();
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+      });
+
+      it('call request turn on captions', () => {
+        isCaptionProcessing.returns(false);
+        voiceaService.turnOnCaptions();
+        assert.calledOnce(requestTurnOnCaptions);
+      });
 
-        assert.equal(response, undefined);
+      it("turns on captions before llm connected", () => {
+        isCaptionProcessing.returns(false);
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        // assert.throws(() => voiceaService.turnOnCaptions(), "can not turn on captions before llm connected");
+        assert.notCalled(requestTurnOnCaptions);
+      });
+
+      it('should not turn on duplicate when processing', () => {
+        isCaptionProcessing.returns(true);
+        voiceaService.turnOnCaptions();
+        assert.notCalled(voiceaService.requestTurnOnCaptions);
       });
     });
 
@@ -263,9 +382,6 @@ describe('plugin-voicea', () => {
           data: {relayType: 'voicea.annc', voiceaPayload: {}},
         });
 
-        const triggerSpy = sinon.spy();
-
-        voiceaService.on(EVENT_TRIGGERS.TRANSCRIBING_ON, triggerSpy);
         voiceaService.listenToEvents();
 
         await voiceaService.toggleTranscribing(true);
@@ -278,16 +394,12 @@ describe('plugin-voicea', () => {
           })
         );
 
-        assert.calledOnce(triggerSpy);
         assert.notCalled(announcementSpy);
       });
 
       it('turns on transcribing with CC disabled', async () => {
         const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
 
-        const triggerSpy = sinon.spy();
-
-        voiceaService.on(EVENT_TRIGGERS.TRANSCRIBING_ON, triggerSpy);
         voiceaService.listenToEvents();
 
         await voiceaService.toggleTranscribing(true);
@@ -300,7 +412,6 @@ describe('plugin-voicea', () => {
           })
         );
 
-        assert.calledOnce(triggerSpy);
         assert.calledOnce(announcementSpy);
       });
 
@@ -309,9 +420,6 @@ describe('plugin-voicea', () => {
 
         const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
 
-        const triggerSpy = sinon.spy();
-
-        voiceaService.on(EVENT_TRIGGERS.TRANSCRIBING_OFF, triggerSpy);
         voiceaService.listenToEvents();
 
         await voiceaService.toggleTranscribing(false);
@@ -324,24 +432,8 @@ describe('plugin-voicea', () => {
           })
         );
 
-        assert.calledOnce(triggerSpy);
         assert.notCalled(announcementSpy);
       });
-
-      it("doesn't call API on same value", async () => {
-        await voiceaService.toggleTranscribing(true);
-        const triggerSpy = sinon.spy();
-        const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
-
-        voiceaService.on(EVENT_TRIGGERS.TRANSCRIBING_OFF, triggerSpy);
-
-        await voiceaService.toggleTranscribing(true);
-
-        assert.notCalled(triggerSpy);
-        assert.notCalled(announcementSpy);
-
-        assert.calledTwice(voiceaService.request);
-      });
     });
 
     describe('#processCaptionLanguageResponse', () => {
@@ -459,6 +551,9 @@ describe('plugin-voicea', () => {
           transcript_id: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
           ts: 1611653204.3147924,
           type: 'transcript_final_result',
+          translations: {
+            en: "Hello?",
+          },
           transcript: {
             alignments: [
               {
@@ -508,6 +603,9 @@ describe('plugin-voicea', () => {
         assert.calledOnceWithExactly(triggerSpy, {
           isFinal: true,
           transcriptId: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
+          translations: {
+            en: "Hello?"
+          },
           transcript: {
             csis: [3556942592],
             text: 'Hello?',
@@ -642,5 +740,19 @@ describe('plugin-voicea', () => {
         });
       });
     });
+
+    describe("#getCaptionStatus", () => {
+      it('works correctly', () => {
+        voiceaService.captionStatus = "enabled"
+        assert.equal(voiceaService.getCaptionStatus(), "enabled");
+      });
+    });
+
+    describe("#getAnnounceStatus", () => {
+      it('works correctly', () => {
+        voiceaService.announceStatus = "joined"
+        assert.equal(voiceaService.getAnnounceStatus(), "joined");
+      });
+    });
   });
 });