@webex/internal-plugin-calendar 3.0.0-beta.39 → 3.0.0-beta.391

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,63 @@ 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")
+      };
+    });
+
+    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 +112,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 +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);
         });
@@ -203,18 +260,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 +268,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 +277,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 +294,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 +304,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 +321,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 +342,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 +359,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
           });
         });
       });