@webex/plugin-meetings 1.157.0 → 1.159.0

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

@@ -1,34 +1,34 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import 'jsdom-global/register';
 
-import {assert} from '@webex/test-helper-chai';
-import sinon from 'sinon';
-import MockWebex from '@webex/test-helper-mock-webex';
 import Device from '@webex/internal-plugin-device';
 import Mercury from '@webex/internal-plugin-mercury';
+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';
+import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import Meeting from '@webex/plugin-meetings/src/meeting';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Meetings from '@webex/plugin-meetings/src/meetings';
-import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
-import Reachability from '@webex/plugin-meetings/src/reachability';
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
-import Meeting from '@webex/plugin-meetings/src/meeting';
-import MediaUtil from '@webex/plugin-meetings/src/media/util';
-import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
-import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
-import StaticConfig from '@webex/plugin-meetings/src/common/config';
-import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
+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 {skipInBrowser} from '@webex/test-helper-mocha';
 
 import {
   LOCUSEVENT,
-  ROAP,
+  OFFLINE,
   ONLINE,
-  OFFLINE
+  ROAP
 } from '../../../../src/constants';
 
-skipInBrowser(describe)('plugin-meetings', () => {
+describe('plugin-meetings', () => {
   const logger = {
     log: () => {},
     info: () => {},
@@ -39,9 +39,14 @@ skipInBrowser(describe)('plugin-meetings', () => {
   };
 
   beforeEach(() => {
-    StaticConfig.set({bandwidth: {audio: 50, video: 500}});
-    LoggerConfig.set({verboseEvents: true, enable: false});
-    LoggerProxy.set(logger);
+    StaticConfig.set({
+      bandwidth: {
+        audio: 50, video: 500
+      }
+    });
+    LoggerConfig.set({
+      verboseEvents: true, enable: false
+    });
     TriggerProxy.trigger = sinon.stub().returns(true);
   });
 
@@ -54,7 +59,7 @@ skipInBrowser(describe)('plugin-meetings', () => {
 
   describe('meetings index', () => {
     beforeEach(() => {
-      MeetingsUtil.triggerH264Codec = sinon.stub();
+      MeetingsUtil.checkH264Support = sinon.stub();
       uuid1 = uuid.v4();
       url1 = `https://example.com/${uuid.v4()}`;
       uri1 = `test-${uuid.v4()}@example.com`;
@@ -68,12 +73,36 @@ skipInBrowser(describe)('plugin-meetings', () => {
         }
       });
 
+
+      Object.assign(webex, {
+        logging: logger
+      });
+
       Object.assign(webex.meetings.config, {
+        bandwidth: {
+          // please note, these are the maximum bandwidth values
+          // the server supports, minimums have to be tested
+          audio: 64000,
+          video: 4000000,
+          startBitrate: 2000
+        },
         experimental: {
           enableUnifiedMeetings: true
+        },
+        logging: {
+          enable: true,
+          verboseEvents: true
         }
       });
 
+      Object.assign(webex, {
+        logger
+      });
+
+      Object.assign(webex.meetings, {
+        startReachability: sinon.stub().returns(Promise.resolve())
+      });
+
       Object.assign(webex.internal, {
         device: {
           deviceType: 'FAKE_DEVICE',
@@ -85,8 +114,23 @@ skipInBrowser(describe)('plugin-meetings', () => {
           disconnect: sinon.stub().returns(Promise.resolve()),
           on: () => {},
           off: () => {}
+        },
+        services: {
+          fetchLoginUserInformation: sinon.stub().returns(Promise.resolve({
+            userPreferences: [
+              'SparkTOSAccept',
+              // eslint-disable-next-line no-useless-escape
+              '\"preferredWebExSite\":"\go.webex.com\"'
+            ]
+          })),
+          fetchClientRegionInfo: sinon.stub().returns(Promise.resolve())
+        },
+        metrics: {
+          submitClientMetrics: sinon.stub().returns(Promise.resolve())
         }
+
       });
+      webex.emit('ready');
     });
 
     it('has a webex instance with a meetings property', () => {
@@ -95,12 +139,12 @@ skipInBrowser(describe)('plugin-meetings', () => {
     });
 
     it('has set up the static config copy', () => {
-      assert.equal(StaticConfig.meetings.bandwidth.audio, 50);
-      assert.equal(StaticConfig.meetings.bandwidth.video, 500);
+      assert.equal(StaticConfig.meetings.bandwidth.audio, 64000);
+      assert.equal(StaticConfig.meetings.bandwidth.video, 4000000);
     });
 
     it('Should trigger h264 download', () => {
-      assert.calledOnce(MeetingsUtil.triggerH264Codec);
+      assert.calledOnce(MeetingsUtil.checkH264Support);
     });
 
     describe('#_toggleUnifiedMeetings', () => {
@@ -126,15 +170,36 @@ skipInBrowser(describe)('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleAdhocMeetings', () => {
+      it('should have toggleAdhocMeetings', () => {
+        assert.equal(typeof webex.meetings._toggleAdhocMeetings, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to start  adhoc meeting', () => {
+          webex.meetings._toggleAdhocMeetings(false);
+          assert.equal(webex.meetings.config.experimental.enableAdhocMeetings, false);
+        });
+      });
+
+      describe('failure', () => {
+        it('should not accept non boolean input', () => {
+          const currentEnableAdhocMeetings = webex.meetings.config.experimental.enableAdhocMeetings;
+
+          webex.meetings._toggleAdhocMeetings('test');
+          assert.equal(webex.meetings.config.experimental.enableAdhocMeetings, currentEnableAdhocMeetings);
+        });
+      });
+    });
+
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
-        it('emits an event and resolves when register succeeds', (done) => {
+        it('emits an event and resolves when register succeeds', async () => {
           webex.canAuthorize = true;
-          webex.meetings.register().then(() => {
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'register'}, 'meetings:registered');
-            assert.isTrue(webex.meetings.registered);
-            done();
-          });
+          await webex.meetings.register();
+          assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'register'}, 'meetings:registered');
+          assert.isTrue(webex.meetings.registered);
         });
 
         it('rejects when SDK canAuthorize is false', () => {
@@ -154,15 +219,24 @@ skipInBrowser(describe)('plugin-meetings', () => {
           assert.isRejected(webex.meetings.register());
         });
 
-        it('resolves immediately if already registered', (done) => {
+        it('resolves immediately if already registered', async () => {
           webex.canAuthorize = true;
           webex.meetings.registered = true;
-          webex.meetings.register().then(() => {
-            assert.notCalled(webex.internal.device.register);
-            assert.notCalled(webex.internal.mercury.connect);
-            assert.isTrue(webex.meetings.registered);
-            done();
-          });
+          await webex.meetings.register();
+          assert.notCalled(webex.internal.device.register);
+          assert.notCalled(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
+        });
+
+        it('on register makes sure following functions are called ', async () => {
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+          await webex.meetings.register();
+          assert.called(webex.internal.device.register);
+          assert.called(webex.internal.services.fetchLoginUserInformation);
+          assert.called(webex.internal.services.fetchClientRegionInfo);
+          assert.called(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
         });
       });
 
@@ -170,7 +244,9 @@ skipInBrowser(describe)('plugin-meetings', () => {
         it('emits an event and resolves when unregister succeeds', (done) => {
           webex.meetings.registered = true;
           webex.meetings.unregister().then(() => {
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'unregister'}, 'meetings:unregistered');
+            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
+              file: 'meetings', function: 'unregister'
+            }, 'meetings:unregistered');
             assert.isFalse(webex.meetings.registered);
             done();
           });
@@ -262,9 +338,13 @@ skipInBrowser(describe)('plugin-meetings', () => {
             });
             describe('#getAllMeetings', () => {
               it('calls MeetingCollection to get all meetings with supplied options', () => {
-                webex.meetings.getAllMeetings({test: test1});
+                webex.meetings.getAllMeetings({
+                  test: test1
+                });
                 assert.calledOnce(webex.meetings.meetingCollection.getAll);
-                assert.calledWith(webex.meetings.meetingCollection.getAll, {test: test1});
+                assert.calledWith(webex.meetings.meetingCollection.getAll, {
+                  test: test1
+                });
               });
             });
           });
@@ -276,14 +356,22 @@ skipInBrowser(describe)('plugin-meetings', () => {
         });
         describe('succesful requests', () => {
           beforeEach(() => {
-            webex.meetings.request.getActiveMeetings = sinon.stub().returns(Promise.resolve({loci: [{url: url1}]}));
+            webex.meetings.request.getActiveMeetings = sinon.stub().returns(Promise.resolve({
+              loci: [{
+                url: url1
+              }]
+            }));
           });
           describe('when meeting is returned', () => {
             let parse;
 
             beforeEach(() => {
               parse = sinon.stub().returns(true);
-              webex.meetings.meetingCollection.getByKey = sinon.stub().returns({locusInfo: {parse}});
+              webex.meetings.meetingCollection.getByKey = sinon.stub().returns({
+                locusInfo: {
+                  parse
+                }
+              });
             });
             it('tests the sync meeting calls for existing meeting', async () => {
               await webex.meetings.syncMeetings();
@@ -299,7 +387,11 @@ skipInBrowser(describe)('plugin-meetings', () => {
             beforeEach(() => {
               initialSetup = sinon.stub().returns(true);
               webex.meetings.meetingCollection.getByKey = sinon.stub().returns(null);
-              webex.meetings.create = sinon.stub().returns(Promise.resolve({locusInfo: {initialSetup}}));
+              webex.meetings.create = sinon.stub().returns(Promise.resolve({
+                locusInfo: {
+                  initialSetup
+                }
+              }));
             });
             it('tests the sync meeting calls for not existing meeting', async () => {
               await webex.meetings.syncMeetings();
@@ -309,29 +401,51 @@ skipInBrowser(describe)('plugin-meetings', () => {
               assert.calledOnce(webex.meetings.create);
               assert.calledWith(webex.meetings.request.getActiveMeetings);
               assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-              assert.calledWith(webex.meetings.create, {url: url1}, 'LOCUS_ID');
-              assert.calledWith(initialSetup, {url: url1});
+              assert.calledWith(webex.meetings.create, {
+                url: url1
+              }, 'LOCUS_ID');
+              assert.calledWith(initialSetup, {
+                url: url1
+              });
             });
           });
           describe('destory non active meeting', () => {
             let initialSetup;
             let parse;
+            let destroySpy;
 
             beforeEach(() => {
+              destroySpy = sinon.spy(webex.meetings, 'destroy');
               parse = sinon.stub().returns(true);
-              webex.meetings.destroy = sinon.stub();
               initialSetup = sinon.stub().returns(true);
-              webex.meetings.meetingCollection.getByKey = sinon.stub().returns({locusInfo: {parse}, sendCallAnalyzerMetrics: sinon.stub()});
-              webex.meetings.meetingCollection.getAll = sinon.stub().returns({meetingutk: {locusUrl: 'fdfdjfdhj', sendCallAnalyzerMetrics: sinon.stub()}});
-              webex.meetings.create = sinon.stub().returns(Promise.resolve({locusInfo: {initialSetup}, sendCallAnalyzerMetrics: sinon.stub()}));
-              webex.meetings.request.getActiveMeetings = sinon.stub().returns(Promise.resolve({loci: []}));
+              webex.meetings.meetingCollection.getByKey = sinon.stub().returns({
+                locusInfo: {
+                  parse
+                },
+                sendCallAnalyzerMetrics: sinon.stub()
+              });
+              webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+                meetingutk: {
+                  locusUrl: 'fdfdjfdhj', sendCallAnalyzerMetrics: sinon.stub()
+                }
+              });
+              webex.meetings.create = sinon.stub().returns(Promise.resolve({
+                locusInfo: {
+                  initialSetup
+                },
+                sendCallAnalyzerMetrics: sinon.stub()
+              }));
+              webex.meetings.request.getActiveMeetings = sinon.stub().returns(Promise.resolve({
+                loci: []
+              }));
+              MeetingUtil.cleanUp = sinon.stub().returns(Promise.resolve());
             });
             it('destroy non active meetings', async () => {
               await webex.meetings.syncMeetings();
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
-              assert.calledOnce(webex.meetings.destroy);
+              assert.calledOnce(destroySpy);
 
-              assert.calledOnce(MeetingsUtil.cleanUp);
+              assert.calledOnce(MeetingUtil.cleanUp);
             });
           });
         });
@@ -348,7 +462,9 @@ skipInBrowser(describe)('plugin-meetings', () => {
             type: 'CONVERSATION_URL'
           };
           webex.meetings.meetingCollection.getByKey = sinon.stub().returns();
-          webex.meetings.createMeeting = sinon.stub().returns(Promise.resolve({on: () => true}));
+          webex.meetings.createMeeting = sinon.stub().returns(Promise.resolve({
+            on: () => true
+          }));
         });
 
         it('should call MeetingInfo#fetchInfoOptions() with proper params',
@@ -404,17 +520,30 @@ skipInBrowser(describe)('plugin-meetings', () => {
           webex.meetings.handleLocusEvent = sinon.stub().returns(true);
         });
         it('doesnt call handle locus mercury for a locus roap event', () => {
-          webex.meetings.handleLocusMercury({data: {eventType: 'locus.message.roap'}});
+          webex.meetings.handleLocusMercury({
+            data: {
+              eventType: 'locus.message.roap'
+            }
+          });
           assert.notCalled(webex.meetings.handleLocusEvent);
         });
         it('doesnt call handle locus mercury for an undefined eventType', () => {
-          webex.meetings.handleLocusMercury({data: {}});
+          webex.meetings.handleLocusMercury({
+            data: {
+            }
+          });
           assert.notCalled(webex.meetings.handleLocusEvent);
         });
         it('calls handle locus mercury for all locus events', () => {
-          webex.meetings.handleLocusMercury({data: {eventType: test1}});
+          webex.meetings.handleLocusMercury({
+            data: {
+              eventType: test1
+            }
+          });
           assert.calledOnce(webex.meetings.handleLocusEvent);
-          assert.calledWith(webex.meetings.handleLocusEvent, {eventType: test1});
+          assert.calledWith(webex.meetings.handleLocusEvent, {
+            eventType: test1
+          });
         });
       });
       describe('#handleLocusEvent', () => {
@@ -423,14 +552,26 @@ skipInBrowser(describe)('plugin-meetings', () => {
 
           beforeEach(() => {
             parse = sinon.stub().returns(true);
-            webex.meetings.meetingCollection.getByKey = sinon.stub().returns({locusInfo: {parse}});
+            webex.meetings.meetingCollection.getByKey = sinon.stub().returns({
+              locusInfo: {
+                parse
+              }
+            });
           });
           it('should parse the meeting info', () => {
-            webex.meetings.handleLocusEvent({locusUrl: url1});
+            webex.meetings.handleLocusEvent({
+              locusUrl: url1
+            });
             assert.calledOnce(webex.meetings.meetingCollection.getByKey);
             assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
             assert.calledOnce(parse);
-            assert.calledWith(parse, {locusInfo: {parse}}, {locusUrl: url1});
+            assert.calledWith(parse, {
+              locusInfo: {
+                parse
+              }
+            }, {
+              locusUrl: url1
+            });
           });
         });
         describe('there was not a meeting', () => {
@@ -439,28 +580,92 @@ skipInBrowser(describe)('plugin-meetings', () => {
           beforeEach(() => {
             initialSetup = sinon.stub().returns(true);
             webex.meetings.meetingCollection.getByKey = sinon.stub().returns(undefined);
-            webex.meetings.create = sinon.stub().returns(Promise.resolve({locusInfo: {initialSetup}}));
+            webex.meetings.create = sinon.stub().returns(Promise.resolve({
+              locusInfo: {
+                initialSetup
+              }
+            }));
           });
           it('should setup the meeting by difference event', async () => {
-            await webex.meetings.handleLocusEvent({locus: {id: uuid1, replaces: [{locusUrl: 'http:locusUrl'}], self: {callBackInfo: {callbackAddress: uri1}}}, eventType: 'locus.difference', locusUrl: url1});
+            await webex.meetings.handleLocusEvent({
+              locus: {
+                id: uuid1,
+                replaces: [{
+                  locusUrl: 'http:locusUrl'
+                }],
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1
+                  }
+                }
+              },
+              eventType: 'locus.difference',
+              locusUrl: url1
+            });
             assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
             assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
             assert.calledOnce(initialSetup);
-            assert.calledWith(initialSetup, {id: uuid1, replaces: [{locusUrl: 'http:locusUrl'}], self: {callBackInfo: {callbackAddress: uri1}}});
+            assert.calledWith(initialSetup, {
+              id: uuid1,
+              replaces: [{
+                locusUrl: 'http:locusUrl'
+              }],
+              self: {
+                callBackInfo: {
+                  callbackAddress: uri1
+                }
+              }
+            });
           });
           it('should setup the meeting by difference event without replaces', async () => {
-            await webex.meetings.handleLocusEvent({locus: {id: uuid1, self: {callBackInfo: {callbackAddress: uri1}}}, eventType: 'locus.difference', locusUrl: url1});
+            await webex.meetings.handleLocusEvent({
+              locus: {
+                id: uuid1,
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1
+                  }
+                }
+              },
+              eventType: 'locus.difference',
+              locusUrl: url1
+            });
             assert.callCount(webex.meetings.meetingCollection.getByKey, 4);
             assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
             assert.calledOnce(initialSetup);
-            assert.calledWith(initialSetup, {id: uuid1, self: {callBackInfo: {callbackAddress: uri1}}});
+            assert.calledWith(initialSetup, {
+              id: uuid1,
+              self: {
+                callBackInfo: {
+                  callbackAddress: uri1
+                }
+              }
+            });
           });
           it('should setup the meeting by a not difference event', async () => {
-            await webex.meetings.handleLocusEvent({locus: {id: uuid1, self: {callBackInfo: {callbackAddress: uri1}}}, eventType: test1, locusUrl: url1});
+            await webex.meetings.handleLocusEvent({
+              locus: {
+                id: uuid1,
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1
+                  }
+                }
+              },
+              eventType: test1,
+              locusUrl: url1
+            });
             assert.callCount(webex.meetings.meetingCollection.getByKey, 4);
             assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
             assert.calledOnce(initialSetup);
-            assert.calledWith(initialSetup, {id: uuid1, self: {callBackInfo: {callbackAddress: uri1}}});
+            assert.calledWith(initialSetup, {
+              id: uuid1,
+              self: {
+                callBackInfo: {
+                  callbackAddress: uri1
+                }
+              }
+            });
           });
         });
       });
@@ -471,23 +676,23 @@ skipInBrowser(describe)('plugin-meetings', () => {
           webex.internal.device.url = url1;
           MeetingCollection.set = sinon.stub().returns(true);
           MeetingsUtil.getMeetingAddedType = sinon.stub().returns('test');
-          MeetingsUtil.extractDestination = sinon.stub().returns('test');
+          TriggerProxy.trigger.reset();
         });
         describe('successful MeetingInfo.#fetchMeetingInfo', () => {
           beforeEach(() => {
-            webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(Promise.resolve({body: {permissionToken: 'PT', meetingJoinUrl: 'meetingJoinUrl'}}));
+            webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(Promise.resolve({
+              body: {
+                permissionToken: 'PT', meetingJoinUrl: 'meetingJoinUrl'
+              }
+            }));
           });
           it('creates the meeting from a successful meeting info fetch promise testing', async () => {
-            const meeting = webex.meetings.createMeeting('test', 'test');
+            const meeting = await webex.meetings.createMeeting('test', 'test');
 
-            assert.exists(meeting.then);
-            await meeting;
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
-            assert.calledOnce(MeetingsUtil.extractDestination);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.calledTwice(TriggerProxy.trigger);
             assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test');
-            assert.calledWith(MeetingsUtil.extractDestination, 'test', 'test');
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
             assert.equal(meeting.permissionToken, 'PT');
             assert.equal(meeting.meetingJoinUrl, 'meetingJoinUrl');
@@ -498,18 +703,21 @@ skipInBrowser(describe)('plugin-meetings', () => {
 
             assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
-            assert.calledOnce(MeetingsUtil.extractDestination);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.calledTwice(TriggerProxy.trigger);
             assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test');
-            assert.calledWith(MeetingsUtil.extractDestination, 'test', 'test');
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'createMeeting'}, 'meeting:added', {meeting: sinon.match.instanceOf(Meeting), type: 'test'});
+            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
+              file: 'meetings', function: 'createMeeting'
+            }, 'meeting:added', {
+              meeting: sinon.match.instanceOf(Meeting), type: 'test'
+            });
           });
         });
         describe('rejected MeetingInfo.#fetchMeetingInfo', () => {
           beforeEach(() => {
             console.error = sinon.stub().returns(false);
+            TriggerProxy.trigger.reset();
             webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(Promise.reject(new Error('test')));
           });
           it('creates the meeting from a rejected meeting info fetch', async () => {
@@ -517,19 +725,25 @@ skipInBrowser(describe)('plugin-meetings', () => {
 
             assert.instanceOf(meeting, Meeting, 'createMeeting should eventually resolve to a Meeting Object');
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
-            assert.calledOnce(MeetingsUtil.extractDestination);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.calledTwice(TriggerProxy.trigger);
             assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test');
-            assert.calledWith(MeetingsUtil.extractDestination, 'test', 'test');
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'createMeeting'}, 'meeting:added', {meeting: sinon.match.instanceOf(Meeting), type: 'test'});
+            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
+              file: 'meetings', function: 'createMeeting'
+            }, 'meeting:added', {
+              meeting: sinon.match.instanceOf(Meeting), type: 'test'
+            });
           });
         });
       });
     });
     describe('Public Event Triggers', () => {
       describe('#destroy', () => {
+        beforeEach(() => {
+          MediaUtil.createPeerConnection = sinon.stub().returns(true);
+          MeetingUtil.cleanUp = sinon.stub();
+        });
         it('should have #destroy', () => {
           assert.exists(webex.meetings.destroy);
         });
@@ -538,23 +752,33 @@ skipInBrowser(describe)('plugin-meetings', () => {
             webex.meetings.meetingCollection.delete = sinon.stub().returns(true);
           });
 
-          it('tests the destroy removal from the collection', () => {
-            webex.meetings.destroy({id: uuid1}, test1);
+          it('tests the destroy removal from the collection', async () => {
+            const meeting = await webex.meetings.createMeeting('test', 'test');
+
+            webex.meetings.destroy(meeting, test1);
 
             assert.calledOnce(webex.meetings.meetingCollection.delete);
-            assert.calledWith(webex.meetings.meetingCollection.delete, uuid1);
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'destroy'}, 'meeting:removed', {meetingId: uuid1, reason: test1});
+            assert.calledWith(webex.meetings.meetingCollection.delete, meeting.id);
+            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
+              file: 'meetings', function: 'destroy'
+            }, 'meeting:removed', {
+              meetingId: meeting.id, reason: test1
+            });
           });
         });
 
         describe('with auto upload logs enabled', () => {
           beforeEach(() => {
-            webex.meetings.config.autoUploadLogs = true;
+            webex.config.autoUploadLogs = true;
             webex.meetings.loggerRequest.uploadLogs = sinon.stub().returns(Promise.resolve());
           });
 
-          it('uploads logs on destroy', () => {
-            webex.meetings.destroy({id: uuid1}, test1);
+          // Invalid test currently does not upload log on destroy of meeting when we do destory
+          // rather happens when we do leave or when via the meetign object action
+          xit('uploads logs on destroy', async () => {
+            const meeting = await webex.meetings.createMeeting('test', 'test');
+
+            webex.meetings.destroy(meeting, test1);
             assert.calledOnce(webex.meetings.loggerRequest.uploadLogs);
           });
         });
@@ -563,9 +787,13 @@ skipInBrowser(describe)('plugin-meetings', () => {
       describe('#network:disconnected', () => {
         it('should trigger event upon mercury disconnect', () => {
           const {meetings} = webex;
-          const SCOPE = {file: 'meetings/index', function: 'handleMercuryOffline'};
+          const SCOPE = {
+            file: 'meetings/index', function: 'handleMercuryOffline'
+          };
           const EVENT = 'network:disconnected';
 
+          TriggerProxy.trigger.reset();
+
           meetings.handleMercuryOffline = sinon.spy(meetings.handleMercuryOffline);
           webex.internal.mercury.disconnect = sinon.stub().callsFake(meetings.handleMercuryOffline);
 
@@ -576,6 +804,15 @@ skipInBrowser(describe)('plugin-meetings', () => {
           assert.calledWith(TriggerProxy.trigger, webex.internal.mercury, SCOPE, EVENT);
         });
       });
+
+      describe('#fetchUserPreferredWebexSite', () => {
+        it('should call request.fetchLoginUserInformation to get the preferred webex site ', async () => {
+          assert.isDefined(webex.meetings.preferredWebexSite);
+          await webex.meetings.fetchUserPreferredWebexSite();
+
+          assert.equal(webex.meetings.preferredWebexSite, 'go.webex.com');
+        });
+      });
     });
   });
 });