@webex/internal-plugin-calendar 3.0.0-beta.215 → 3.0.0-beta.217

package/src/calendar.js

@@ -41,8 +41,8 @@
  * @instance
  * @memberof Calendar
  */
-
-import btoa from 'btoa';
+import {isArray} from 'lodash';
+import {base64} from '@webex/common';
 import {WebexPlugin} from '@webex/webex-core';
 
 import CalendarCollection from './collection';
@@ -54,6 +54,9 @@ import {
   CALENDAR_UPDATED,
 } from './constants';
 
+import EncryptHelper from './calendar.encrypt.helper';
+import DecryptHelper from './calendar.decrypt.helper';
+
 const Calendar = WebexPlugin.extend({
   namespace: 'Calendar',
 
@@ -65,6 +68,43 @@ const Calendar = WebexPlugin.extend({
    */
   registered: false,
 
+  /**
+   * Cache all rpc event request locally
+   * */
+  rpcEventRequests: [],
+
+  /**
+   * Cache KMS encryptionKeyUrl
+   * */
+  encryptionKeyUrl: null,
+
+  /**
+   * WebexPlugin initialize method. This triggers once Webex has completed its
+   * initialization workflow.
+   *
+   * If the plugin is meant to perform startup actions, place them in this
+   * `initialize()` method instead of the `constructor()` method.
+   * @returns {void}
+   */
+  initialize() {
+    // Used to perform actions after webex is fully qualified and ready for
+    // operation.
+    this.listenToOnce(this.webex, 'ready', () => {
+      // Pre-fetch a KMS encryption key url to improve performance
+      this.webex.internal.encryption.kms.createUnboundKeys({count: 1}).then((keys) => {
+        const key = isArray(keys) ? keys[0] : keys;
+        this.encryptionKeyUrl = key ? key.uri : null;
+        this.logger.info('calendar->bind a KMS encryption key url');
+        this.webex.internal.encryption
+          .getKey(this.encryptionKeyUrl, {onBehalfOf: null})
+          .then((retrievedKey) => {
+            this.encryptionKeyUrl = retrievedKey ? retrievedKey.uri : null;
+            this.logger.info('calendar->retrieve the KMS encryption key url and cache it');
+          });
+      });
+    });
+  },
+
   /**
    * Explicitly sets up the calendar plugin by registering
    * the device, connecting to mercury, and listening for calendar events.
@@ -148,6 +188,9 @@ const Calendar = WebexPlugin.extend({
     this.webex.internal.mercury.on('event:calendar.meeting.delete', (envelope) => {
       this._handleDelete(envelope.data);
     });
+    this.webex.internal.mercury.on('event:calendar.free_busy', (envelope) => {
+      this._handleFreeBusy(envelope.data);
+    });
   },
 
   /**
@@ -161,6 +204,7 @@ const Calendar = WebexPlugin.extend({
     this.webex.internal.mercury.off('event:calendar.meeting.update');
     this.webex.internal.mercury.off('event:calendar.meeting.update.minimal');
     this.webex.internal.mercury.off('event:calendar.meeting.delete');
+    this.webex.internal.mercury.off('event:calendar.free_busy');
   },
 
   /**
@@ -199,6 +243,32 @@ const Calendar = WebexPlugin.extend({
     this.trigger(CALENDAR_DELETE, item);
   },
 
+  /**
+   * handles free_busy events
+   * @param {Object} data
+   * @returns {undefined}
+   * @private
+   */
+  _handleFreeBusy(data) {
+    DecryptHelper.decryptFreeBusyResponse(this, data).then(() => {
+      let response = {};
+      if (data && data.calendarFreeBusyScheduleResponse) {
+        response = data.calendarFreeBusyScheduleResponse;
+      }
+      if (response && response.requestId && response.requestId in this.rpcEventRequests) {
+        this.logger.log(
+          `webex.internal.calendar - receive requests, requestId: ${response.requestId}`
+        );
+        delete response.encryptionKeyUrl;
+        const {resolve} = this.rpcEventRequests[response.requestId];
+        resolve(response);
+        delete this.rpcEventRequests[response.requestId];
+      } else {
+        this.logger.log('webex.internal.calendar - receive other requests.');
+      }
+    });
+  },
+
   /**
    * Retrieves a collection of calendars based on the request parameters
    * Defaults to 1 day before and 7 days ahead
@@ -277,7 +347,7 @@ const Calendar = WebexPlugin.extend({
     return this.request({
       method: 'GET',
       service: 'calendar',
-      resource: `calendarEvents/${btoa(id)}/notes`,
+      resource: `calendarEvents/${base64.encode(id)}/notes`,
     });
   },
 
@@ -315,6 +385,117 @@ const Calendar = WebexPlugin.extend({
         return Promise.all(promises).then(() => meetingObjects);
       });
   },
+
+  /**
+   * Create calendar event
+   * @param {object} [data] meeting payload data
+   * @param {object} [query] the query parameters for specific usage
+   * @returns {Promise} Resolves with creating calendar event response
+   * */
+  createCalendarEvent(data, query) {
+    return EncryptHelper.encryptCalendarEventRequest(this, data).then(() =>
+      this.request({
+        method: 'POST',
+        service: 'calendar',
+        body: data,
+        resource: 'calendarEvents/sync',
+        qs: query || {},
+      })
+    );
+  },
+
+  /**
+   * Update calendar event
+   * @param {string} [id] calendar event id
+   * @param {object} [data] meeting payload data
+   * @param {object} [query] the query parameters for specific usage
+   * @returns {Promise} Resolves with updating calendar event response
+   * */
+  updateCalendarEvent(id, data, query) {
+    return EncryptHelper.encryptCalendarEventRequest(this, data).then(() =>
+      this.request({
+        method: 'PATCH',
+        service: 'calendar',
+        body: data,
+        resource: `calendarEvents/${base64.encode(id)}/sync`,
+        qs: query || {},
+      })
+    );
+  },
+
+  /**
+   * Delete calendar event
+   * @param {string} [id] calendar event id
+   * @param {object} [query] the query parameters for specific usage
+   * @returns {Promise} Resolves with deleting calendar event response
+   * */
+  deleteCalendarEvent(id, query) {
+    return this.request({
+      method: 'DELETE',
+      service: 'calendar',
+      resource: `calendarEvents/${base64.encode(id)}/sync`,
+      qs: query || {},
+    });
+  },
+
+  /**
+   * @typedef QuerySchedulerDataOptions
+   * @param {string} [siteName] it is site full url, must have. Example: ccctest.dmz.webex.com
+   * @param {string} [id] it is seriesOrOccurrenceId. If present, the series/occurrence meeting ID to fetch data for.
+   *                      Example: 040000008200E00074C5B7101A82E008000000004A99F11A0841D9010000000000000000100000009EE499D4A71C1A46B51494C70EC7BFE5
+   * @param {string} [clientMeetingId] If present, the client meeting UUID to fetch data for.
+   *                      Example: 7f318aa9-887c-6e94-802a-8dc8e6eb1a0a
+   * @param {string} [scheduleTemplateId] it template id.
+   * @param {string} [sessionTypeId] it session type id.
+   * @param {string} [organizerCIUserId] required in schedule-on-behalf case. It is the organizer's CI UUID.
+   * @param {boolean} [usmPreference]
+   * @param {string} [webexMeetingId] webex side meeting UUID
+   * @param {string} [eventId] event ID.
+   * @param {string} [icalUid] icalendar UUID.
+   * @param {string} [thirdPartyType] third part type, such as: Microsoft
+   */
+  /**
+   * Get scheduler data from calendar service
+   * @param {QuerySchedulerDataOptions} [query] the command parameters for fetching scheduler data.
+   * @returns {Promise} Resolves with a decrypted scheduler data
+   * */
+  getSchedulerData(query) {
+    return this.request({
+      method: 'GET',
+      service: 'calendar',
+      resource: 'schedulerData',
+      qs: query || {},
+    }).then((response) => {
+      return DecryptHelper.decryptSchedulerDataResponse(this, response.body).then(() => response);
+    });
+  },
+
+  /**
+   * Get free busy status from calendar service
+   * @param {Object} [data] the command parameters for fetching free busy status.
+   * @param {object} [query] the query parameters for specific usage
+   * @returns {Promise} Resolves with a decrypted response
+   * */
+  getFreeBusy(data, query) {
+    return EncryptHelper.encryptFreeBusyRequest(this, data)
+      .then(() => {
+        return this.request({
+          method: 'POST',
+          service: 'calendar',
+          body: data,
+          resource: 'freebusy',
+          qs: query || {},
+        });
+      })
+      .then(() => {
+        return new Promise((resolve, reject) => {
+          this.rpcEventRequests[data.requestId] = {resolve, reject};
+        });
+      })
+      .catch((error) => {
+        throw error;
+      });
+  },
 });
 
 export default Calendar;

package/src/index.js

@@ -20,7 +20,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeetingNotes',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.encryptedNotes'));
+          return Promise.resolve(
+            has(response, 'body.encryptedNotes') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);
@@ -30,7 +38,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeetingParticipants',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.encryptedParticipants'));
+          return Promise.resolve(
+            has(response, 'body.encryptedParticipants') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);
@@ -50,7 +66,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeeting',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.seriesId'));
+          return Promise.resolve(
+            has(response, 'body.seriesId') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);

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,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,14 @@ 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('Public Api Contract', () => {
@@ -55,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 () => {
@@ -97,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);
         });
@@ -285,7 +293,7 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa(id)}/notes`,
+            resource: `calendarEvents/${base64.encode(id)}/notes`,
           });
         });
       });
@@ -333,6 +341,127 @@ describe('internal-plugin-calendar', () => {
           });
         });
       });
+
+      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
+          });
+        });
+      });
     });
   });
 });