@webex/internal-plugin-calendar 3.0.0-beta.3 → 3.0.0-beta.300

package/test/unit/spec/calendar.decrypt.helper.js

@@ -0,0 +1,145 @@
+import sinon from "sinon";
+import { expect } from "@webex/test-helper-chai";
+import DecryptHelper from "@webex/internal-plugin-calendar/src/calendar.decrypt.helper";
+
+describe("internal-plugin-calendar", () => {
+  describe("DecryptHelper", () => {
+    let ctx;
+    let encryptedSchedulerData;
+    let encryptedFreeBusyData;
+
+    beforeEach(() => {
+      ctx = {
+        webex: {
+          internal: {
+            encryption: {
+              decryptText: sinon.stub()
+            }
+          }
+        }
+      };
+
+      encryptedSchedulerData = {
+        encryptionKeyUrl: "http://example.com/encryption-key",
+        encryptedSubject: "some encrypted subject",
+        encryptedLocation: "some encrypted location",
+        encryptedNotes: "some encrypted notes",
+        encryptedParticipants: [
+          {
+            encryptedEmailAddress: "some encrypted email address",
+            encryptedName: "some encrypted name"
+          },
+          {
+            encryptedEmailAddress: "another encrypted email address",
+            encryptedName: "another encrypted name"
+          }
+        ],
+        encryptedScheduleFor: {
+          "user1@example.com": {
+            encryptedEmail: "some encrypted email address",
+            encryptedDisplayName: "some encrypted display name"
+          },
+          "user2@example.com": {
+            encryptedEmail: "another encrypted email address",
+            encryptedDisplayName: "another encrypted display name"
+          }
+        },
+        meetingJoinInfo: {
+          meetingJoinURI: "some encrypted meeting join URI",
+          meetingJoinURL: "some encrypted meeting join URL"
+        },
+        encryptedOrganizer: {
+          encryptedEmailAddress: "some encrypted email address",
+          encryptedName: "some encrypted name"
+        },
+        webexURI: "some encrypted webex URI",
+        webexURL: "some encrypted webex URL",
+        spaceMeetURL: "some encrypted space meet URL",
+        spaceURI: "some encrypted space URI",
+        spaceURL: "some encrypted space URL"
+      };
+
+      encryptedFreeBusyData = {
+        calendarFreeBusyScheduleResponse: {
+          encryptionKeyUrl: "https://encryption.key/url",
+          calendarFreeBusyItems: [
+            {
+              email: "encrypted-email"
+            }
+          ]
+        }
+      };
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it("#decryptSchedulerDataResponse - should resolve with undefined if data is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptSchedulerDataResponse(ctx, undefined);
+      expect(decryptedData).to.be.undefined;
+    });
+
+    it("#decryptSchedulerDataResponse - should resolve with undefined if data.encryptionKeyUrl is undefined", async () => {
+      encryptedSchedulerData.encryptionKeyUrl = undefined;
+      const decryptedData = await DecryptHelper.decryptSchedulerDataResponse(ctx, encryptedSchedulerData);
+      expect(decryptedData).to.be.undefined;
+    });
+
+    describe("#decryptSchedulerDataResponse - should replace encrypted data with decrypted data in response", () => {
+      it("should decrypt scheduler data response correctly", async () => {
+        // Stub the decryption method to return the plaintext value.
+        const expectedCiphertext = "some decrypted text for testing";
+
+        ctx.webex.internal.encryption.decryptText.callsFake((key, ciphertext) => Promise.resolve(expectedCiphertext));
+
+        // Decrypt the data.
+        await DecryptHelper.decryptSchedulerDataResponse(ctx, encryptedSchedulerData);
+
+        // Check that all encrypted properties were decrypted correctly.
+        expect(encryptedSchedulerData.encryptedSubject).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedLocation).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedNotes).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedParticipants[0].encryptedEmailAddress).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedParticipants[0].encryptedName).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedScheduleFor["user1@example.com"].encryptedEmail).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedScheduleFor["user1@example.com"].encryptedDisplayName).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.meetingJoinInfo.meetingJoinURI).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.meetingJoinInfo.meetingJoinURL).to.equal(expectedCiphertext);
+
+        expect(encryptedSchedulerData.encryptedOrganizer.encryptedEmailAddress).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.encryptedOrganizer.encryptedName).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.webexURI).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.webexURL).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.spaceMeetURL).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.spaceURI).to.equal(expectedCiphertext);
+        expect(encryptedSchedulerData.spaceURL).to.equal(expectedCiphertext);
+      });
+    });
+
+    it("#decryptFreeBusyResponse - should resolve with undefined if data is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptFreeBusyResponse(ctx, undefined);
+      expect(decryptedData).to.be.undefined;
+    });
+
+    it("#decryptFreeBusyResponse - should resolve with undefined if data.calendarFreeBusyScheduleResponse is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptFreeBusyResponse(ctx, {});
+      expect(decryptedData).to.be.undefined;
+    });
+
+    it("#decryptFreeBusyResponse - should resolve with undefined if data.calendarFreeBusyScheduleResponse.encryptionKeyUrl is undefined", async () => {
+      encryptedFreeBusyData.calendarFreeBusyScheduleResponse.encryptionKeyUrl = undefined;
+      const decryptedData = await DecryptHelper.decryptFreeBusyResponse(ctx, encryptedFreeBusyData);
+      expect(decryptedData).to.be.undefined;
+    });
+
+    it("#decryptFreeBusyResponse - should replace encrypted email with decrypted email in calendarFreeBusyItems", async () => {
+      const decryptTextStub = ctx.webex.internal.encryption.decryptText;
+      decryptTextStub.resolves("decrypted-email");
+
+      await DecryptHelper.decryptFreeBusyResponse(ctx, encryptedFreeBusyData);
+
+      expect(encryptedFreeBusyData.calendarFreeBusyScheduleResponse.calendarFreeBusyItems[0].email).to.equal("decrypted-email");
+    });
+  });
+});

package/test/unit/spec/calendar.encrypt.helper.js

@@ -0,0 +1,52 @@
+import sinon from 'sinon';
+import {expect} from '@webex/test-helper-chai';
+import EncryptHelper from '@webex/internal-plugin-calendar/src/calendar.encrypt.helper';
+describe('internal-plugin-calendar', () => {
+  describe('encryptHelper', () => {
+    let ctx;
+    beforeEach(() => {
+      ctx = {
+        encryptionKeyUrl: 'http://example.com/encryption-key',
+        webex: {
+          internal: {
+            encryption: {
+              encryptText: sinon.stub(),
+            },
+          },
+        },
+      };
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('#encryptFreebusyRequestData with emails should ', async () => {
+      const freeBusyRequest = {
+        start: '20230712T10:20:00Z',
+        end: '20230712T20:20:00Z',
+        emails: ['test@webex.com'],
+      };
+      const expectedCiphertext = 'some encrpty data';
+      ctx.webex.internal.encryption.encryptText.callsFake((key, ciphertext) =>
+        Promise.resolve(expectedCiphertext)
+      );
+      await EncryptHelper.encryptFreeBusyRequest(ctx, freeBusyRequest);
+      expect(freeBusyRequest.emails[0]).to.be.equal(expectedCiphertext);
+    });
+
+    it('#encryptFreebusyRequestData not include emails, but include ids- should b', async () => {
+      const freeBusyRequest = {
+        start: '20230712T10:20:00Z',
+        end: '20230712T20:20:00Z',
+        userIds: ['91aee1231'],
+      };
+      const expectedCiphertext = '91aee1231';
+      ctx.webex.internal.encryption.encryptText.callsFake((key, ciphertext) =>
+        Promise.resolve(expectedCiphertext)
+      );
+      await EncryptHelper.encryptFreeBusyRequest(ctx, freeBusyRequest);
+      expect(freeBusyRequest.userIds[0]).to.equal(expectedCiphertext);
+    });
+  });
+});

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,7 +46,15 @@ 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")
       };
     });
 
@@ -49,7 +63,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 () => {
@@ -91,7 +105,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 +122,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 +148,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 +161,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 +182,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 +190,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: null
+          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'],
+                    },
+                  ],
+                },
+              })
+            );
 
           // Assign webexRequestStub to webex.request
           webex.request = webexRequestStub;
@@ -190,19 +219,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 +234,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 +264,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 +282,8 @@ describe('internal-plugin-calendar', () => {
           webex.request = sinon.stub().returns(
             Promise.resolve({
               body: {
-                encryptedNotes: 'notes1'
-              }
+                encryptedNotes: 'notes1',
+              },
             })
           );
 
@@ -280,30 +293,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
           });
         });
       });