@webex/internal-plugin-calendar 3.0.0-beta.4 → 3.0.0-beta.400

package/test/unit/spec/calendar.js

@@ -2,13 +2,19 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 
-import {assert} from '@webex/test-helper-chai';
+import { assert, expect } from "@webex/test-helper-chai";
 import Calendar from '@webex/internal-plugin-calendar';
 import MockWebex from '@webex/test-helper-mock-webex';
-import btoa from 'btoa';
+import { base64 } from "@webex/common";
 import sinon from 'sinon';
 
-import {CALENDAR_REGISTERED, CALENDAR_UPDATED, CALENDAR_DELETE, CALENDAR_CREATE, CALENDAR_UNREGISTERED} from '../../../src/constants';
+import {
+  CALENDAR_REGISTERED,
+  CALENDAR_UPDATED,
+  CALENDAR_DELETE,
+  CALENDAR_CREATE,
+  CALENDAR_UNREGISTERED,
+} from '../../../src/constants';
 
 describe('internal-plugin-calendar', () => {
   describe('Calendar Apis', () => {
@@ -17,14 +23,14 @@ describe('internal-plugin-calendar', () => {
     beforeEach(async () => {
       webex = new MockWebex({
         children: {
-          calendar: Calendar
-        }
+          calendar: Calendar,
+        },
       });
 
       webex.canAuthorize = true;
       webex.internal.device = {
         register: sinon.stub().returns(Promise.resolve()),
-        unregister: sinon.stub().returns(Promise.resolve())
+        unregister: sinon.stub().returns(Promise.resolve()),
       };
       webex.internal.mercury = {
         connect: sinon.stub().returns(Promise.resolve()),
@@ -40,16 +46,73 @@ describe('internal-plugin-calendar', () => {
             callback({data: {calendarMeetingExternal: {id: 'calendarId1'}}});
           }
         }),
-        off: sinon.spy()
+        off: sinon.spy(),
+      };
+      webex.internal.encryption = {
+        kms: {
+          createUnboundKeys: sinon.stub().resolves([{
+            uri: "kms://kms-us-int.wbx2.com/keys/xxxx-xxxx-xxxx-xxxx"
+          }])
+        },
+        encryptText: sinon.stub().resolves("encryptedText")
       };
     });
 
+    describe('Private API', () => {
+      describe('#prefetchEncryptionKey', () => {
+        it('waits for the ability to authorize before doing anything', () => {
+          webex.canAuthorize = false;
+
+          webex.internal.calendar.prefetchEncryptionKey();
+
+          assert.notCalled(webex.internal.encryption.kms.createUnboundKeys);
+
+          // Behaviour when the user can authorize is tested elsewhere, so just ensure it gets called again
+          const prefetchEncryptionKeyStub = sinon.stub(webex.internal.calendar, 'prefetchEncryptionKey');
+
+          webex.trigger('change:canAuthorize');
+
+          assert.calledOnce(prefetchEncryptionKeyStub);
+          assert.calledWith(prefetchEncryptionKeyStub);
+        });
+
+        it('does nothing when the current user is an unverified guest', () => {
+          webex.credentials.isUnverifiedGuest = true;
+
+          webex.internal.calendar.prefetchEncryptionKey();
+
+          assert.notCalled(webex.internal.encryption.kms.createUnboundKeys);
+        });
+
+        it('creates an encryption key when the current user can authorize', () => {
+          webex.internal.calendar.prefetchEncryptionKey();
+
+          assert.calledOnce(webex.internal.encryption.kms.createUnboundKeys);
+          assert.calledWith(webex.internal.encryption.kms.createUnboundKeys, {count: 1});
+        });
+      });
+
+      describe('#initialize', () => {
+        it('adds relevant handlers when webex is ready', () => {
+          const prefetchEncryptionKeyStub = sinon.stub(webex.internal.calendar, 'prefetchEncryptionKey');
+
+          assert.notCalled(prefetchEncryptionKeyStub);
+
+          // Initialize should have already run, so there should be an event handler already
+          webex.trigger('ready');
+
+          assert.calledOnce(prefetchEncryptionKeyStub);
+          assert.calledWith(prefetchEncryptionKeyStub);
+        });
+      });
+    });
+
     describe('Public Api Contract', () => {
       describe('#register()', () => {
         it('on calendar register call mercury registration', async () => {
           await webex.internal.calendar.register();
           assert.calledOnce(webex.internal.device.register);
-          assert.callCount(webex.internal.mercury.on, 5);
+          assert.callCount(webex.internal.mercury.on, 6);
           assert.equal(webex.internal.calendar.registered, true);
         });
         it('should trigger `calendar:register` event', async () => {
@@ -91,7 +154,7 @@ describe('internal-plugin-calendar', () => {
         it('should call `mercury.unregister` and `device.unregister`', async () => {
           await webex.internal.calendar.register();
           await webex.internal.calendar.unregister();
-          assert.callCount(webex.internal.mercury.off, 5);
+          assert.callCount(webex.internal.mercury.off, 6);
           assert.calledOnce(webex.internal.mercury.disconnect);
           assert.calledOnce(webex.internal.device.unregister);
         });
@@ -108,14 +171,25 @@ describe('internal-plugin-calendar', () => {
 
       describe('#syncCalendar()', () => {
         it('should sync from calendar service', async () => {
-          webex.request = sinon.stub().returns(Promise.resolve({body: {items: [{id: 'calendar1'}, {id: 'calendar2'}]}})); webex.request = sinon.stub().returns(
+          webex.request = sinon
+            .stub()
+            .returns(Promise.resolve({body: {items: [{id: 'calendar1'}, {id: 'calendar2'}]}}));
+          webex.request = sinon.stub().returns(
             Promise.resolve({
               body: {
                 items: [
-                  {id: 'calendar1', encryptedNotes: 'notes1', encryptedParticipants: ['participant1']},
-                  {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
-                ]
-              }
+                  {
+                    id: 'calendar1',
+                    encryptedNotes: 'notes1',
+                    encryptedParticipants: ['participant1'],
+                  },
+                  {
+                    id: 'calendar2',
+                    encryptedNotes: 'notes2',
+                    encryptedParticipants: ['participant2'],
+                  },
+                ],
+              },
             })
           );
           await webex.internal.calendar.syncCalendar({fromDate: 'xx-xx', toDate: 'xx-nn'});
@@ -123,7 +197,7 @@ describe('internal-plugin-calendar', () => {
             method: 'GET',
             service: 'calendar',
             resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
+            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
           assert.equal(webex.internal.calendar.getAll().length, 2);
           assert.equal(webex.internal.calendar.getAll()[0].id, 'calendar1');
@@ -136,10 +210,18 @@ describe('internal-plugin-calendar', () => {
             Promise.resolve({
               body: {
                 items: [
-                  {id: 'calendar1', encryptedNotes: 'notes1', encryptedParticipants: ['participant1']},
-                  {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
-                ]
-              }
+                  {
+                    id: 'calendar1',
+                    encryptedNotes: 'notes1',
+                    encryptedParticipants: ['participant1'],
+                  },
+                  {
+                    id: 'calendar2',
+                    encryptedNotes: 'notes2',
+                    encryptedParticipants: ['participant2'],
+                  },
+                ],
+              },
             })
           );
           const res = await webex.internal.calendar.list({fromDate: 'xx-xx', toDate: 'xx-nn'});
@@ -149,7 +231,7 @@ describe('internal-plugin-calendar', () => {
             method: 'GET',
             service: 'calendar',
             resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
+            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
         });
 
@@ -157,31 +239,27 @@ describe('internal-plugin-calendar', () => {
           const webexRequestStub = sinon.stub();
 
           // calendar list stub
-          webexRequestStub.withArgs({
-            method: 'GET',
-            service: 'calendar',
-            resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
-          }).returns(
-            Promise.resolve({
-              body: {
-                items: [
-                  {id: 'calendar1', encryptedParticipants: ['participant1']},
-                  {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
-                ]
-              }
+          webexRequestStub
+            .withArgs({
+              method: 'GET',
+              service: 'calendar',
+              resource: 'calendarEvents',
+              qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
             })
-          );
-          // getNotes stub
-          webexRequestStub.withArgs({
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`
-          }).returns(
-            Promise.resolve({
-              body: null
-            })
-          );
+            .returns(
+              Promise.resolve({
+                body: {
+                  items: [
+                    {id: 'calendar1', encryptedParticipants: ['participant1']},
+                    {
+                      id: 'calendar2',
+                      encryptedNotes: 'notes2',
+                      encryptedParticipants: ['participant2'],
+                    },
+                  ],
+                },
+              })
+            );
 
           // Assign webexRequestStub to webex.request
           webex.request = webexRequestStub;
@@ -190,19 +268,14 @@ describe('internal-plugin-calendar', () => {
 
           assert.equal(res.length, 2);
           assert.deepEqual(res, [
-            {id: 'calendar1', encryptedNotes: null, encryptedParticipants: ['participant1']},
-            {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
+            {id: 'calendar1', encryptedParticipants: ['participant1']},
+            {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']},
           ]);
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
             resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
-          });
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`
+            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
         });
 
@@ -210,33 +283,27 @@ describe('internal-plugin-calendar', () => {
           const webexRequestStub = sinon.stub();
 
           // calendar list stub
-          webexRequestStub.withArgs({
-            method: 'GET',
-            service: 'calendar',
-            resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
-          }).returns(
-            Promise.resolve({
-              body: {
-                items: [
-                  {id: 'calendar1', encryptedParticipants: ['participant1']},
-                  {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
-                ]
-              }
-            })
-          );
-          // getNotes stub
-          webexRequestStub.withArgs({
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`
-          }).returns(
-            Promise.resolve({
-              body: {
-                encryptedNotes: 'notes1'
-              }
+          webexRequestStub
+            .withArgs({
+              method: 'GET',
+              service: 'calendar',
+              resource: 'calendarEvents',
+              qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
             })
-          );
+            .returns(
+              Promise.resolve({
+                body: {
+                  items: [
+                    {id: 'calendar1', encryptedNotes: 'notes1', encryptedParticipants: ['participant1']},
+                    {
+                      id: 'calendar2',
+                      encryptedNotes: 'notes2',
+                      encryptedParticipants: ['participant2'],
+                    },
+                  ],
+                },
+              })
+            );
 
           // Assign webexRequestStub to webex.request
           webex.request = webexRequestStub;
@@ -246,18 +313,13 @@ describe('internal-plugin-calendar', () => {
           assert.equal(res.length, 2);
           assert.deepEqual(res, [
             {id: 'calendar1', encryptedNotes: 'notes1', encryptedParticipants: ['participant1']},
-            {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']}
+            {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']},
           ]);
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
             resource: 'calendarEvents',
-            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'}
-          });
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`
+            qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
         });
       });
@@ -269,8 +331,8 @@ describe('internal-plugin-calendar', () => {
           webex.request = sinon.stub().returns(
             Promise.resolve({
               body: {
-                encryptedNotes: 'notes1'
-              }
+                encryptedNotes: 'notes1',
+              },
             })
           );
 
@@ -280,30 +342,172 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa(id)}/notes`
+            resource: `calendarEvents/${base64.encode(id)}/notes`,
           });
         });
       });
 
       describe('#getParticipants()', () => {
-        const id = 'meetingId123';
+        const uri = 'participantsUrl';
 
         it('should fetch the meeting participants', async () => {
           webex.request = sinon.stub().returns(
             Promise.resolve({
               body: {
-                encryptedParticipants: ['participant1']
-              }
+                encryptedParticipants: ['participant1'],
+              },
             })
           );
 
-          const res = await webex.internal.calendar.getParticipants(id);
+          const res = await webex.internal.calendar.getParticipants(uri);
 
           assert.equal(res.body.encryptedParticipants.length, 1);
           assert.calledWith(webex.request, {
             method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa(id)}/participants`
+            uri,
+          });
+        });
+      });
+
+      describe('#getNotesByUrl()', () => {
+        const uri = 'notesUrl';
+
+        it('should fetch the meeting notes', async () => {
+          webex.request = sinon.stub().returns(
+            Promise.resolve({
+              body: {
+                encryptedParticipants: ['participant1'],
+              },
+            })
+          );
+
+          const res = await webex.internal.calendar.getNotesByUrl(uri);
+
+          assert.equal(res.body.encryptedParticipants.length, 1);
+          assert.calledWith(webex.request, {
+            method: 'GET',
+            uri,
+          });
+        });
+      });
+
+      describe("#getSchedulerData()", () => {
+        it("should fetch meeting calendar data", async () => {
+          const query = {
+            siteName: "scheduler01.dmz.webex.com",
+            clientMeetingId: "YWJjZGFiY2QtYWJjZC1hYmNkLWFiY2QtMDAwMDAwMDA"
+          };
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              encryptedSubject: "My Meeting 1",
+              schedulerPreferences: {
+                uiControlAttributes: {
+                  displayHostSaveMeetingTemplate: true
+                },
+                webexOptions: {
+                  sessionTypeId: 3
+                }
+              }
+            }
+          });
+
+          const res = await webex.internal.calendar.getSchedulerData(query);
+
+          expect(res.body.encryptedSubject).to.equal("My Meeting 1");
+          expect(res.body.schedulerPreferences.uiControlAttributes.displayHostSaveMeetingTemplate).to.be.true;
+          expect(res.body.schedulerPreferences.webexOptions.sessionTypeId).to.equal(3);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            service: "calendar",
+            resource: "schedulerData",
+            qs: {
+              siteName: query.siteName,
+              clientMeetingId: query.clientMeetingId
+            }
+          });
+        });
+      });
+
+      describe("#createCalendarEvent()", () => {
+        it("should create an calendar event", async () => {
+          const data = {
+            encryptionKeyUrl: "kms://kms-us-int.wbx2.com/keys/d1c14fc5-be10-4389-ae83-9521f92fbfd3",
+            notes: "This is Agenda",
+            subject: "My Meeting 1",
+            webexOptions: "{}"
+          };
+          const query = {};
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              meetingId: "abcdabcd-abcd-abcd-abcd-00000000",
+              globalMeetingId: "xxxx-xxxx-xxxx-xxxx"
+            }
+          });
+
+          const res = await webex.internal.calendar.createCalendarEvent(data);
+
+          expect(res.body.meetingId).to.equal("abcdabcd-abcd-abcd-abcd-00000000");
+          expect(res.body.globalMeetingId).to.equal("xxxx-xxxx-xxxx-xxxx");
+          assert.calledWith(webex.request, {
+            method: "POST",
+            service: "calendar",
+            body: data,
+            resource: "calendarEvents/sync",
+            qs: query
+          });
+        });
+      });
+
+      describe("#updateCalendarEvent()", () => {
+        it("should update a calendar event", async () => {
+          const id = "abcdabcd-abcd-abcd-abcd-00000000";
+          const data = {
+            encryptionKeyUrl: "kms://kms-us-int.wbx2.com/keys/d1c14fc5-be10-4389-ae83-9521f92fbfd3",
+            notes: "This is Agenda",
+            subject: "My Meeting 1",
+            webexOptions: "{}"
+          };
+          const query = {};
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              meetingId: "abcdabcd-abcd-abcd-abcd-00000000",
+              globalMeetingId: "xxxx-xxxx-xxxx-xxxx"
+            }
+          });
+
+          const res = await webex.internal.calendar.updateCalendarEvent(id, data);
+
+          expect(res.body.meetingId).to.equal("abcdabcd-abcd-abcd-abcd-00000000");
+          expect(res.body.globalMeetingId).to.equal("xxxx-xxxx-xxxx-xxxx");
+          assert.calledWith(webex.request, {
+            method: "PATCH",
+            service: "calendar",
+            body: data,
+            resource: `calendarEvents/${base64.encode(id)}/sync`,
+            qs: query
+          });
+        });
+      });
+
+      describe("#deleteCalendarEvent()", () => {
+        it("should delete a calendar event", async () => {
+          const id = "abcdabcd-abcd-abcd-abcd-00000000";
+          const query = {};
+
+          webex.request = sinon.stub().resolves({
+            body: {}
+          });
+
+          await webex.internal.calendar.deleteCalendarEvent(id, query);
+
+          assert.calledWith(webex.request, {
+            method: "DELETE",
+            service: "calendar",
+            resource: `calendarEvents/${base64.encode(id)}/sync`,
+            qs: query
           });
         });
       });

package/test/unit/spec/utils.js

@@ -5,7 +5,10 @@ import CalendarUtils from '../../../src/util';
 describe('Calendar utils', () => {
   describe('#calculateEndTime()', () => {
     it('return the end time for meeting', () => {
-      const result = CalendarUtils.calculateEndTime({start: '2020-02-21T18:57:00.000Z', durationMinutes: 30});
+      const result = CalendarUtils.calculateEndTime({
+        start: '2020-02-21T18:57:00.000Z',
+        durationMinutes: 30,
+      });
 
       assert.equal(new Date(result.endTime).toISOString(), '2020-02-21T19:27:00.000Z');
     });