@webex/plugin-meetings 3.0.0-test.1 → 3.1.0

package/test/unit/spec/meeting/request.js

@@ -194,12 +194,14 @@ describe('plugin-meetings', () => {
         const roapMessage = 'roap-message';
         const permissionToken = 'permission-token';
         const installationId = 'installationId';
+        const reachability = 'reachability';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
           deviceUrl,
           correlationId,
           roapMessage,
+          reachability,
           permissionToken,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
@@ -212,6 +214,9 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
         assert.include(requestParams.body.device.localIp, '127.0.0');
+        assert.deepEqual(requestParams.body.localMedias, [
+          {localSdp: '{"roapMessage":"roap-message","reachability":"reachability"}'},
+        ]);
 
         assert.calledOnceWithExactly(anonymizeIpSpy, '127.0.0.1');
       });
@@ -365,6 +370,22 @@ describe('plugin-meetings', () => {
         assert.deepEqual(requestParams.body.locale, undefined);
       });
 
+      it('adds alias to request when they are provided', async () => {
+        await meetingsRequest.joinMeeting({
+          alias: 'assigned name',
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.alias, 'assigned name');
+      });
+
+      it('does not add alias to request when they are not provided', async () => {
+        await meetingsRequest.joinMeeting({});
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.alias, undefined);
+      });
+
       it('includes joinCookie and ipver correctly', async () => {
         const locusUrl = 'locusURL';
         const deviceUrl = 'deviceUrl';

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

@@ -57,7 +57,8 @@ describe('plugin-meetings', () => {
     });
 
     describe('#cleanup', () => {
-      it('do clean up on meeting object', async () => {
+      it('do clean up on meeting object with LLM enabled', async () => {
+        meeting.config = {enableAutomaticLLM : true};
         await MeetingUtil.cleanUp(meeting);
         assert.calledOnce(meeting.cleanupLocalStreams);
         assert.calledOnce(meeting.closeRemoteStreams);
@@ -71,6 +72,37 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
       });
+
+      it('do clean up on meeting object with LLM disabled', async () => {
+        meeting.config = {enableAutomaticLLM : false};
+        await MeetingUtil.cleanUp(meeting);
+        assert.calledOnce(meeting.cleanupLocalStreams);
+        assert.calledOnce(meeting.closeRemoteStreams);
+        assert.calledOnce(meeting.closePeerConnections);
+
+        assert.calledOnce(meeting.unsetRemoteStreams);
+        assert.calledOnce(meeting.unsetPeerConnections);
+        assert.calledOnce(meeting.reconnectionManager.cleanUp);
+        assert.calledOnce(meeting.stopKeepAlive);
+        assert.notCalled(meeting.updateLLMConnection);
+        assert.calledOnce(meeting.breakouts.cleanUp);
+        assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
+      });
+
+      it('do clean up on meeting object with no config', async () => {
+        await MeetingUtil.cleanUp(meeting);
+        assert.calledOnce(meeting.cleanupLocalStreams);
+        assert.calledOnce(meeting.closeRemoteStreams);
+        assert.calledOnce(meeting.closePeerConnections);
+
+        assert.calledOnce(meeting.unsetRemoteStreams);
+        assert.calledOnce(meeting.unsetPeerConnections);
+        assert.calledOnce(meeting.reconnectionManager.cleanUp);
+        assert.calledOnce(meeting.stopKeepAlive);
+        assert.notCalled(meeting.updateLLMConnection);
+        assert.calledOnce(meeting.breakouts.cleanUp);
+        assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
+      });
     });
 
     describe('logging', () => {
@@ -369,14 +401,19 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
-        await MeetingUtil.joinMeeting(meeting, {});
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
+        await MeetingUtil.joinMeeting(meeting, {
+          reachability: 'reachability',
+          roapMessage: 'roapMessage',
+        });
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
         assert.equal(parameter.preferTranscoding, true);
+        assert.equal(parameter.reachability, 'reachability');
+        assert.equal(parameter.roapMessage, 'roapMessage');
 
         assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
           name: 'client.locus.join.request',
@@ -396,6 +433,7 @@ describe('plugin-meetings', () => {
             mediaConnections: 'mediaConnections',
           },
         });
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
@@ -406,7 +444,7 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           breakoutsSupported: true,
         });
@@ -415,6 +453,7 @@ describe('plugin-meetings', () => {
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.breakoutsSupported, true);
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with liveAnnotationSupported=true when passed in as true', async () => {
@@ -425,7 +464,7 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           liveAnnotationSupported: true,
         });
@@ -434,6 +473,7 @@ describe('plugin-meetings', () => {
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.liveAnnotationSupported, true);
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with locale=en_UK, deviceCapabilities=["TEST"] when they are passed in as those values', async () => {
@@ -444,7 +484,7 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           locale: 'en_UK',
           deviceCapabilities: ['TEST'],
@@ -455,6 +495,7 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.locale, 'en_UK');
         assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
@@ -468,7 +509,7 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
@@ -476,6 +517,7 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
         assert.equal(parameter.preferTranscoding, false);
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
@@ -488,13 +530,14 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'sipUri');
+        parseLocusJoinSpy.restore();
       });
 
       it('#Should fallback to meetingNumber if meetingJoinUrl/sipUrl  does not exists', async () => {
@@ -507,7 +550,7 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
@@ -515,6 +558,7 @@ describe('plugin-meetings', () => {
 
         assert.isUndefined(parameter.inviteeAddress);
         assert.equal(parameter.meetingNumber, 'meetingNumber');
+        parseLocusJoinSpy.restore();
       });
 
       it('should pass in the locusClusterUrl from meetingInfo', async () => {
@@ -528,19 +572,20 @@ describe('plugin-meetings', () => {
           getWebexObject: sinon.stub().returns(webex),
         };
 
-        MeetingUtil.parseLocusJoin = sinon.stub();
+        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
+        parseLocusJoinSpy.restore();
       });
     });
 
     describe('joinMeetingOptions', () => {
       it('sends client events correctly', async () => {
-        MeetingUtil.joinMeeting = sinon.stub().rejects({});
+        const joinMeetingSpy = sinon.stub(MeetingUtil, 'joinMeeting').rejects({});
         MeetingUtil.isPinOrGuest = sinon.stub().returns(true);
         const meeting = {
           id: 'meeting-id',
@@ -571,6 +616,8 @@ describe('plugin-meetings', () => {
               meetingId: meeting.id,
             },
           });
+        } finally {
+          joinMeetingSpy.restore();
         }
       });
     });

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/meetinginfov2.js

@@ -795,13 +795,17 @@ describe('plugin-meetings', () => {
       it('Make a request to /spaceInstant when conversationUrl', async () => {
         const {invitee} = setup();
 
-        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
+        webex.request.resolves({
+          statusCode: 200,
+          body: conversation
+        });
+
+        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl,installedOrgID);
 
         assert.calledWith(
-          webex.internal.conversation.get,
-          {url: conversationUrl},
-          {includeParticipants: true, disableTransform: true}
-        );
+          webex.request,
+          {uri:conversationUrl, qs: {includeParticipants: true}, disableTransform: true}
+        )
 
         assert.calledWith(webex.request, {
           method: 'POST',
@@ -812,27 +816,28 @@ describe('plugin-meetings', () => {
             keyUrl: conversation.encryptionKeyUrl,
             kroUrl: conversation.kmsResourceObjectUrl,
             invitees: invitee,
+            installedOrgID: installedOrgID
           },
         });
-        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledOnce(Metrics.sendBehavioralMetric);
         assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
         assert.deepEqual(result, {
-          body: {},
+          body: conversation,
           statusCode: 200
         });
       });
-
       it('Make a request to /spaceInstant when conversationUrl with installed org ID', async () => {
         const {invitee} = setup();
-
+        webex.request = sinon.stub().resolves({
+          body: conversation,
+        });
         await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
 
-        assert.calledWith(
-          webex.internal.conversation.get,
-          {url: conversationUrl},
-          {includeParticipants: true, disableTransform: true}
-        );
-
+        assert.calledWith(webex.request, {
+          uri: conversationUrl,
+          qs: {includeParticipants: true},
+          disableTransform: true,
+        });
         assert.calledWith(webex.request, {
           method: 'POST',
           uri: 'https://go.webex.com/wbxappapi/v2/meetings/spaceInstant',

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

@@ -252,6 +252,12 @@ describe('plugin-meetings', () => {
       it('SIP meeting address from excepted domain', () => {
         assert.equal(MeetingInfoUtil.getWebexSite('10019857020@meet.webex.com'), null);
       });
+      it('SIP meeting address from excepted domain for IC', () => {
+        assert.equal(MeetingInfoUtil.getWebexSite('10019857020@meet-intb.ciscospark.com'), null);
+      });
+      it('SIP meeting address from webex domain', () => {
+        assert.equal(MeetingInfoUtil.getWebexSite('10019857020@webex.com'), null);
+      });
       it('invalid domain', () => {
         assert.equal(MeetingInfoUtil.getWebexSite('invaliddomain'), null);
       });