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

package/src/calendar.encrypt.helper.js

@@ -0,0 +1,98 @@
+import {isArray} from 'lodash';
+
+const _encryptTextProp = (ctx, name, key, object) => {
+  if (!object[name]) {
+    return Promise.resolve();
+  }
+
+  return ctx.webex.internal.encryption
+    .encryptText(key.uri || key, object[name])
+    .then((ciphertext) => {
+      object[name] = ciphertext;
+    });
+};
+
+const _encryptCalendarEventPayload = (data, ctx) => {
+  Object.assign(data, {encryptionKeyUrl: ctx.encryptionKeyUrl});
+
+  const encryptedAttendees = data.attendees
+    ? data.attendees.map((attendee) =>
+        Promise.all([
+          _encryptTextProp(ctx, 'displayName', data.encryptionKeyUrl, attendee),
+          _encryptTextProp(ctx, 'email', data.encryptionKeyUrl, attendee),
+        ])
+      )
+    : [];
+
+  return Promise.all(
+    [
+      _encryptTextProp(ctx, 'subject', data.encryptionKeyUrl, data),
+      _encryptTextProp(ctx, 'notes', data.encryptionKeyUrl, data),
+      _encryptTextProp(ctx, 'webexOptions', data.encryptionKeyUrl, data),
+    ].concat([encryptedAttendees])
+  );
+};
+
+const _encryptFreeBusyPayload = (data, ctx) => {
+  Object.assign(data, {encryptionKeyUrl: ctx.encryptionKeyUrl});
+
+  const promises = [];
+  if (data.emails && Array.isArray(data.emails)) {
+    data.emails.map((item, index) =>
+      promises.push(
+        ctx.webex.internal.encryption
+          .encryptText(data.encryptionKeyUrl, item)
+          .then((encryptText) => {
+            data.emails[index] = encryptText;
+          })
+      )
+    );
+  }
+
+  return Promise.all(promises);
+};
+
+const EncryptHelper = {
+  /**
+   * Encrypt create / update calendar event request payload
+   * @param {object} [ctx] context
+   * @param {object} [data] meeting payload data
+   * @returns {Promise} Resolves with encrypted request payload
+   * */
+  encryptCalendarEventRequest: (ctx, data) => {
+    if (ctx.encryptionKeyUrl) {
+      return _encryptCalendarEventPayload(data, ctx);
+    }
+
+    return ctx.webex.internal.encryption.kms.createUnboundKeys({count: 1}).then((keys) => {
+      const key = isArray(keys) ? keys[0] : keys;
+      ctx.encryptionKeyUrl = key.uri;
+
+      return _encryptCalendarEventPayload(data, ctx);
+    });
+  },
+  /**
+   * Encrypt free-busy request payload, if request payload only includes the sensitive data, like email, need to encrypt these reqeust parameters, and playload includes encrypt url.
+   * Otherwise, don't encrypt playload and without encrypt url,Due to calendar serivce will vaild both encrypt url and sensitive that are both present. if not, will return 400 bad reqeust to caller.
+   * @param {object} [ctx] context
+   * @param {object} [data] free busy payload data
+   * @returns {Promise} Resolves with encrypted request payload
+   * */
+  encryptFreeBusyRequest: (ctx, data) => {
+    if (!data.emails || !Array.isArray(data.emails)) {
+      return Promise.resolve();
+    }
+    if (ctx.encryptionKeyUrl) {
+      return _encryptFreeBusyPayload(data, ctx);
+    }
+
+    return ctx.webex.internal.encryption.kms.createUnboundKeys({count: 1}).then((keys) => {
+      const key = isArray(keys) ? keys[0] : keys;
+      ctx.encryptionKeyUrl = key.uri;
+
+      return _encryptFreeBusyPayload(data, ctx);
+    });
+  },
+};
+
+export default EncryptHelper;

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,65 @@ const Calendar = WebexPlugin.extend({
    */
   registered: false,
 
+  /**
+   * Cache all rpc event request locally
+   * */
+  rpcEventRequests: [],
+
+  /**
+   * Cache KMS encryptionKeyUrl
+   * */
+  encryptionKeyUrl: null,
+
+  /**
+   * Pre-fetch a KMS encryption key url to improve performance.
+   * Waits for the user to be authorized and skips if an unverified guest.
+   * @private
+   * @returns {void}
+   */
+  prefetchEncryptionKey() {
+    if (!this.webex.canAuthorize) {
+      this.listenToOnce(this.webex, 'change:canAuthorize', () => {
+        this.prefetchEncryptionKey();
+      });
+
+      return;
+    }
+
+    if (this.webex.credentials.isUnverifiedGuest) {
+      return;
+    }
+
+    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');
+        });
+    });
+  },
+
+  /**
+   * 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.
+   * @private
+   * @returns {void}
+   */
+  initialize() {
+    // Used to perform actions after webex is fully qualified and ready for
+    // operation.
+    this.listenToOnce(this.webex, 'ready', () => {
+      this.prefetchEncryptionKey();
+    });
+  },
+
   /**
    * Explicitly sets up the calendar plugin by registering
    * the device, connecting to mercury, and listening for calendar events.
@@ -148,6 +210,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 +226,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 +265,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
@@ -245,15 +337,26 @@ const Calendar = WebexPlugin.extend({
   },
 
   /**
-   * Retrieves an array of meeting participants for the meeting id
-   * @param {String} id
+   * Retrieves an array of meeting participants for the meeting participantsUrl
+   * @param {String} participantsUrl
    * @returns {Promise} Resolves with an object of meeting participants
    */
-  getParticipants(id) {
+  getParticipants(participantsUrl) {
     return this.request({
       method: 'GET',
-      service: 'calendar',
-      resource: `calendarEvents/${btoa(id)}/participants`,
+      uri: participantsUrl,
+    });
+  },
+
+  /**
+   * get meeting notes using notesUrl from meeting object.
+   * @param {String} notesUrl
+   * @returns {Promise} Resolves with an object of meeting notes
+   */
+  getNotesByUrl(notesUrl) {
+    return this.request({
+      method: 'GET',
+      uri: notesUrl,
     });
   },
 
@@ -266,7 +369,7 @@ const Calendar = WebexPlugin.extend({
     return this.request({
       method: 'GET',
       service: 'calendar',
-      resource: `calendarEvents/${btoa(id)}/notes`,
+      resource: `calendarEvents/${base64.encode(id)}/notes`,
     });
   },
 
@@ -292,17 +395,9 @@ const Calendar = WebexPlugin.extend({
         const promises = [];
 
         meetingObjects.forEach((meeting) => {
-          if (!meeting.encryptedNotes) {
-            promises.push(
-              this.getNotes(meeting.id).then((notesResponse) => {
-                meeting.encryptedNotes = notesResponse.body && notesResponse.body.encryptedNotes;
-              })
-            );
-          }
-
           if (!meeting.encryptedParticipants) {
             promises.push(
-              this.getParticipants(meeting.id).then((notesResponse) => {
+              this.getParticipants(meeting.participantsUrl).then((notesResponse) => {
                 meeting.encryptedParticipants = notesResponse.body.encryptedParticipants;
               })
             );
@@ -312,6 +407,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);
+    });
+  });
+});