@webex/plugin-meetings 3.0.0-beta.254 → 3.0.0-beta.256

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

@@ -13,6 +13,7 @@ import {Credentials, Token, WebexPlugin} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
+import { Defer } from '@webex/common';
 import {
   FLOOR_ACTION,
   SHARE_STATUS,
@@ -96,6 +97,7 @@ import {
 } from '../../../../src/meeting-info/meeting-info-v2';
 import {ANNOTATION_POLICY} from '../../../../src/annotation/constants';
 
+
 // Non-stubbed function
 const {getDisplayMedia} = Media;
 
@@ -818,27 +820,6 @@ describe('plugin-meetings', () => {
             assert.equal(result, joinMeetingResult);
           });
 
-          it('should call updateLLMConnection upon joining if config value is set', async () => {
-            meeting.config.enableAutomaticLLM = true;
-            await meeting.join();
-
-            assert.calledOnce(meeting.updateLLMConnection);
-          });
-
-          it('should not call updateLLMConnection upon joining if config value is not set', async () => {
-            await meeting.join();
-
-            assert.notCalled(meeting.updateLLMConnection);
-          });
-
-          it('should invoke `receiveTranscription()` if receiveTranscription is set to true', async () => {
-            meeting.isTranscriptionSupported = sinon.stub().returns(true);
-            meeting.receiveTranscription = sinon.stub().returns(Promise.resolve());
-
-            await meeting.join({receiveTranscription: true});
-            assert.calledOnce(meeting.receiveTranscription);
-          });
-
           it('should not create new correlation ID on join immediately after create', async () => {
             await meeting.join();
             sinon.assert.notCalled(setCorrelationIdSpy);
@@ -937,6 +918,125 @@ describe('plugin-meetings', () => {
             });
           });
         });
+        describe('lmm and transcription decoupling', () => {
+          beforeEach(() => {
+            sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
+          });
+
+          describe('llm', () => {
+            it('makes sure that join does not wait for update llm connection promise', async () => {
+              const defer = new Defer();
+
+              meeting.config.enableAutomaticLLM = true;
+              meeting.updateLLMConnection = sinon.stub().returns(defer.promise);
+
+              const result = await meeting.join();
+
+              assert.equal(result, joinMeetingResult);
+
+              defer.resolve();
+            });
+
+            it('should call updateLLMConnection as part of joining if config value is set', async () => {
+              meeting.config.enableAutomaticLLM = true;
+              meeting.updateLLMConnection = sinon.stub().resolves();
+
+              await meeting.join();
+
+              assert.calledOnce(meeting.updateLLMConnection);
+            });
+
+            it('should not call updateLLMConnection as part of joining if config value is not set', async () => {
+              meeting.updateLLMConnection = sinon.stub().resolves();
+              await meeting.join();
+
+              assert.notCalled(meeting.updateLLMConnection);
+            });
+
+            it('handles catching error of llm connection later, and join still resolves', async () => {
+              const defer = new Defer();
+
+              meeting.config.enableAutomaticLLM = true;
+              meeting.updateLLMConnection = sinon.stub().returns(defer.promise);
+
+              const result = await meeting.join();
+
+              assert.equal(result, joinMeetingResult);
+
+              defer.reject(new Error("bad day", {cause: 'bad weather'}));
+
+              try {
+                await defer.promise;
+              } catch (err) {
+
+                assert.deepEqual(Metrics.sendBehavioralMetric.getCalls()[0].args, [
+                  BEHAVIORAL_METRICS.JOIN_SUCCESS, {correlation_id: meeting.correlationId}
+                ])
+
+                assert.deepEqual(Metrics.sendBehavioralMetric.getCalls()[1].args, [
+                  BEHAVIORAL_METRICS.LLM_CONNECTION_AFTER_JOIN_FAILURE, {
+                    correlation_id: meeting.correlationId,
+                    reason: err.message,
+                    stack: err.stack,
+                  }
+                ]);
+              }
+            });
+          });
+
+          describe('receive transcription', () => {
+            it('should invoke `receiveTranscription()` if receiveTranscription is set to true', async () => {
+              meeting.isTranscriptionSupported = sinon.stub().returns(true);
+              meeting.receiveTranscription = sinon.stub().returns(Promise.resolve());
+
+              await meeting.join({receiveTranscription: true});
+              assert.calledOnce(meeting.receiveTranscription);
+            });
+
+            it('make sure that join does not wait for setting up receive transcriptions', async () => {
+              const defer = new Defer();
+
+              meeting.isTranscriptionSupported = sinon.stub().returns(true);
+              meeting.receiveTranscription = sinon.stub().returns(defer.promise);
+
+              const result = await meeting.join({receiveTranscription: true});
+
+              assert.equal(result, joinMeetingResult);
+
+              defer.resolve();
+            });
+
+            it('handles catching error of receiveTranscription(), and join still resolves', async () => {
+              const defer = new Defer();
+
+              meeting.isTranscriptionSupported = sinon.stub().returns(true);
+              meeting.receiveTranscription = sinon.stub().returns(defer.promise);
+
+              const result = await meeting.join({receiveTranscription: true});
+
+              assert.equal(result, joinMeetingResult);
+
+              defer.reject(new Error("bad day", {cause: 'bad weather'}));
+
+              try {
+                await defer.promise;
+              } catch (err) {
+                console.log(Metrics.sendBehavioralMetric.getCalls())
+                assert.deepEqual(Metrics.sendBehavioralMetric.getCalls()[0].args, [
+                  BEHAVIORAL_METRICS.JOIN_SUCCESS, {correlation_id: meeting.correlationId}
+                ])
+
+                assert.deepEqual(Metrics.sendBehavioralMetric.getCalls()[1].args, [
+                  BEHAVIORAL_METRICS.RECEIVE_TRANSCRIPTION_AFTER_JOIN_FAILURE, {
+                    correlation_id: meeting.correlationId,
+                    reason: err.message,
+                    stack: err.stack,
+                  }
+                ]);
+              }
+            })
+          })
+        })
       });
 
       describe('#addMedia', () => {
@@ -3484,6 +3584,219 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#refreshPermissionToken', () => {
+        const FAKE_MEETING_INFO = {
+          conversationUrl: 'some_convo_url',
+          locusUrl: 'some_locus_url',
+          sipUrl: 'some_sip_url',
+          meetingNumber: '123456',
+          hostId: 'some_host_id',
+        };
+        const FAKE_MEETING_INFO_LOOKUP_URL = 'meetingLookupUrl';
+        const FAKE_PERMISSION_TOKEN = {someField: 'some value'};
+        const FAKE_TTL = 13;
+
+        beforeEach(() => {
+          meeting.locusId = 'locus-id';
+          meeting.id = 'meeting-id';
+          meeting.config.installedOrgID = 'fake-installed-org-id';
+          meeting.meetingInfo.permissionToken = FAKE_PERMISSION_TOKEN;
+          meeting.destination = 'meeting-destination';
+          meeting.destinationType = 'meeting-destination-type';
+          meeting.updateMeetingActions = sinon.stub().returns(undefined);
+          meeting.getPermissionTokenTimeLeftInSec = sinon.stub().returns(FAKE_TTL);
+          meeting.meetingInfoExtraParams = {
+            extraParam1: 'value1'
+          };
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .resolves({body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}),
+          };
+        });
+
+        it('resolves without doing anything if there is no permission token', async () => {
+          meeting.meetingInfo.permissionToken = undefined;
+
+          await meeting.refreshPermissionToken();
+
+          assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+          assert.notCalled(Metrics.sendBehavioralMetric);
+        });
+
+        it('calls meetingInfoProvider.fetchMeetingInfo() with the right params', async () => {
+          await meeting.refreshPermissionToken('fake reason');
+
+          assert.calledOnceWithExactly(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            'meeting-destination',
+            'meeting-destination-type',
+            null,
+            null,
+            'fake-installed-org-id',
+            'locus-id',
+            {extraParam1: 'value1', permissionToken: FAKE_PERMISSION_TOKEN},
+            {meetingId: meeting.id, sendCAevents: true}
+          );
+          assert.deepEqual(meeting.meetingInfo, {
+            ...FAKE_MEETING_INFO,
+            meetingLookupUrl: FAKE_MEETING_INFO_LOOKUP_URL
+          });
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meetings', function: 'fetchMeetingInfo'},
+            'meeting:meetingInfoAvailable'
+          );
+          assert.calledWith(meeting.updateMeetingActions);
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH, {
+              correlationId: meeting.correlationId,
+              timeLeft: FAKE_TTL,
+              reason: 'fake reason',
+              destinationType: 'meeting-destination-type',
+            }
+          );
+        });
+
+        it('calls meetingInfoProvider.fetchMeetingInfo() with the right params when we are starting an instant space meeting', async () => {
+          meeting.destination = 'some-convo-url';
+          meeting.destinationType = 'CONVERSATION_URL';
+          meeting.config.experimental = {enableAdhocMeetings: true};
+          meeting.meetingInfo.meetingJoinUrl = 'meeting-join-url';
+          meeting.webex.meetings.preferredWebexSite = 'preferredWebexSite';
+
+          await meeting.refreshPermissionToken('some reason');
+
+          assert.calledOnceWithExactly(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            'meeting-join-url',
+            'MEETING_LINK',
+            null,
+            null,
+            'fake-installed-org-id',
+            'locus-id',
+            {
+              extraParam1: 'value1',
+              permissionToken: FAKE_PERMISSION_TOKEN
+            },
+            {meetingId: meeting.id, sendCAevents: true}
+          );
+          assert.deepEqual(meeting.meetingInfo, {
+            ...FAKE_MEETING_INFO,
+            meetingLookupUrl: FAKE_MEETING_INFO_LOOKUP_URL
+          });
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meetings', function: 'fetchMeetingInfo'},
+            'meeting:meetingInfoAvailable'
+          );
+          assert.calledWith(meeting.updateMeetingActions);
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH, {
+              correlationId: meeting.correlationId,
+              timeLeft: FAKE_TTL,
+              reason: 'some reason',
+              destinationType: 'MEETING_LINK',
+            }
+          );
+        });
+
+        it('throws PermissionError if policy error is encountered', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2PolicyError(123456, FAKE_MEETING_INFO, 'a message')),
+          };
+
+          await assert.isRejected(meeting.refreshPermissionToken());
+
+          assert.calledOnce(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+          assert.deepEqual(meeting.meetingInfo, {
+            ...FAKE_MEETING_INFO,
+          });
+          assert.equal(meeting.meetingInfoFailureCode, 123456);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.POLICY);
+          assert.calledWith(meeting.updateMeetingActions);
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH_ERROR, {
+              correlationId: meeting.correlationId,
+              reason: 'Not allowed to execute the function, some properties on server, or local client state do not allow you to complete this action.',
+              stack: sinon.match.any,
+            }
+          );
+        });
+
+        it('throws PasswordError if password is required', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO)),
+          };
+
+          await assert.isRejected(meeting.refreshPermissionToken());
+
+          assert.calledOnce(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+          assert.deepEqual(meeting.meetingInfo, {
+            ...FAKE_MEETING_INFO,
+          });
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.calledWith(meeting.updateMeetingActions);
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH_ERROR, {
+              correlationId: meeting.correlationId,
+              reason: 'Password is required, please use verifyPassword()',
+              stack: sinon.match.any,
+            }
+          );
+        });
+
+        it('throws CaptchaError if captcha is required', async () => {
+          const FAKE_SDK_CAPTCHA_INFO = {
+            captchaId: 'FAKE_CAPTCHA_ID',
+            verificationImageURL: 'FAKE_CAPTCHA_IMAGE_URL',
+            verificationAudioURL: 'FAKE_CAPTCHA_AUDIO_URL',
+            refreshURL: 'FAKE_CAPTCHA_REFRESH_URL',
+          };
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO)),
+          };
+
+          await assert.isRejected(meeting.refreshPermissionToken());
+
+          assert.calledOnce(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.calledWith(meeting.updateMeetingActions);
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.PERMISSION_TOKEN_REFRESH_ERROR, {
+              correlationId: meeting.correlationId,
+              reason: 'Captcha is required.',
+              stack: sinon.match.any,
+            }
+          );
+        });
+      });
+
       describe('#refreshCaptcha', () => {
         it('fails if no captcha required', async () => {
           assert.isRejected(meeting.refreshCaptcha(), Error);
@@ -5506,9 +5819,9 @@ describe('plugin-meetings', () => {
           assert.notOk(meeting.permissionTokenPayload);
 
           const permissionTokenPayloadData = {permission: {userPolicies: {a: true}}, exp: '1234'};
-          
+
           const jwtDecodeStub = sinon.stub(jwt, 'decode').returns(permissionTokenPayloadData);
-          
+
           meeting.setPermissionTokenPayload();
 
           assert.calledOnce(jwtDecodeStub);
@@ -5605,7 +5918,7 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.owner, expectedInfoToParse.owner);
           assert.equal(meeting.permissionToken, expectedInfoToParse.permissionToken);
           assert.deepEqual(meeting.selfUserPolicies, expectedInfoToParse.selfUserPolicies);
-          
+
           if(expectedInfoToParse.permissionTokenPayload) {
             assert.deepEqual(meeting.permissionTokenPayload, expectedInfoToParse.permissionTokenPayload);
           }
@@ -5624,9 +5937,9 @@ describe('plugin-meetings', () => {
             }
           };
 
-          // generated permissionToken with secret `secret` and 
+          // generated permissionToken with secret `secret` and
           // value `JSON.stringify(expectedPermissionTokenPayload)`
-          const permissionToken = 
+          const permissionToken =
             'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0';
 
           const FAKE_MEETING_INFO = {
@@ -7976,20 +8289,20 @@ describe('plugin-meetings', () => {
     });
 
     afterEach(() => {
-      clock.restore();  
+      clock.restore();
     })
 
-    it('should return undefined if exp is undefined', () => { 
+    it('should return undefined if exp is undefined', () => {
       assert.equal(meeting.getPermissionTokenTimeLeftInSec(), undefined)
     });
 
-    it('should return the expected positive exp', () => { 
+    it('should return the expected positive exp', () => {
       // set permission token as now + 1 sec
       meeting.permissionTokenPayload = {exp: (now + 1000).toString()};
       assert.equal(meeting.getPermissionTokenTimeLeftInSec(), 1);
     });
 
-    it('should return the expected negative exp', () => { 
+    it('should return the expected negative exp', () => {
       // set permission token as now - 1 sec
       meeting.permissionTokenPayload = {exp: (now - 1000).toString()};
       assert.equal(meeting.getPermissionTokenTimeLeftInSec(), -1);