@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0

package/test/unit/spec/meeting/voicea-meeting.ts

@@ -0,0 +1,266 @@
+import {
+    getSpeakerFromProxyOrStore,
+    processNewCaptions,
+} from '@webex/plugin-meetings/src/meeting/voicea-meeting';
+import {assert} from '@webex/test-helper-chai';
+import { expect } from 'chai';
+
+describe('plugin-meetings', () => {
+    let fakeMeeting, fakeVoiceaPayload;
+    const fakeMemberId = "4f35a5ab-f750-3ba7-b309-dea62a512257";
+    beforeEach(() => {
+        const fakeMemberList = {
+            [fakeMemberId]: {
+                participant: {
+                    person: {
+                        id: "8093d335-9b96-4f9d-a6b2-7293423be88a",
+                        name: "John Doe",
+                        isExternal: false,
+                        orgId: "1eb65fdf-9643-417f-9974-ad72cae0e10f",
+                        incomingCallProtocols: []
+                    },
+                    status: {
+                        audioStatus: "SENDRECV",
+                        videoStatus: "INACTIVE",
+                        videoSlidesStatus: "RECVONLY",
+                        audioSlidesStatus: "INACTIVE",
+                        csis: [
+                            3060099329,
+                            3060099328,
+                            1234867712,
+                            1234867713
+                        ]
+                    },
+                },
+                id: fakeMemberId
+            }
+        };
+
+        const fakeCaptions = {
+            captions: [
+                {
+                    id: "6bece1b9-4e50-fafe-fb63-d27d5fb27280",
+                    isFinal: true,
+                    text: "Oh it's not update.",
+                    currentSpokenLanguage: "en",
+                    timestamp: "1:34",
+                    speaker: {
+                        speakerId: "8093d335-9b96-4f9d-a6b2-7293423be88a",
+                        name: "John Doe"
+                    }
+                },
+                {
+                    id: "c34400a9-cb2b-20c3-d20c-bd7981cc62a9",
+                    isFinal: true,
+                    text: "Nice.",
+                    currentSpokenLanguage: "en",
+                    timestamp: "1:60",
+                    speaker: {
+                        speakerId: "8093d335-9b96-4f9d-a6b2-7293423be88a",
+                        name: "John Doe"
+                    }
+                },
+                {
+                    id: "311cc182-e657-c077-c078-795f866c4e9b_8093d335-9b96-4f9d-a6b2-7293423be88a",
+                    isFinal: false,
+                    text: " Don't bother me talking I'm just going to get the transcript data that is interim and I",
+                    currentCaptionLanguage: "en",
+                    speaker: {
+                        speakerId: "8093d335-9b96-4f9d-a6b2-7293423be88a",
+                        name: "John Doe"
+                    }
+                }
+            ],
+            interimCaptions: {
+                "6bece1b9-4e50-fafe-fb63-d27d5fb27280": [],
+                "c34400a9-cb2b-20c3-d20c-bd7981cc62a9": [],
+                "311cc182-e657-c077-c078-795f866c4e9b": [
+                    "311cc182-e657-c077-c078-795f866c4e9b_8093d335-9b96-4f9d-a6b2-7293423be88a"
+                ]
+            },
+            speakerProxy: {},
+        };
+
+        fakeMeeting = {
+            members: {
+                membersCollection: {
+                    members: fakeMemberList
+                }
+            },
+            transcription: fakeCaptions
+        }
+
+        fakeVoiceaPayload = {
+            isFinal: true,
+            transcriptId: "311cc182-e657-c077-c078-795f866c4e9b",
+            transcripts: [
+                {
+                    text: "Don't bother me talking I'm just going to get the transcript data that is interim and I needed if I keep talking, I get the interim data",
+                    csis: [
+                        1234867712
+                    ],
+                    transcript_language_code: "en"
+                }
+            ],
+            transcript: {
+                text: "Don't bother me talking I'm just going to get the transcript data that is interim and I needed if I keep talking, I get the interim data",
+                csis: [
+                    1234867712
+                ],
+                transcript_language_code: "en"
+            }
+        };
+    });
+
+    describe('voicea-meeting', () => {
+        it('should export the correct members', () => {
+            assert.isFunction(getSpeakerFromProxyOrStore);
+            assert.isFunction(processNewCaptions);
+        });
+
+        describe('getSpeakerFromProxyOrStore', () => {
+            it('should return a cached speaker if csisKey is in speakerProxy', () => {
+                // Add a speaker to the speakerProxy
+                const csisKey = 1234867712;
+                const cachedSpeaker = {
+                    speakerId: 'cached-speaker-id',
+                    name: 'Cached Speaker'
+                };
+                fakeMeeting.transcription.speakerProxy[csisKey] = cachedSpeaker;
+        
+                const { speaker, needsCaching } = getSpeakerFromProxyOrStore({
+                    csisKey,
+                    meetingMembers: fakeMeeting.members.membersCollection.members,
+                    transcriptData: fakeMeeting.transcription
+                });
+        
+                expect(speaker).to.deep.equal(cachedSpeaker);
+                expect(needsCaching).to.be.false;
+            });
+            
+            it('should find and cache a speaker if not already in speakerProxy', () => {
+                const csisKey = 1234867712; // This csis exists in the fakeMemberList
+        
+                // Ensure speakerProxy is empty
+                fakeMeeting.transcription.speakerProxy = {};
+        
+                const { speaker, needsCaching } = getSpeakerFromProxyOrStore({
+                    csisKey,
+                    meetingMembers: fakeMeeting.members.membersCollection.members,
+                    transcriptData: fakeMeeting.transcription
+                });
+        
+                expect(speaker.speakerId).to.equal(fakeMeeting.members.membersCollection.members[fakeMemberId].participant.person.id);
+                expect(speaker.name).to.equal(fakeMeeting.members.membersCollection.members[fakeMemberId].participant.person.name);
+                expect(needsCaching).to.be.true;
+            });
+        });
+
+        describe('processNewCaptions', () => {
+            it('should process new final captions correctly', () => {
+                let transcriptData = fakeMeeting.transcription;
+                let transcriptId = fakeVoiceaPayload.transcriptId;
+                delete fakeVoiceaPayload.transcripts;
+
+                // Assuming that processNewCaptions is a pure function that doesn't mutate the input but returns a new state
+                processNewCaptions({
+                  data: fakeVoiceaPayload,
+                  meeting: fakeMeeting
+                });
+
+                // Check if speaker details are cached if needed
+                const csisKey = fakeVoiceaPayload.transcript.csis[0];
+                const speaker = transcriptData.speakerProxy[csisKey];
+                expect(speaker).to.exist;
+
+                // Check if interim captions are removed
+                expect(transcriptData.interimCaptions[transcriptId]).to.deep.equal([]);
+
+                //check if the interim caption is removed
+                const oldInterimCaption = transcriptData.captions.find(caption => caption.id === `${transcriptId}_${speaker.speakerId}`);
+                expect(oldInterimCaption).to.not.exist;
+
+                // Check the final caption data
+                const newCaption = transcriptData.captions.find(caption => caption.id === transcriptId);
+                expect(newCaption).to.exist;
+                expect(newCaption).to.include({
+                  id: transcriptId,
+                  isFinal: fakeVoiceaPayload.isFinal,
+                  text: fakeVoiceaPayload.transcript.text,
+                  currentSpokenLanguage: fakeVoiceaPayload.transcript.transcript_language_code,
+                });
+
+                // Check the speaker data in the new caption
+                expect(newCaption.speaker).to.deep.equal(speaker);
+            });
+
+            it('should process new interim captions correctly', () => {
+                let transcriptData = fakeMeeting.transcription;
+                let transcriptId = fakeVoiceaPayload.transcriptId;
+                delete fakeVoiceaPayload.transcript;
+
+                transcriptData.captions.splice(transcriptData.length - 1, 1);
+                fakeVoiceaPayload.isFinal = false;
+
+                processNewCaptions({
+                  data: fakeVoiceaPayload,
+                  meeting: fakeMeeting
+                });
+
+                // Check if speaker details are cached if needed
+                const csisKey = fakeVoiceaPayload.transcripts[0].csis[0];
+                const speaker = transcriptData.speakerProxy[csisKey];
+                expect(speaker).to.exist;
+
+                // Check the final caption data
+                const newCaption = transcriptData.captions.find(caption => caption.id === `${transcriptId}_${speaker.speakerId}`);
+                expect(newCaption).to.exist;
+                expect(newCaption).to.include({
+                  id: `${transcriptId}_${speaker.speakerId}`,
+                  isFinal: fakeVoiceaPayload.isFinal,
+                  text: fakeVoiceaPayload.transcripts[0].text,
+                  currentCaptionLanguage: fakeVoiceaPayload.transcripts[0].transcript_language_code,
+                });
+
+                // Check if interim captions has the right caption id
+                expect(transcriptData.interimCaptions[transcriptId]).to.deep.equal([newCaption.id]);
+
+                // Check the speaker data in the new caption
+                expect(newCaption.speaker).to.deep.equal(speaker);
+            });
+
+            it('should process interim captions with an existing one correctly', () => {
+                let transcriptData = fakeMeeting.transcription;
+                let transcriptId = fakeVoiceaPayload.transcriptId;
+                delete fakeVoiceaPayload.transcript;
+                fakeVoiceaPayload.isFinal = false;
+
+                processNewCaptions({
+                  data: fakeVoiceaPayload,
+                  meeting: fakeMeeting
+                });
+
+                // Check if speaker details are cached if needed
+                const csisKey = fakeVoiceaPayload.transcripts[0].csis[0];
+                const speaker = transcriptData.speakerProxy[csisKey];
+                expect(speaker).to.exist;
+
+                // Check the final caption data
+                const newCaption = transcriptData.captions.find(caption => caption.id === `${transcriptId}_${speaker.speakerId}`);
+                expect(newCaption).to.exist;
+                expect(newCaption).to.include({
+                  id: `${transcriptId}_${speaker.speakerId}`,
+                  isFinal: fakeVoiceaPayload.isFinal,
+                  text: fakeVoiceaPayload.transcripts[0].text,
+                  currentCaptionLanguage: fakeVoiceaPayload.transcripts[0].transcript_language_code,
+                });
+
+                // Check if interim captions has the right caption id
+                expect(transcriptData.interimCaptions[transcriptId]).to.deep.equal([newCaption.id]);
+
+                // Check the speaker data in the new caption
+                expect(newCaption.speaker).to.deep.equal(speaker);
+            });
+        });
+    });
+});

package/test/unit/spec/meeting-info/index.js

@@ -25,42 +25,78 @@ describe('plugin-meetings', () => {
     });
 
     describe('#fetchMeetingInfo', () => {
-      it('should send ca events if meetingId present', async () => {
-        const body = {meetingKey: '1234323'};
+      const checkResolvedFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics, confIdStrProp}) => {
+        const body = {meetingKey: '1234323', url: 'url-123', confID: '123', meetingId: '321'};
+        const bodyConfIdStr = {meetingKey: '1234323', url: 'url-123', confIdStr: '123', meetingId: '321'};
 
         sinon
           .stub(MeetingInfoUtil, 'generateOptions')
           .resolves({type: 'MEETING_ID', destination: '123456'});
-        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(confIdStrProp ? bodyConfIdStr : body));
 
         await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null, {
-          meetingId: 'meetingId',
+          meetingId,
+          sendCAevents,
         });
 
         const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+        const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
 
-        assert.deepEqual(submitInternalEventCalls[0].args[0], {
-          name: 'internal.client.meetinginfo.request',
-        });
-        assert.deepEqual(submitInternalEventCalls[1].args[0], {
-          name: 'internal.client.meetinginfo.response',
-        });
+        if (shouldSendCAMetrics) {
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          assert.deepEqual(submitClientEventCalls[0].args[0], {
+            name: 'client.meetinginfo.request',
+            options: {
+              meetingId,
+            },
+          });
+
+          assert.deepEqual(submitInternalEventCalls[1].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          assert.deepEqual(submitClientEventCalls[1].args[0], {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'url-123',
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: '123',
+              globalMeetingId: '321'
+            },
+          });
+        } else {
+          assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+          assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+        }
+      }
+      it('should send ca events if meetingId present and send CA events is authorized', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true});
       });
 
-      it('should not send ca events if meetingId not present', async () => {
-        const body = {meetingKey: '1234323'};
+      it('should send ca events if meetingId present and send CA events is authorized and confIdStrProp is true', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true, confIdStrProp: true});
+      });
 
-        sinon
-          .stub(MeetingInfoUtil, 'generateOptions')
-          .resolves({type: 'MEETING_ID', destination: '123456'});
-        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+      it('should not send ca events if meetingId not present even if CA events are authorized', async () => {
+        checkResolvedFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false});
+      });
 
-        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null);
+      it('should not send ca events if CA events are not authorized', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false});
+      });
 
-        assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+      it('should not send ca events if meeting id is not present and CA events are not authorized', async () => {
+        checkResolvedFetchMeetingInfo({shouldSendCAMetrics: false});
       });
 
-      it('should send ca events when fails and if meetingId present', async () => {
+      const checkFailingFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics}) => {
         const reject = {
           statusCode: 403,
           body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
@@ -84,32 +120,66 @@ describe('plugin-meetings', () => {
             null,
             null,
             {
-              meetingId: 'meetingId',
+              meetingId,
+              sendCAevents,
             }
           );
         } catch (err) {
           const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
 
-          assert.deepEqual(submitInternalEventCalls[0].args[0], {
-            name: 'internal.client.meetinginfo.request',
-          });
+          if(shouldSendCAMetrics) {  
+            assert.deepEqual(submitInternalEventCalls[0].args[0], {
+              name: 'internal.client.meetinginfo.request',
+            });
 
-          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-            name: 'client.meetinginfo.response',
-            payload: {
-              identifiers: {
-                meetingLookupUrl: 'http://api-url.com',
+            assert.deepEqual(submitClientEventCalls[0].args[0], {
+              name: 'client.meetinginfo.request',
+              options: {
+                meetingId: 'meetingId',
               },
-            },
-            options: {
-              meetingId: 'meetingId',
-              rawError: err,
-            },
-          });
+            });
+
+            assert.deepEqual(submitInternalEventCalls[1].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+  
+            assert.deepEqual(submitClientEventCalls[1].args[0], {
+              name: 'client.meetinginfo.response',
+              payload: {
+                identifiers: {
+                  meetingLookupUrl: 'http://api-url.com',
+                },
+              },
+              options: {
+                meetingId: 'meetingId',
+                rawError: err,
+              },
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
         }
+      }
+
+      it('should send ca events when fails if meetingId present and CA events are authorized', async () => {
+        checkFailingFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true})
+      });
+
+      it('should not send ca events when fails if meetingId present and CA events are not authorized', async () => {
+        checkFailingFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when fails if meetingId not present even if CA events are authorized', async () => {
+        checkFailingFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when fails if meetingId not present and CA events are not authorized', async () => {
+        checkFailingFetchMeetingInfo({shouldSendCAMetrics: false})
       });
 
-      it('should send ca events when in the retry as well if meetingId present', async () => {
+      const checkRetryFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics}) => {
         const reject = {
           statusCode: 403,
           body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
@@ -118,7 +188,7 @@ describe('plugin-meetings', () => {
 
         sinon
           .stub(MeetingInfoUtil, 'generateOptions')
-          .resolves({type: 'MEETING_LINK', destination: '123456'});
+          .resolves({type: 'MEETING_LINK', destination: '123456', url: 'success-url-123'});
         const requestStub = sinon
           .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
           .rejects(reject);
@@ -133,48 +203,97 @@ describe('plugin-meetings', () => {
             null,
             null,
             {
-              meetingId: 'meetingId',
+              meetingId,
+              sendCAevents,
             }
           );
           assert.fail('fetchMeetingInfo should have thrown, but has not done that');
         } catch (err) {
           let submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          let submitClientEventCalls = webex.internal.newMetrics.submitClientlEvent.getCalls();
 
-          assert.deepEqual(submitInternalEventCalls[0].args[0], {
-            name: 'internal.client.meetinginfo.request',
-          });
+          if(shouldSendCAMetrics) {
+            assert.deepEqual(submitInternalEventCalls[0].args[0], {
+              name: 'internal.client.meetinginfo.request',
+            });
 
-          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-            name: 'client.meetinginfo.response',
-            payload: {
-              identifiers: {
-                meetingLookupUrl: 'http://api-url.com',
-              },
-            },
-            options: {
-              meetingId: 'meetingId',
-              rawError: err,
-            },
-          });
+            assert.deepEqual(submitClientEventCalls[0].args[0], {
+              name: 'client.meetinginfo.request',
+            });
 
-          assert.deepEqual(submitInternalEventCalls[1].args[0], {
-            name: 'internal.client.meetinginfo.response',
-          });
+            assert.deepEqual(submitInternalEventCalls[1].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+  
+            assert.deepEqual(submitClientEventCalls[1].args[0], {
+              name: 'client.meetinginfo.response',
+              payload: {
+                identifiers: {
+                  meetingLookupUrl: 'http://api-url.com',
+                },
+              },
+              options: {
+                meetingId: 'meetingId',
+                rawError: err,
+              },
+            });
 
-          assert.deepEqual(submitInternalEventCalls[2].args[0], {
-            name: 'internal.client.meetinginfo.request',
-          });
+            assert.deepEqual(submitInternalEventCalls[2].args[0], {
+              name: 'internal.client.meetinginfo.request',
+            });
+  
+            assert.deepEqual(submitClientEventCalls[2].args[0], {
+              name: 'client.meetinginfo.request',
+              payload: {
+                identifiers: {
+                  meetingLookupUrl: 'success-url-123',
+                },
+              },
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
 
           requestStub.resolves({});
 
           await flushPromises();
 
           submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
 
-          assert.deepEqual(submitInternalEventCalls[3].args[0], {
-            name: 'internal.client.meetinginfo.response',
-          });
+          if(shouldSendInternalCAMetrics) {
+            assert.deepEqual(submitInternalEventCalls[3].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+          }
+
+          if(shouldSendCAMetrics) {
+            assert.deepEqual(submitClientEventCalls[3].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
         }
+      }
+
+      it('should send ca events when in the retry as well if meetingId present and CA events are authorized', async () => {
+        checkRetryFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId not present and CA events are authorized', async () => {
+        checkRetryFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId present and CA events are not authorized', async () => {
+        checkRetryFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId not present and CA events are not authorized', async () => {
+        checkRetryFetchMeetingInfo({shouldSendCAMetrics: false})
       });
     });
   });