@webex/plugin-meetings 1.158.0 → 1.159.2

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

@@ -28,7 +28,6 @@ import {
   ROAP
 } from '../../../../src/constants';
 
-
 describe('plugin-meetings', () => {
   const logger = {
     log: () => {},
@@ -74,6 +73,11 @@ describe('plugin-meetings', () => {
         }
       });
 
+
+      Object.assign(webex, {
+        logging: logger
+      });
+
       Object.assign(webex.meetings.config, {
         bandwidth: {
           // please note, these are the maximum bandwidth values
@@ -86,7 +90,7 @@ describe('plugin-meetings', () => {
           enableUnifiedMeetings: true
         },
         logging: {
-          enable: false,
+          enable: true,
           verboseEvents: true
         }
       });
@@ -95,6 +99,10 @@ describe('plugin-meetings', () => {
         logger
       });
 
+      Object.assign(webex.meetings, {
+        startReachability: sinon.stub().returns(Promise.resolve())
+      });
+
       Object.assign(webex.internal, {
         device: {
           deviceType: 'FAKE_DEVICE',
@@ -162,17 +170,36 @@ 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', () => {
@@ -192,15 +219,24 @@ 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);
         });
       });
 
@@ -639,7 +675,7 @@ describe('plugin-meetings', () => {
           webex.internal.device.userId = uuid1;
           webex.internal.device.url = url1;
           MeetingCollection.set = sinon.stub().returns(true);
-          MeetingsUtil.getMeetingAddedType = sinon.stub().returns('test');
+          MeetingsUtil.getMeetingAddedType = sinon.stub().returns('test meeting added type');
           TriggerProxy.trigger.reset();
         });
         describe('successful MeetingInfo.#fetchMeetingInfo', () => {
@@ -651,30 +687,32 @@ describe('plugin-meetings', () => {
             }));
           });
           it('creates the meeting from a successful meeting info fetch promise testing', async () => {
-            const meeting = await webex.meetings.createMeeting('test', 'test');
+            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.calledTwice(TriggerProxy.trigger);
-            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test');
-            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test destination', 'test 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');
           });
 
           it('creates the meeting from a successful meeting info fetch meeting resolve testing', async () => {
-            const meeting = await webex.meetings.createMeeting('test', 'test');
+            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
             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');
-            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test destination', 'test type');
+            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
             assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
               file: 'meetings', function: 'createMeeting'
             }, 'meeting:added', {
-              meeting: sinon.match.instanceOf(Meeting), type: 'test'
+              meeting: sinon.match.instanceOf(Meeting), type: 'test meeting added type'
             });
           });
         });
@@ -685,18 +723,18 @@ describe('plugin-meetings', () => {
             webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(Promise.reject(new Error('test')));
           });
           it('creates the meeting from a rejected meeting info fetch', async () => {
-            const meeting = await webex.meetings.createMeeting('test', 'test');
+            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
             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');
-            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test');
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, 'test destination', 'test type');
+            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
             assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
               file: 'meetings', function: 'createMeeting'
             }, 'meeting:added', {
-              meeting: sinon.match.instanceOf(Meeting), type: 'test'
+              meeting: sinon.match.instanceOf(Meeting), type: 'test meeting added type'
             });
           });
         });
@@ -768,6 +806,29 @@ 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');
+        });
+
+        it('should not fail if UserPreferred info is not fetched ', async () => {
+          Object.assign(webex.internal, {
+            services: {
+              fetchLoginUserInformation: sinon.stub().returns(Promise.resolve({})),
+            },
+
+          });
+
+          await webex.meetings.fetchUserPreferredWebexSite()
+            .then(() => {
+              assert.equal(webex.meetings.preferredWebexSite, '');
+            });
+        });
+      });
     });
   });
 });

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

@@ -0,0 +1,18 @@
+import {assert} from '@webex/test-helper-chai';
+import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
+
+describe('plugin-meetings', () => {
+  describe('Meetings utils function', () => {
+    describe('#parseUserPreferences', () => {
+      it('parsed the prefered webesite from userPreferences', async () => {
+        const res = MeetingsUtil.parseUserPreferences([
+          'SparkTOSAccept',
+          '"preferredWebExSite":"go.webex.com"'
+        ]);
+
+        assert.equal(res, 'go.webex.com');
+      });
+    });
+  });
+});
+