@webex/plugin-meetings 1.151.7 → 1.152.0

package/src/meeting-info/meeting-info-v2.js

@@ -3,6 +3,52 @@ import {HTTP_VERBS} from '../constants';
 
 import MeetingInfoUtil from './utilv2';
 
+const PASSWORD_ERROR_DEFAULT_MESSAGE = 'Password required. Call fetchMeetingInfo() with password argument';
+const CAPTCHA_ERROR_DEFAULT_MESSAGE = 'Captcha required. Call fetchMeetingInfo() with captchaInfo argument';
+
+/**
+ * Error to indicate that wbxappapi requires a password
+ */
+export class MeetingInfoV2PasswordError extends Error {
+  /**
+    *
+    * @constructor
+    * @param {Number} [wbxAppApiErrorCode]
+    * @param {Object} [meetingInfo]
+    * @param {String} [message]
+    */
+  constructor(wbxAppApiErrorCode, meetingInfo, message = PASSWORD_ERROR_DEFAULT_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = (new Error()).stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.meetingInfo = meetingInfo;
+  }
+}
+
+/**
+   * Error to indicate that wbxappapi requires a captcha
+   */
+export class MeetingInfoV2CaptchaError extends Error {
+  /**
+    *
+    * @constructor
+    * @param {Number} [wbxAppApiErrorCode]
+    * @param {Object} [captchaInfo]
+    * @param {String} [message]
+    */
+  constructor(wbxAppApiErrorCode, captchaInfo, message = CAPTCHA_ERROR_DEFAULT_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = (new Error()).stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.isPasswordRequired = wbxAppApiErrorCode === 423005;
+    this.captchaInfo = captchaInfo;
+  }
+}
+
 /**
    * @class MeetingInfo
    */
@@ -35,24 +81,42 @@ export default class MeetingInfoV2 {
      * Fetches meeting info from the server
      * @param {String} destination one of many different types of destinations to look up info for
      * @param {String} [type] to match up with the destination value
+     * @param {String} password
+     * @param {Object} captchaInfo
+     * @param {String} captchaInfo.code
+     * @param {String} captchaInfo.id
      * @returns {Promise} returns a meeting info object
      * @public
      * @memberof MeetingInfo
      */
-  async fetchMeetingInfo(destination, type = null) {
+  async fetchMeetingInfo(destination, type = null, password = null, captchaInfo = null) {
     const destinationType = await MeetingInfoUtil.getDestinationType({
       destination,
       type,
       webex: this.webex
     });
-    const body = await MeetingInfoUtil.getRequestBody(destinationType);
+    const body = await MeetingInfoUtil.getRequestBody({...destinationType, password, captchaInfo});
 
     return this.webex.request({
       method: HTTP_VERBS.POST,
       service: 'webex-appapi-service',
       resource: 'meetingInfo',
       body
-    });
+    })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          throw new MeetingInfoV2PasswordError(err.body?.code, err.body?.data?.meetingInfo);
+        }
+        if (err?.statusCode === 423) {
+          throw new MeetingInfoV2CaptchaError(err.body?.code, {
+            captchaId: err.body.captchaID,
+            verificationImageURL: err.body.verificationImageURL,
+            verificationAudioURL: err.body.verificationAudioURL,
+            refreshURL: err.body.refreshURL
+          });
+        }
+        throw err;
+      });
   }
 }
 

package/src/meeting-info/utilv2.js

@@ -212,7 +212,9 @@ MeetingInfoUtil.getDestinationType = async (from) => {
  * @returns {Object} returns an object with {resource, method}
  */
 MeetingInfoUtil.getRequestBody = (options) => {
-  const {type, destination} = options;
+  const {
+    type, destination, password, captchaInfo
+  } = options;
   const body = {
     supportHostKey: true
   };
@@ -250,6 +252,15 @@ MeetingInfoUtil.getRequestBody = (options) => {
     default:
   }
 
+  if (password) {
+    body.password = password;
+  }
+
+  if (captchaInfo) {
+    body.captchaID = captchaInfo.id;
+    body.captchaVerifyCode = captchaInfo.code;
+  }
+
   return body;
 };
 

package/src/meetings/index.js

@@ -48,6 +48,8 @@ import Reachability from '../reachability';
 import Request from '../meetings/request';
 import StatsAnalyzer from '../analyzer/analyzer';
 import StatsCalculator from '../analyzer/calculator';
+import PasswordError from '../common/errors/password-error';
+import CaptchaError from '../common/errors/captcha-error';
 
 import MeetingCollection from './collection';
 import MeetingsUtil from './util';
@@ -716,7 +718,8 @@ export default class Meetings extends WebexPlugin {
           deviceUrl: this.webex.internal.device.url,
           orgId: this.webex.internal.device.orgId,
           roapSeq: 0,
-          locus: type === _LOCUS_ID_ ? destination : null // pass the locus object if present
+          locus: type === _LOCUS_ID_ ? destination : null, // pass the locus object if present
+          meetingInfoProvider: this.meetingInfo
         },
         {
           parent: this.webex
@@ -726,15 +729,14 @@ export default class Meetings extends WebexPlugin {
       this.meetingCollection.set(meeting);
 
       try {
-        const info = await this.meetingInfo.fetchMeetingInfo(destination, type);
-
-        meeting.parseMeetingInfo(info);
-        meeting.meetingInfo = info ? info.body : null;
+        await meeting.fetchMeetingInfo({destination, type});
       }
       catch (err) {
-        // if there is no meeting info we assume its a 1:1 call or wireless share
-        LoggerProxy.logger.info(`Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`);
-        LoggerProxy.logger.info('Meetings:index#createMeeting --> Info assuming this destination is a 1:1 or wireless share');
+        if (!(err instanceof CaptchaError) && !(err instanceof PasswordError)) {
+          // if there is no meeting info we assume its a 1:1 call or wireless share
+          LoggerProxy.logger.info(`Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`);
+          LoggerProxy.logger.info('Meetings:index#createMeeting --> Info assuming this destination is a 1:1 or wireless share');
+        }
         LoggerProxy.logger.debug(`Meetings:index#createMeeting --> Debug ${err} fetching /meetingInfo for creation.`);
         // We need to save this info for future reference
         meeting.destination = destination;

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

@@ -31,8 +31,11 @@ import {
   FLOOR_ACTION,
   SHARE_STATUS,
   METRICS_OPERATIONAL_MEASURES,
+  MEETING_INFO_FAILURE_REASON,
+  PASSWORD_STATUS,
   EVENTS,
-  EVENT_TRIGGERS
+  EVENT_TRIGGERS,
+  _SIP_URI_
 } from '@webex/plugin-meetings/src/constants';
 
 import {
@@ -43,8 +46,11 @@ import {
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
+import PasswordError from '../../../../src/common/errors/password-error';
+import CaptchaError from '../../../../src/common/errors/captcha-error';
 import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
+import {MeetingInfoV2CaptchaError, MeetingInfoV2PasswordError} from '../../../../src/meeting-info/meeting-info-v2';
 
 const {
   getBrowserName
@@ -98,7 +104,8 @@ describe('plugin-meetings', () => {
           },
           mediaSettings: {},
           metrics: {},
-          stats: {}
+          stats: {},
+          experimental: {enableUnifiedMeetings: true}
         }
       }
     });
@@ -173,6 +180,9 @@ describe('plugin-meetings', () => {
           assert.instanceOf(meeting.meetingRequest, MeetingRequest);
           assert.instanceOf(meeting.locusInfo, LocusInfo);
           assert.instanceOf(meeting.mediaProperties, MediaProperties);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.UNKNOWN);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.meetingInfoFailureReason, undefined);
         });
       });
       describe('#invite', () => {
@@ -653,6 +663,14 @@ describe('plugin-meetings', () => {
               });
             });
           });
+          it('should fail if password is required', async () => {
+            meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+            await assert.isRejected(meeting.join(), PasswordError);
+          });
+          it('should fail if captcha is required', async () => {
+            meeting.requiredCaptcha = {captchaId: 'aaa'};
+            await assert.isRejected(meeting.join(), CaptchaError);
+          });
           describe('total failure', () => {
             beforeEach(() => {
               MeetingUtil.isPinOrGuest = sinon.stub().returns(false);
@@ -2010,6 +2028,279 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#fetchMeetingInfo', () => {
+        const FAKE_DESTINATION = 'something@somecompany.com';
+        const FAKE_TYPE = _SIP_URI_;
+        const FAKE_PASSWORD = '123abc';
+        const FAKE_CAPTCHA_CODE = 'a1b2c3XYZ';
+        const FAKE_CAPTCHA_ID = '987654321';
+        const FAKE_CAPTCHA_IMAGE_URL = 'http://captchaimage';
+        const FAKE_CAPTCHA_AUDIO_URL = 'http://captchaaudio';
+        const FAKE_CAPTCHA_REFRESH_URL = 'http://captcharefresh';
+        const FAKE_MEETING_INFO = {
+          conversationUrl: 'some_convo_url',
+          locusUrl: 'some_locus_url',
+          sipUrl: 'some_sip_url', // or sipMeetingUri
+          meetingNumber: '123456', // this.config.experimental.enableUnifiedMeetings
+          hostId: 'some_host_id' // this.owner;
+        };
+        const FAKE_SDK_CAPTCHA_INFO = {
+          captchaId: FAKE_CAPTCHA_ID,
+          verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
+          verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
+          refreshURL: FAKE_CAPTCHA_REFRESH_URL
+        };
+        const FAKE_WBXAPPAPI_CAPTCHA_INFO = {
+          captchaID: `${FAKE_CAPTCHA_ID}-2`,
+          verificationImageURL: `${FAKE_CAPTCHA_IMAGE_URL}-2`,
+          verificationAudioURL: `${FAKE_CAPTCHA_AUDIO_URL}-2`,
+          refreshURL: `${FAKE_CAPTCHA_REFRESH_URL}-2`
+        };
+
+
+        it('calls meetingInfoProvider with all the right parameters and parses the result', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+          await meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: FAKE_PASSWORD, captchaCode: FAKE_CAPTCHA_CODE
+          });
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, FAKE_PASSWORD, {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.requiredCaptcha, null);
+        });
+
+        it('fails if captchaCode is provided when captcha not needed', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.requiredCaptcha = null;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, captchaCode: FAKE_CAPTCHA_CODE
+          }), Error, 'fetchMeetingInfo() called with captchaCode when captcha was not required');
+
+          assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+        });
+
+        it('fails if password is provided when not required', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: FAKE_PASSWORD
+          }), Error, 'fetchMeetingInfo() called with password when password was not required');
+
+          assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+        });
+
+        it('handles meetingInfoProvider requiring password', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE
+          }), PasswordError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
+
+          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);
+        });
+
+        it('handles meetingInfoProvider requiring captcha because of wrong password', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+          meeting.requiredCaptcha = null;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa'
+          }), CaptchaError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+
+          assert.deepEqual(meeting.meetingInfo, {});
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: FAKE_CAPTCHA_ID,
+            verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
+            verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
+            refreshURL: FAKE_CAPTCHA_REFRESH_URL
+          });
+        });
+
+        it('handles meetingInfoProvider requiring captcha because of wrong captcha', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa', captchaCode: 'bbb'
+          }), CaptchaError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, {});
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
+        });
+
+        it('handles successful response when good password is passed', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves(
+              {
+                statusCode: 200,
+                body: FAKE_MEETING_INFO
+              }
+            )
+          };
+          meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+
+          await meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa'
+          });
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.VERIFIED);
+          assert.equal(meeting.requiredCaptcha, null);
+        });
+
+        it('refreshes captcha when captcha was required and we received 403 error code', async () => {
+          const refreshedCaptcha = {
+            captchaID: FAKE_WBXAPPAPI_CAPTCHA_INFO.captchaID,
+            verificationImageURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationImageURL,
+            verificationAudioURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationAudioURL
+          };
+
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+          };
+          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve(
+            {
+              body: refreshedCaptcha
+            }
+          ));
+          meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa', captchaCode: 'bbb'
+          }));
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: refreshedCaptcha.captchaID,
+            verificationImageURL: refreshedCaptcha.verificationImageURL,
+            verificationAudioURL: refreshedCaptcha.verificationAudioURL,
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+          });
+        });
+      });
+
+      describe('#refreshCaptcha', () => {
+        it('fails if no captcha required', async () => {
+          assert.isRejected(meeting.refreshCaptcha(), Error);
+        });
+        it('sends correct request to captcha service refresh url', async () => {
+          const REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx';
+          const EXPECTED_REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx&siteFullName=something.webex.com';
+
+          const FAKE_SDK_CAPTCHA_INFO = {
+            captchaId: 'some id',
+            verificationImageURL: 'some image url',
+            verificationAudioURL: 'some audio url',
+            refreshURL: REFRESH_URL
+          };
+
+          const FAKE_REFRESHED_CAPTCHA = {
+            captchaID: 'some id',
+            verificationImageURL: 'some image url',
+            verificationAudioURL: 'some audio url'
+          };
+
+          // setup the meeting so that a captcha is required
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: 'something@somecompany.com', type: _SIP_URI_, password: ''
+          }), CaptchaError);
+
+          assert.deepEqual(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
+          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve({body: FAKE_REFRESHED_CAPTCHA}));
+
+          // test the captcha refresh
+          await meeting.refreshCaptcha();
+
+          assert.calledWith(meeting.meetingRequest.refreshCaptcha,
+            {
+              captchaRefreshUrl: EXPECTED_REFRESH_URL,
+              captchaId: FAKE_SDK_CAPTCHA_INFO.captchaId
+            });
+
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: FAKE_REFRESHED_CAPTCHA.captchaID,
+            verificationImageURL: FAKE_REFRESHED_CAPTCHA.verificationImageURL,
+            verificationAudioURL: FAKE_REFRESHED_CAPTCHA.verificationAudioURL,
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+          });
+        });
+      });
+
+      describe('#verifyPassword', () => {
+        it('calls fetchMeetingInfo() with the passed password and captcha code', async () => {
+          // simulate successful case
+          meeting.fetchMeetingInfo = sinon.stub().resolves();
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, true);
+          assert.equal(result.requiredCaptcha, null);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.NONE);
+        });
+        it('handles PasswordError returned by fetchMeetingInfo', async () => {
+          meeting.fetchMeetingInfo = sinon.stub().callsFake(() => {
+            meeting.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+
+            return Promise.reject(new PasswordError());
+          });
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, false);
+          assert.equal(result.requiredCaptcha, null);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+        });
+        it('handles CaptchaError returned by fetchMeetingInfo', async () => {
+          const FAKE_CAPTCHA = {captchaId: 'some catcha id...'};
+
+          meeting.fetchMeetingInfo = sinon.stub().callsFake(() => {
+            meeting.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA;
+            meeting.requiredCaptcha = FAKE_CAPTCHA;
+
+            return Promise.reject(new CaptchaError());
+          });
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, false);
+          assert.deepEqual(result.requiredCaptcha, FAKE_CAPTCHA);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
+        });
+      });
       describe('#mediaNegotiatedEvent', () => {
         it('should have #mediaNegotiatedEvent', () => {
           assert.exists(meeting.mediaNegotiatedEvent);

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

@@ -12,7 +12,7 @@ import {
   _MEETING_ID_,
   _PERSONAL_ROOM_
 } from '@webex/plugin-meetings/src/constants';
-import MeetingInfo from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
+import MeetingInfo, {MeetingInfoV2PasswordError, MeetingInfoV2CaptchaError} from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 
 describe('plugin-meetings', () => {
@@ -80,6 +80,79 @@ describe('plugin-meetings', () => {
         MeetingInfoUtil.getDestinationType.restore();
         MeetingInfoUtil.getRequestBody.restore();
       });
+
+      it('should fetch meeting info with provided password and captcha code', async () => {
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: 'webex-appapi-service',
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            meetingKey: '1234323',
+            password: 'abc',
+            captchaID: '999',
+            captchaVerifyCode: 'aabbcc11'
+          }
+        });
+      });
+
+      it('should throw MeetingInfoV2PasswordError for 403 response', async () => {
+        const FAKE_MEETING_INFO = {blablabla: 'some_fake_meeting_info'};
+
+        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 403000, data: {meetingInfo: FAKE_MEETING_INFO}}});
+
+        try {
+          await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        }
+        catch (err) {
+          assert.instanceOf(err, MeetingInfoV2PasswordError);
+          assert.deepEqual(err.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(err.wbxAppApiCode, 403000);
+        }
+      });
+
+      describe('should throw MeetingInfoV2CaptchaError for 423 response', () => {
+        const runTest = async (wbxAppApiCode, expectedIsPasswordRequired) => {
+          webex.request = sinon.stub().rejects(
+            {
+              statusCode: 423,
+              body: {
+                code: wbxAppApiCode,
+                captchaID: 'fake_captcha_id',
+                verificationImageURL: 'fake_image_url',
+                verificationAudioURL: 'fake_audio_url',
+                refreshURL: 'fake_refresh_url'
+              }
+            }
+          );
+          try {
+            await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+            assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+          }
+          catch (err) {
+            assert.instanceOf(err, MeetingInfoV2CaptchaError);
+            assert.deepEqual(err.captchaInfo, {
+              captchaId: 'fake_captcha_id',
+              verificationImageURL: 'fake_image_url',
+              verificationAudioURL: 'fake_audio_url',
+              refreshURL: 'fake_refresh_url'
+            });
+            assert.equal(err.wbxAppApiCode, wbxAppApiCode);
+            assert.equal(err.isPasswordRequired, expectedIsPasswordRequired);
+          }
+        };
+
+        it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423005)', async () => {
+          await runTest(423005, true);
+        });
+
+        it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423001)', async () => {
+          await runTest(423001, false);
+        });
+      });
     });
   });
 });