@webex/internal-plugin-calendar 3.0.0-bnr.4 → 3.0.0

package/test/unit/spec/calendar.js

@@ -2,10 +2,10 @@
  * 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 {
@@ -48,6 +48,64 @@ describe('internal-plugin-calendar', () => {
         }),
         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"),
+        getKey: sinon.stub().resolves(undefined),
+      };
+    });
+
+    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', () => {
@@ -55,7 +113,7 @@ describe('internal-plugin-calendar', () => {
         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 () => {
@@ -97,7 +155,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);
         });
@@ -203,18 +261,6 @@ describe('internal-plugin-calendar', () => {
                 },
               })
             );
-          // getNotes stub
-          webexRequestStub
-            .withArgs({
-              method: 'GET',
-              service: 'calendar',
-              resource: `calendarEvents/${btoa('calendar1')}/notes`,
-            })
-            .returns(
-              Promise.resolve({
-                body: null,
-              })
-            );
 
           // Assign webexRequestStub to webex.request
           webex.request = webexRequestStub;
@@ -223,7 +269,7 @@ describe('internal-plugin-calendar', () => {
 
           assert.equal(res.length, 2);
           assert.deepEqual(res, [
-            {id: 'calendar1', encryptedNotes: null, encryptedParticipants: ['participant1']},
+            {id: 'calendar1', encryptedParticipants: ['participant1']},
             {id: 'calendar2', encryptedNotes: 'notes2', encryptedParticipants: ['participant2']},
           ]);
           assert.calledWith(webex.request, {
@@ -232,11 +278,6 @@ describe('internal-plugin-calendar', () => {
             resource: 'calendarEvents',
             qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`,
-          });
         });
 
         it('should fetch the calendar list and resolves with fetched encryptedNotes', async () => {
@@ -254,7 +295,7 @@ describe('internal-plugin-calendar', () => {
               Promise.resolve({
                 body: {
                   items: [
-                    {id: 'calendar1', encryptedParticipants: ['participant1']},
+                    {id: 'calendar1', encryptedNotes: 'notes1', encryptedParticipants: ['participant1']},
                     {
                       id: 'calendar2',
                       encryptedNotes: 'notes2',
@@ -264,20 +305,6 @@ describe('internal-plugin-calendar', () => {
                 },
               })
             );
-          // getNotes stub
-          webexRequestStub
-            .withArgs({
-              method: 'GET',
-              service: 'calendar',
-              resource: `calendarEvents/${btoa('calendar1')}/notes`,
-            })
-            .returns(
-              Promise.resolve({
-                body: {
-                  encryptedNotes: 'notes1',
-                },
-              })
-            );
 
           // Assign webexRequestStub to webex.request
           webex.request = webexRequestStub;
@@ -295,11 +322,6 @@ describe('internal-plugin-calendar', () => {
             resource: 'calendarEvents',
             qs: {fromDate: 'xx-xx', toDate: 'xx-nn'},
           });
-          assert.calledWith(webex.request, {
-            method: 'GET',
-            service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`,
-          });
         });
       });
 
@@ -321,13 +343,13 @@ 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(
@@ -338,13 +360,155 @@ describe('internal-plugin-calendar', () => {
             })
           );
 
-          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/dist/internal-plugin-calendar.d.ts

@@ -1,4 +0,0 @@
-declare const Calendar: any;
-export default Calendar;
-
-export { }

package/dist/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.34.4"
-    }
-  ]
-}

package/dist/types/calendar.d.ts

@@ -1,2 +0,0 @@
-export default Calendar;
-declare const Calendar: any;

package/dist/types/collection.d.ts

@@ -1,58 +0,0 @@
-export default CalendarCollection;
-declare namespace CalendarCollection {
-    export { CALENDAR as namespace };
-    export const items: {};
-    /**
-     * @param {String} id calendar ID
-     * @returns {Any} Calendar Item specifc to that id
-     * @private
-     * @memberof CalendarCollection
-     */
-    export function get(id: string): Any;
-    /**
-     * @param {String} key any key and the corresponding calendar Item
-     * @param {String} value any values corresponding to calendar item
-     * @returns {Any} returns whatever is being stuffed into the collection
-     * @private
-     * @memberof CalendarCollection
-     */
-    export function getBy(key: string, value: string): Any;
-    /**
-     * @param {Object} item CalendarObject passed to the collection
-     * @returns {Any} returns calender id whats get set
-     * @private
-     * @memberof CalendarCollection
-     */
-    export function set(item: any): Any;
-    /**
-     * resets all the values in the calendarcollection
-     * @returns {undefined}
-     * @private
-     * @memberof CalendarCollection
-     */
-    export function reset(): undefined;
-    /**
-     * @param {Id} id is the id for the calendar item to be removed
-     * @returns {Any} calendar item which got removed
-     * @private
-     * @memberof CalendarCollection
-     */
-    export function remove(id: Id): Any;
-    /**
-     * sets all the item passed to the collection
-     * @param {Array} items array of calendar items
-     * @private
-     * @returns {undefined}
-     * @memberof CalendarCollection
-     */
-    export function setAll(items: any[]): undefined;
-    /**
-     * gets all the calendar stored in the collection
-     * @param {Array} items array of calendar items
-     * @private
-     * @returns {Array} returns an array of calendar items
-     * @memberof CalendarCollection
-     */
-    export function getAll(): any[];
-}
-import { CALENDAR } from "./constants";

package/dist/types/config.d.ts

@@ -1,7 +0,0 @@
-declare namespace _default {
-    namespace calendar {
-        const fromDate: Date;
-        const toDate: Date;
-    }
-}
-export default _default;

package/dist/types/constants.d.ts

@@ -1,6 +0,0 @@
-export const CALENDAR_REGISTERED: "calendar:registered";
-export const CALENDAR_UNREGISTERED: "calendar:unregistered";
-export const CALENDAR_UPDATED: "calendar:update";
-export const CALENDAR_DELETE: "calendar:delete";
-export const CALENDAR_CREATE: "calendar:create";
-export const CALENDAR: "CALENDAR";

package/dist/types/index.d.ts

@@ -1 +0,0 @@
-export { default } from "./calendar";

package/dist/types/util.d.ts

@@ -1,15 +0,0 @@
-export default CalendarUtil;
-declare namespace CalendarUtil {
-    /**
-     * calculates the end time for meeting
-     * @param {Object} item the locus.host property
-     * @param {Object} item.start start time of the meeting
-     * @param {Object} item.duration duration of the meeting
-     * @returns {Object} end time of the meeting
-     * @memberof CalendarUtil
-     */
-    function calculateEndTime(item: {
-        start: any;
-        duration: any;
-    }): any;
-}