@webex/plugin-meetings 1.161.0 → 2.0.0

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

@@ -10,6 +10,7 @@ import {assert} from '@webex/test-helper-chai';
 import {Credentials} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
+
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
 import Meeting from '@webex/plugin-meetings/src/meeting';
 import Members from '@webex/plugin-meetings/src/members';
@@ -228,6 +229,7 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.policy);
           assert.instanceOf(meeting.meetingRequest, MeetingRequest);
           assert.instanceOf(meeting.locusInfo, LocusInfo);
+          assert.equal(meeting.fetchMeetingInfoTimeoutId, undefined);
           assert.instanceOf(meeting.mediaProperties, MediaProperties);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.UNKNOWN);
           assert.equal(meeting.requiredCaptcha, null);
@@ -2118,6 +2120,7 @@ describe('plugin-meetings', () => {
       describe('#fetchMeetingInfo', () => {
         const FAKE_DESTINATION = 'something@somecompany.com';
         const FAKE_TYPE = _SIP_URI_;
+        const FAKE_TIMEOUT_FETCHMEETINGINFO_ID = '123456';
         const FAKE_PASSWORD = '123abc';
         const FAKE_CAPTCHA_CODE = 'a1b2c3XYZ';
         const FAKE_CAPTCHA_ID = '987654321';
@@ -2150,6 +2153,7 @@ describe('plugin-meetings', () => {
           meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
+          meeting.parseMeetingInfo = sinon.stub().returns(undefined);
 
           await meeting.fetchMeetingInfo({
             password: FAKE_PASSWORD, captchaCode: FAKE_CAPTCHA_CODE
@@ -2157,10 +2161,45 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, FAKE_PASSWORD, {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID});
 
+          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
           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);
+          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+        });
+
+        it('calls meetingInfoProvider with all the right parameters and parses the result when random delay is applied', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.destination = FAKE_DESTINATION;
+          meeting.destinationType = FAKE_TYPE;
+          meeting.parseMeetingInfo = sinon.stub().returns(undefined);
+          meeting.fetchMeetingInfoTimeoutId = FAKE_TIMEOUT_FETCHMEETINGINFO_ID;
+
+          const clock = sinon.useFakeTimers();
+          const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+          await meeting.fetchMeetingInfo({});
+
+          // clear timer
+          assert.calledWith(clearTimeoutSpy, FAKE_TIMEOUT_FETCHMEETINGINFO_ID);
+          clock.restore();
+          assert.isUndefined(meeting.fetchMeetingInfoTimeoutId);
+
+          // meeting info provider
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
+
+          // parseMeeting info
+          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
+
+          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
         });
 
         it('fails if captchaCode is provided when captcha not needed', async () => {
@@ -2428,6 +2467,64 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('#endMeeting for all', () => {
+        let sandbox;
+
+        it('should have #endMeetingForAll', () => {
+          assert.exists(meeting.endMeetingForAll);
+        });
+
+        it('should reject if meeting is already ended', async () => {
+          await meeting.endMeetingForAll().catch((err) => {
+            assert.instanceOf(err, MeetingNotActiveError);
+          });
+        });
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          meeting.meetingFiniteStateMachine.ring();
+          meeting.meetingFiniteStateMachine.join();
+          meeting.meetingRequest.endMeetingForAll = sinon.stub().returns(Promise.resolve({body: 'test'}));
+          meeting.locusInfo.onFullLocus = sinon.stub().returns(true);
+          meeting.closeLocalStream = sinon.stub().returns(Promise.resolve());
+          meeting.closeLocalShare = sinon.stub().returns(Promise.resolve());
+          meeting.closeRemoteStream = sinon.stub().returns(Promise.resolve());
+          sandbox.stub(meeting, 'closeRemoteTracks').returns(Promise.resolve());
+          meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+          meeting.unsetLocalVideoTrack = sinon.stub().returns(true);
+          meeting.unsetLocalShareTrack = sinon.stub().returns(true);
+          meeting.unsetRemoteTracks = sinon.stub();
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub()};
+          meeting.unsetRemoteStream = sinon.stub().returns(true);
+          meeting.unsetPeerConnections = sinon.stub().returns(true);
+          meeting.roap.stop = sinon.stub().returns(Promise.resolve());
+          meeting.logger.error = sinon.stub().returns(true);
+
+          // A meeting needs to be joined to end
+          meeting.meetingState = 'ACTIVE';
+          meeting.state = 'JOINED';
+        });
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+        it('should end the meeting for all and return promise', async () => {
+          const endMeetingForAll = meeting.endMeetingForAll();
+
+          assert.exists(endMeetingForAll.then);
+          await endMeetingForAll;
+          assert.calledOnce(meeting?.meetingRequest?.endMeetingForAll);
+          assert.calledOnce(meeting?.closeLocalStream);
+          assert.calledOnce(meeting?.closeLocalShare);
+          assert.calledOnce(meeting?.closeRemoteTracks);
+          assert.calledOnce(meeting?.closePeerConnections);
+          assert.calledOnce(meeting?.unsetLocalVideoTrack);
+          assert.calledOnce(meeting?.unsetLocalShareTrack);
+          assert.calledOnce(meeting?.unsetRemoteTracks);
+          assert.calledOnce(meeting?.unsetPeerConnections);
+          assert.calledOnce(meeting?.roap?.stop);
+        });
+      });
     });
 
     describe('Public Event Triggers', () => {
@@ -2879,21 +2976,141 @@ describe('plugin-meetings', () => {
         });
       });
       describe('#parseMeetingInfo', () => {
-        it('should parse meeting info, set values, and return null', () => {
+        const checkParseMeetingInfo = (expectedInfoToParse) => {
+          assert.equal(meeting.conversationUrl, expectedInfoToParse.conversationUrl);
+          assert.equal(meeting.locusUrl, expectedInfoToParse.locusUrl);
+          assert.equal(meeting.sipUri, expectedInfoToParse.sipUri);
+          assert.equal(meeting.meetingNumber, expectedInfoToParse.meetingNumber);
+          assert.equal(meeting.meetingJoinUrl, expectedInfoToParse.meetingJoinUrl);
+          assert.equal(meeting.owner, expectedInfoToParse.owner);
+          assert.equal(meeting.permissionToken, expectedInfoToParse.permissionToken);
+        };
+
+        it('should parse meeting info from api return when locus meeting object is not available, set values, and return null', () => {
           meeting.config.experimental = {enableMediaNegotiatedEvent: true};
+          meeting.config.experimental.enableUnifiedMeetings = true;
+          const FAKE_MEETING_INFO = {
+            body: {
+              conversationUrl: uuid1,
+              locusUrl: url1,
+              meetingJoinUrl: url2,
+              meetingNumber: '12345',
+              permissionToken: 'abc',
+              sipMeetingUri: test1,
+              sipUrl: test1,
+              owner: test2
+            }
+          };
 
-          meeting.parseMeetingInfo({
+          meeting.parseMeetingInfo(FAKE_MEETING_INFO);
+          const expectedInfoToParse = {
+            conversationUrl: uuid1,
+            locusUrl: url1,
+            sipUri: test1,
+            meetingNumber: '12345',
+            meetingJoinUrl: url2,
+            owner: test2,
+            permissionToken: 'abc'
+          };
+
+          checkParseMeetingInfo(expectedInfoToParse);
+        });
+        it('should parse meeting info from locus meeting object if possible, else from api return, set values, and return null', () => {
+          meeting.config.experimental = {enableMediaNegotiatedEvent: true};
+          meeting.config.experimental.enableUnifiedMeetings = true;
+          const FAKE_LOCUS_MEETING = {
+            conversationUrl: 'locusConvURL',
+            url: 'locusUrl',
+            info: {
+              webExMeetingId: 'locusMeetingId',
+              sipUri: 'locusSipUri',
+              owner: 'locusOwner'
+            }
+          };
+          const FAKE_MEETING_INFO = {
             body: {
               conversationUrl: uuid1,
               locusUrl: url1,
+              meetingJoinUrl: url2,
+              meetingNumber: '12345',
+              permissionToken: 'abc',
               sipMeetingUri: test1,
+              sipUrl: test1,
               owner: test2
             }
-          });
-          assert.equal(meeting.conversationUrl, uuid1);
-          assert.equal(meeting.locusUrl, url1);
-          assert.equal(meeting.sipUri, test1);
-          assert.equal(meeting.owner, test2);
+          };
+
+          meeting.parseMeetingInfo(FAKE_MEETING_INFO, FAKE_LOCUS_MEETING);
+          const expectedInfoToParse = {
+            conversationUrl: 'locusConvURL',
+            locusUrl: 'locusUrl',
+            sipUri: 'locusSipUri',
+            meetingNumber: 'locusMeetingId',
+            meetingJoinUrl: url2,
+            owner: 'locusOwner',
+            permissionToken: 'abc'
+          };
+
+          checkParseMeetingInfo(expectedInfoToParse);
+        });
+        it('should parse meeting info from api return, set values, and return null', () => {
+          meeting.config.experimental = {enableMediaNegotiatedEvent: true};
+          meeting.config.experimental.enableUnifiedMeetings = true;
+          const FAKE_MEETING_INFO = {
+            body: {
+              conversationUrl: uuid1,
+              locusUrl: url1,
+              meetingJoinUrl: url2,
+              meetingNumber: '12345',
+              permissionToken: 'abc',
+              sipMeetingUri: test1,
+              sipUrl: test1,
+              owner: test2
+            }
+          };
+
+          meeting.parseMeetingInfo(FAKE_MEETING_INFO);
+          const expectedInfoToParse = {
+            conversationUrl: uuid1,
+            locusUrl: url1,
+            sipUri: test1,
+            meetingNumber: '12345',
+            meetingJoinUrl: url2,
+            owner: test2,
+            permissionToken: 'abc'
+          };
+
+          checkParseMeetingInfo(expectedInfoToParse);
+        });
+        it('should parse meeting info, set values, and return null when destination is a string', () => {
+          meeting.config.experimental = {enableMediaNegotiatedEvent: true};
+          meeting.config.experimental.enableUnifiedMeetings = true;
+          const FAKE_STRING_DESTINATION = 'sipUrl';
+          const FAKE_MEETING_INFO = {
+            body: {
+              conversationUrl: uuid1,
+              locusUrl: url1,
+              meetingJoinUrl: url2,
+              meetingNumber: '12345',
+              permissionToken: 'abc',
+              sipMeetingUri: test1,
+              sipUrl: test1,
+              owner: test2
+            }
+          };
+
+          meeting.parseMeetingInfo(FAKE_MEETING_INFO, FAKE_STRING_DESTINATION);
+          const expectedInfoToParse = {
+            conversationUrl: uuid1,
+            locusUrl: url1,
+            sipUri: test1,
+            meetingNumber: '12345',
+            meetingJoinUrl: url2,
+            owner: test2,
+            permissionToken: 'abc'
+          };
+
+          checkParseMeetingInfo(expectedInfoToParse);
         });
       });
       describe('#parseLocus', () => {

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

@@ -249,5 +249,19 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.device.deviceType, 'PROVISIONAL');
       });
     });
+
+    describe('#endMeetingForAll', () => {
+      it('sends request to endMeetingForAll', async () => {
+        const locusUrl = 'locusURL';
+
+        await meetingsRequest.endMeetingForAll({
+          locusUrl,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/end`);
+      });
+    });
   });
 });

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

@@ -5,6 +5,11 @@ import 'jsdom-global/register';
 
 import Device from '@webex/internal-plugin-device';
 import Mercury from '@webex/internal-plugin-mercury';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import uuid from 'uuid';
+
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
@@ -16,11 +21,8 @@ import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 import Reachability from '@webex/plugin-meetings/src/reachability';
-import {assert} from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
-import sinon from 'sinon';
-import uuid from 'uuid';
 
+import testUtils from '../../../utils/testUtils';
 import {
   LOCUSEVENT,
   OFFLINE,
@@ -489,12 +491,13 @@ describe('plugin-meetings', () => {
           });
 
         it('calls createMeeting and returns its promise', async () => {
-          const create = webex.meetings.create(test1, test2);
+          const FAKE_USE_RANDOM_DELAY = true;
+          const create = webex.meetings.create(test1, test2, FAKE_USE_RANDOM_DELAY);
 
           assert.exists(create.then);
           await create;
           assert.calledOnce(webex.meetings.createMeeting);
-          assert.calledWith(webex.meetings.createMeeting, test1, test2);
+          assert.calledWith(webex.meetings.createMeeting, test1, test2, FAKE_USE_RANDOM_DELAY);
         });
 
         it('creates a new meeting when a scheduled meeting exists in the conversation', async () => {
@@ -582,7 +585,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(webex.meetings.handleLocusEvent);
           assert.calledWith(webex.meetings.handleLocusEvent, {
             eventType: test1
-          });
+          }, true);
         });
       });
       describe('#handleLocusEvent', () => {
@@ -753,43 +756,208 @@ describe('plugin-meetings', () => {
           TriggerProxy.trigger.reset();
         });
         describe('successful MeetingInfo.#fetchMeetingInfo', () => {
+          let clock, setTimeoutSpy, fakeMeetingStartTimeString, FAKE_TIME_TO_START;
+
           beforeEach(() => {
+            clock = sinon.useFakeTimers();
+            setTimeoutSpy = sinon.spy(clock, 'setTimeout');
             webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(Promise.resolve({
               body: {
                 permissionToken: 'PT', meetingJoinUrl: 'meetingJoinUrl'
               }
             }));
+            const nowTimeStamp = Date.now();
+
+            FAKE_TIME_TO_START = 0.1 * 60 * 1000;
+            const fakeMeetingStartTimeStamp = nowTimeStamp + FAKE_TIME_TO_START;
+            const fakeMeetingStartTimeDate = new Date(fakeMeetingStartTimeStamp);
+
+            fakeMeetingStartTimeString = fakeMeetingStartTimeDate.toISOString();
+          });
+
+          afterEach(() => {
+            clock.restore();
           });
-          it('creates the meeting from a successful meeting info fetch promise testing', async () => {
-            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
+          const checkCreateWithoutDelay = (meeting, destination, type, expectedMeetingData = {}) => {
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
-            assert.calledTwice(TriggerProxy.trigger);
-            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test destination', 'test type');
+            assert.notCalled(setTimeoutSpy);
+            assert.calledThrice(TriggerProxy.trigger);
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, destination, type);
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
-            assert.equal(meeting.permissionToken, 'PT');
-            assert.equal(meeting.meetingJoinUrl, 'meetingJoinUrl');
-            assert.equal(meeting.destination, 'test destination');
-            assert.equal(meeting.destinationType, 'test type');
+
+            if (expectedMeetingData.permissionToken) {
+              assert.equal(meeting.permissionToken, expectedMeetingData.permissionToken);
+            }
+            if (expectedMeetingData.meetingJoinUrl) {
+              assert.equal(meeting.meetingJoinUrl, expectedMeetingData.meetingJoinUrl);
+            }
+            assert.equal(meeting.destination, destination);
+            assert.equal(meeting.destinationType, type);
+            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
+              file: 'meetings', function: 'createMeeting'
+            }, 'meeting:added', {
+              meeting: sinon.match.instanceOf(Meeting), type: 'test meeting added type'
+            });
+            assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+          };
+
+          it('creates the meeting from a successful meeting info fetch promise testing', async () => {
+            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
+
+            const expectedMeetingData = {
+              permissionToken: 'PT',
+              meetingJoinUrl: 'meetingJoinUrl'
+            };
+
+            checkCreateWithoutDelay(meeting, 'test destination', 'test type', expectedMeetingData);
           });
 
           it('creates the meeting from a successful meeting info fetch meeting resolve testing', async () => {
             const meeting = await webex.meetings.createMeeting('test destination', 'test type');
+            const expectedMeetingData = {
+              permissionToken: 'PT',
+              meetingJoinUrl: 'meetingJoinUrl'
+            };
 
             assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
-            assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
-            assert.calledOnce(MeetingsUtil.getMeetingAddedType);
-            assert.calledTwice(TriggerProxy.trigger);
-            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test destination', 'test type');
+            checkCreateWithoutDelay(meeting, 'test destination', 'test type', expectedMeetingData);
+          });
+
+          it('creates the meeting from a successful meeting info fetch with random delay', async () => {
+            const FAKE_LOCUS_MEETING = {
+              conversationUrl: 'locusConvURL',
+              url: 'locusUrl',
+              info: {
+                webExMeetingId: 'locusMeetingId',
+                sipUri: 'locusSipUri',
+                owner: 'locusOwner'
+              },
+              meeting: {
+                startTime: fakeMeetingStartTimeString
+              },
+              fullState: {
+                active: false
+              }
+            };
+
+            const meeting = await webex.meetings.createMeeting(FAKE_LOCUS_MEETING, 'test type', true);
+
+            assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
+            assert.notCalled(webex.meetings.meetingInfo.fetchMeetingInfo);
+            assert.calledOnce(setTimeoutSpy);
+
+            // Parse meeting info with locus object
+            assert.equal(meeting.conversationUrl, 'locusConvURL');
+            assert.equal(meeting.locusUrl, 'locusUrl');
+            assert.equal(meeting.sipUri, 'locusSipUri');
+            assert.equal(meeting.meetingNumber, 'locusMeetingId');
+            assert.isUndefined(meeting.meetingJoinUrl);
+            assert.equal(meeting.owner, 'locusOwner');
+            assert.isUndefined(meeting.permissionToken);
+
+            // Add meeting and send trigger
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
+            assert.calledTwice(TriggerProxy.trigger);
             assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
               file: 'meetings', function: 'createMeeting'
             }, 'meeting:added', {
               meeting: sinon.match.instanceOf(Meeting), type: 'test meeting added type'
             });
+
+            // When timer expires
+            clock.tick(FAKE_TIME_TO_START);
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, FAKE_LOCUS_MEETING, 'test type');
+
+            // Parse meeting info is called again with new meeting info
+            await testUtils.flushPromises();
+            assert.equal(meeting.conversationUrl, 'locusConvURL');
+            assert.equal(meeting.locusUrl, 'locusUrl');
+            assert.equal(meeting.sipUri, 'locusSipUri');
+            assert.equal(meeting.meetingNumber, 'locusMeetingId');
+            assert.equal(meeting.meetingJoinUrl, 'meetingJoinUrl');
+            assert.equal(meeting.owner, 'locusOwner');
+            assert.equal(meeting.permissionToken, 'PT');
+
+            assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+          });
+
+          it('creates the meeting from a successful meeting info fetch that has no random delay because it is active', async () => {
+            const FAKE_LOCUS_MEETING = {
+              conversationUrl: 'locusConvURL',
+              url: 'locusUrl',
+              info: {
+                webExMeetingId: 'locusMeetingId',
+                sipUri: 'locusSipUri',
+                owner: 'locusOwner'
+              },
+              meeting: {
+                startTime: fakeMeetingStartTimeString
+              },
+              fullState: {
+                active: true
+              }
+            };
+
+            const meeting = await webex.meetings.createMeeting(FAKE_LOCUS_MEETING, 'test type', true);
+
+            assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
+            checkCreateWithoutDelay(meeting, FAKE_LOCUS_MEETING, 'test type');
+          });
+
+          it('creates the meeting from a successful meeting info fetch that has no random delay because meeting start time is in the past', async () => {
+            const FAKE_LOCUS_MEETING = {
+              conversationUrl: 'locusConvURL',
+              url: 'locusUrl',
+              info: {
+                webExMeetingId: 'locusMeetingId',
+                sipUri: 'locusSipUri',
+                owner: 'locusOwner'
+              },
+              meeting: {
+                startTime: fakeMeetingStartTimeString - (1 * 60 * 60 * 1000)
+              },
+              fullState: {
+                active: false
+              }
+            };
+
+            const meeting = await webex.meetings.createMeeting(FAKE_LOCUS_MEETING, 'test type', true);
+
+            assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
+            checkCreateWithoutDelay(meeting, FAKE_LOCUS_MEETING, 'test type');
+          });
+
+          it('creates the meeting from a successful meeting info fetch that has no random delay because enableUnifiedMeetings is disabled', async () => {
+            Object.assign(webex.meetings.config, {
+              experimental: {
+                enableUnifiedMeetings: false
+              }
+            });
+            const FAKE_LOCUS_MEETING = {
+              conversationUrl: 'locusConvURL',
+              url: 'locusUrl',
+              info: {
+                webExMeetingId: 'locusMeetingId',
+                sipUri: 'locusSipUri',
+                owner: 'locusOwner'
+              },
+              meeting: {
+                startTime: fakeMeetingStartTimeString
+              },
+              fullState: {
+                active: false
+              }
+            };
+
+            const meeting = await webex.meetings.createMeeting(FAKE_LOCUS_MEETING, 'test type', true);
+
+            assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
+            checkCreateWithoutDelay(meeting, FAKE_LOCUS_MEETING, 'test type');
           });
         });
+
         describe('rejected MeetingInfo.#fetchMeetingInfo', () => {
           beforeEach(() => {
             console.error = sinon.stub().returns(false);