@webex/plugin-meetings 3.8.1-next.42 → 3.8.1-next.44

package/src/meeting/util.ts

@@ -197,6 +197,17 @@ const MeetingUtil = {
         });
 
         return parsed;
+      })
+      .catch((err) => {
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.join.response',
+          payload: {
+            identifiers: {meetingLookupUrl: meeting.meetingInfo?.meetingLookupUrl},
+          },
+          options: {meetingId: meeting.id, rawError: err},
+        });
+
+        throw err;
       });
   },
 
@@ -332,10 +343,57 @@ const MeetingUtil = {
     meeting.resourceId = meeting.resourceId || options.resourceId;
 
     if (meeting.requiredCaptcha) {
-      return Promise.reject(new CaptchaError());
+      const errorToThrow = new CaptchaError();
+
+      // @ts-ignore
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.response',
+        options: {
+          meetingId: meeting.id,
+        },
+        payload: {
+          errors: [
+            {
+              fatal: false,
+              category: 'expected',
+              name: 'other',
+              shownToUser: false,
+              errorCode: errorToThrow.code,
+              errorDescription: errorToThrow.name,
+              rawErrorMessage: errorToThrow.sdkMessage,
+            },
+          ],
+        },
+      });
+
+      return Promise.reject(errorToThrow);
     }
+
     if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
-      return Promise.reject(new PasswordError());
+      const errorToThrow = new PasswordError();
+
+      // @ts-ignore
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.response',
+        options: {
+          meetingId: meeting.id,
+        },
+        payload: {
+          errors: [
+            {
+              fatal: false,
+              category: 'expected',
+              name: 'other',
+              shownToUser: false,
+              errorCode: errorToThrow.code,
+              errorDescription: errorToThrow.name,
+              rawErrorMessage: errorToThrow.sdkMessage,
+            },
+          ],
+        },
+      });
+
+      return Promise.reject(errorToThrow);
     }
 
     if (options.pin) {

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

@@ -485,6 +485,18 @@ describe('plugin-meetings', () => {
           });
         });
 
+        it('pstnCorrelationId getter/setter should work correctly', () => {
+          const testPstnCorrelationId = uuid.v4();
+          
+          meeting.pstnCorrelationId = testPstnCorrelationId;
+          assert.equal(meeting.pstnCorrelationId, testPstnCorrelationId);
+          assert.equal(meeting.callStateForMetrics.pstnCorrelationId, testPstnCorrelationId);
+
+          meeting.pstnCorrelationId = undefined;
+          assert.equal(meeting.pstnCorrelationId, undefined);
+          assert.equal(meeting.callStateForMetrics.pstnCorrelationId, undefined);
+        });
+
         describe('creates ReceiveSlot manager instance', () => {
           let mockReceiveSlotManagerCtor;
           let providedCreateSlotCallback;
@@ -1977,21 +1989,25 @@ describe('plugin-meetings', () => {
             });
           });
 
-          it('should post error event if failed', async () => {
+          it('should handle join failure', async () => {
             MeetingUtil.isPinOrGuest = sinon.stub().returns(false);
+            webex.internal.newMetrics.submitClientEvent = sinon.stub();
+            
             await meeting.join().catch(() => {
-              assert.deepEqual(
-                webex.internal.newMetrics.submitClientEvent.getCall(1).args[0].name,
-                'client.locus.join.response'
-              );
-              assert.match(
-                webex.internal.newMetrics.submitClientEvent.getCall(1).args[0].options.rawError,
+              assert.calledOnce(MeetingUtil.joinMeeting);
+              
+              // Assert that client.locus.join.response error event is not sent from this function, it is now emitted from MeetingUtil.joinMeeting
+              assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
+              assert.calledWithMatch(
+                webex.internal.newMetrics.submitClientEvent,
                 {
-                  code: 2,
-                  error: null,
-                  joinOptions: {},
-                  sdkMessage:
-                    'There was an issue joining the meeting, meeting could be in a bad state.',
+                  name: 'client.call.initiated',
+                  payload: {
+                    trigger: 'user-interaction',
+                    isRoapCallEnabled: true,
+                    pstnAudioType: undefined
+                  },
+                  options: {meetingId: meeting.id},
                 }
               );
             });
@@ -6526,12 +6542,17 @@ describe('plugin-meetings', () => {
           const DIAL_IN_URL = meeting.dialInUrl;
 
           assert.calledWith(meeting.meetingRequest.dialIn, {
-            correlationId: meeting.correlationId,
+            correlationId: meeting.pstnCorrelationId,
             dialInUrl: DIAL_IN_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
           });
           assert.notCalled(meeting.meetingRequest.dialOut);
+          
+          // Verify pstnCorrelationId was set
+          assert.exists(meeting.pstnCorrelationId);
+          assert.notEqual(meeting.pstnCorrelationId, meeting.correlationId);
+          const firstPstnCorrelationId = meeting.pstnCorrelationId
 
           meeting.meetingRequest.dialIn.resetHistory();
 
@@ -6539,12 +6560,18 @@ describe('plugin-meetings', () => {
           await meeting.usePhoneAudio();
 
           assert.calledWith(meeting.meetingRequest.dialIn, {
-            correlationId: meeting.correlationId,
+            correlationId: meeting.pstnCorrelationId,
             dialInUrl: DIAL_IN_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
           });
           assert.notCalled(meeting.meetingRequest.dialOut);
+          // A new PSTN correlationId should be generated for the second attempt
+          assert.notEqual(
+            meeting.pstnCorrelationId,
+            firstPstnCorrelationId,
+            'pstnCorrelationId should be regenerated on each dial-in attempt'
+          );
         });
 
         it('given a phone number, triggers dial-out, delegating request to meetingRequest correctly', async () => {
@@ -6554,7 +6581,7 @@ describe('plugin-meetings', () => {
           const DIAL_OUT_URL = meeting.dialOutUrl;
 
           assert.calledWith(meeting.meetingRequest.dialOut, {
-            correlationId: meeting.correlationId,
+            correlationId: meeting.pstnCorrelationId,
             dialOutUrl: DIAL_OUT_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
@@ -6562,49 +6589,126 @@ describe('plugin-meetings', () => {
           });
           assert.notCalled(meeting.meetingRequest.dialIn);
 
+          // Verify pstnCorrelationId was set
+          assert.exists(meeting.pstnCorrelationId);
+          assert.notEqual(meeting.pstnCorrelationId, meeting.correlationId);
+          const firstPstnCorrelationId = meeting.pstnCorrelationId;
+
           meeting.meetingRequest.dialOut.resetHistory();
 
           // try again. the dial out urls should match
           await meeting.usePhoneAudio(phoneNumber);
 
           assert.calledWith(meeting.meetingRequest.dialOut, {
-            correlationId: meeting.correlationId,
+            correlationId: meeting.pstnCorrelationId,
             dialOutUrl: DIAL_OUT_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
             phoneNumber,
           });
           assert.notCalled(meeting.meetingRequest.dialIn);
+          // A new PSTN correlationId should be generated for the second attempt
+          assert.notEqual(
+            meeting.pstnCorrelationId,
+            firstPstnCorrelationId,
+            'pstnCorrelationId should be regenerated on each dial-out attempt'
+          );
         });
 
-        it('rejects if the request failed (dial in)', () => {
-          const error = 'something bad happened';
+        it('rejects if the request failed (dial in)', async () => {
+          const error = {error: {message: 'dial in failed'}, stack: 'error stack'};
 
           meeting.meetingRequest.dialIn = sinon.stub().returns(Promise.reject(error));
 
-          return meeting
-            .usePhoneAudio()
-            .then(() => Promise.reject(new Error('Promise resolved when it should have rejected')))
-            .catch((e) => {
-              assert.equal(e, error);
-
-              return Promise.resolve();
+          try {
+            await meeting.usePhoneAudio();
+            throw new Error('Promise resolved when it should have rejected');
+          } catch (e) {
+            assert.equal(e, error);
+            
+            // Verify behavioral metric was sent with dial_in_correlation_id
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_DIAL_IN_FAILURE, {
+              correlation_id: meeting.correlationId,
+              dial_in_url: meeting.dialInUrl,
+              dial_in_correlation_id: sinon.match.string,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              client_url: meeting.deviceUrl,
+              reason: error.error.message,
+              stack: error.stack,
             });
+            
+            // Verify pstnCorrelationId was cleared after error
+            assert.equal(meeting.pstnCorrelationId, undefined);
+          }
         });
 
         it('rejects if the request failed (dial out)', async () => {
-          const error = 'something bad happened';
+          const error = {error: {message: 'dial out failed'}, stack: 'error stack'};
 
           meeting.meetingRequest.dialOut = sinon.stub().returns(Promise.reject(error));
 
-          return meeting
-            .usePhoneAudio('+441234567890')
-            .then(() => Promise.reject(new Error('Promise resolved when it should have rejected')))
-            .catch((e) => {
-              assert.equal(e, error);
-
-              return Promise.resolve();
+          try {
+            await meeting.usePhoneAudio('+441234567890');
+            throw new Error('Promise resolved when it should have rejected');
+          } catch (e) {
+            assert.equal(e, error);
+            
+            // Verify behavioral metric was sent with dial_out_correlation_id
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_DIAL_OUT_FAILURE, {
+              correlation_id: meeting.correlationId,
+              dial_out_url: meeting.dialOutUrl,
+              dial_out_correlation_id: sinon.match.string,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              client_url: meeting.deviceUrl,
+              reason: error.error.message,
+              stack: error.stack,
             });
+            
+            // Verify pstnCorrelationId was cleared after error
+            assert.equal(meeting.pstnCorrelationId, undefined);
+          }
+        });
+      });
+
+      describe('#disconnectPhoneAudio', () => {
+        beforeEach(() => {
+          // Mock the MeetingUtil.disconnectPhoneAudio method
+          sinon.stub(MeetingUtil, 'disconnectPhoneAudio').resolves();
+          meeting.dialInUrl = 'dialin:///test-dial-in-url';
+          meeting.dialOutUrl = 'dialout:///test-dial-out-url';
+          meeting.dialInDeviceStatus = 'JOINED';
+          meeting.dialOutDeviceStatus = 'JOINED';
+        });
+
+        afterEach(() => {
+          MeetingUtil.disconnectPhoneAudio.restore();
+        });
+
+        it('should disconnect phone audio and clear pstnCorrelationId', async () => {
+          meeting.pstnCorrelationId = 'test-pstn-correlation-id';
+          
+          await meeting.disconnectPhoneAudio();
+          
+          // Verify that pstnCorrelationId is cleared
+          assert.equal(meeting.pstnCorrelationId, undefined);
+          
+          // Verify that MeetingUtil.disconnectPhoneAudio was called for both dial-in and dial-out
+          assert.calledTwice(MeetingUtil.disconnectPhoneAudio);
+          assert.calledWith(MeetingUtil.disconnectPhoneAudio, meeting, meeting.dialInUrl);
+          assert.calledWith(MeetingUtil.disconnectPhoneAudio, meeting, meeting.dialOutUrl);
+        });
+
+        it('should handle case when no PSTN connection is active', async () => {
+          meeting.dialInDeviceStatus = 'IDLE';
+          meeting.dialOutDeviceStatus = 'IDLE';
+          meeting.pstnCorrelationId = 'test-pstn-correlation-id';
+          
+          await meeting.disconnectPhoneAudio();
+          
+          // Verify that pstnCorrelationId is still cleared even when no phone connection is active
+          assert.equal(meeting.pstnCorrelationId, undefined);
+           // And verify no disconnect was attempted
+          assert.notCalled(MeetingUtil.disconnectPhoneAudio);
         });
       });
 

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

@@ -3,12 +3,14 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
-import {LOCAL_SHARE_ERRORS} from '@webex/plugin-meetings/src/constants';
+import {LOCAL_SHARE_ERRORS, PASSWORD_STATUS} from '@webex/plugin-meetings/src/constants';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import MockWebex from '@webex/test-helper-mock-webex';
 import * as BrowserDetectionModule from '@webex/plugin-meetings/src/common/browser-detection';
+import PasswordError from '@webex/plugin-meetings/src/common/errors/password-error';
+import CaptchaError from '@webex/plugin-meetings/src/common/errors/captcha-error';
 
 describe('plugin-meetings', () => {
   let webex;
@@ -638,6 +640,28 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
       });
+
+      it('should post client event with error when join fails', async () => {
+        const joinError = new Error('Join failed');
+        meeting.meetingRequest.joinMeeting.rejects(joinError);
+        meeting.meetingInfo = { meetingLookupUrl: 'test-lookup-url' };
+
+        try {
+          await MeetingUtil.joinMeeting(meeting, {});
+          assert.fail('Expected joinMeeting to throw an error');
+        } catch (error) {
+          assert.equal(error, joinError);
+          
+          // Verify error client event was submitted
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.locus.join.response',
+            payload: {
+              identifiers: { meetingLookupUrl: 'test-lookup-url' },
+            },
+            options: { meetingId: meeting.id, rawError: joinError },
+          });
+        }
+      });
     });
 
     describe('joinMeetingOptions', () => {
@@ -677,6 +701,82 @@ describe('plugin-meetings', () => {
           joinMeetingSpy.restore();
         }
       });
+
+      it('should submit client event and reject with PasswordError when password is required', async () => {
+        const meeting = {
+          id: 'meeting-id',
+          passwordStatus: PASSWORD_STATUS.REQUIRED,
+          resourceId: null,
+          requiredCaptcha: null,
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        try {
+          await MeetingUtil.joinMeetingOptions(meeting, {});
+          assert.fail('Expected joinMeetingOptions to throw PasswordError');
+        } catch (error) {
+          assert.instanceOf(error, PasswordError);
+          
+          // Verify client event was submitted with error details
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            options: {
+              meetingId: meeting.id,
+            },
+            payload: {
+              errors: [
+                {
+                  fatal: false,
+                  category: 'expected',
+                  name: 'other',
+                  shownToUser: false,
+                  errorCode: error.code,
+                  errorDescription: error.name,
+                  rawErrorMessage: error.sdkMessage,
+                },
+              ],
+            },
+          });
+        }
+      });
+
+      it('should submit client event and reject with CaptchaError when captcha is required', async () => {
+        const meeting = {
+          id: 'meeting-id',
+          passwordStatus: null,
+          resourceId: null,
+          requiredCaptcha: {captchaId: 'test-captcha'},
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        try {
+          await MeetingUtil.joinMeetingOptions(meeting, {});
+          assert.fail('Expected joinMeetingOptions to throw CaptchaError');
+        } catch (error) {
+          assert.instanceOf(error, CaptchaError);
+          
+          // Verify client event was submitted with error details
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            options: {
+              meetingId: meeting.id,
+            },
+            payload: {
+              errors: [
+                {
+                  fatal: false,
+                  category: 'expected',
+                  name: 'other',
+                  shownToUser: false,
+                  errorCode: error.code,
+                  errorDescription: error.name,
+                  rawErrorMessage: error.sdkMessage,
+                },
+              ],
+            },
+          });
+        }
+      });
     });
 
     describe('getUserDisplayHintsFromLocusInfo', () => {