Files
cal.diy/packages/app-store/googlecalendar/lib/__tests__/CalendarService.test.ts
T

1771 lines
56 KiB
TypeScript

import prismock from "../../../../../tests/libs/__mocks__/prisma";
import oAuthManagerMock, {
defaultMockOAuthManager,
setFullMockOAuthManagerRequest,
} from "../../../tests/__mocks__/OAuthManager";
import "../__mocks__/features.repository";
import "../__mocks__/getGoogleAppKeys";
import {
calendarMock,
adminMock,
setLastCreatedJWT,
setCredentialsMock,
setLastCreatedOAuth2Client,
freebusyQueryMock,
calendarListMock,
} from "../__mocks__/googleapis";
import { expect, test, beforeEach, vi, describe } from "vitest";
import "vitest-fetch-mock";
import { CalendarCache } from "@calcom/features/calendar-cache/calendar-cache";
import { getTimeMax, getTimeMin } from "@calcom/features/calendar-cache/lib/datesForCache";
import logger from "@calcom/lib/logger";
import { safeStringify } from "@calcom/lib/safeStringify";
import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
import CalendarService from "../CalendarService";
import {
createMockJWTInstance,
createInMemoryDelegationCredentialForCalendarService,
defaultDelegatedCredential,
createCredentialForCalendarService,
createInMemoryCredential,
} from "./utils";
const log = logger.getSubLogger({ prefix: ["CalendarService.test"] });
async function expectCacheToBeSet({
credentialId,
itemsInKey,
}: {
credentialId: number;
itemsInKey: { id: string }[];
}) {
const caches = await prismock.calendarCache.findMany({
where: {
credentialId,
},
});
expect(caches).toHaveLength(1);
expect(JSON.parse(caches[0].key)).toEqual(
expect.objectContaining({
items: itemsInKey,
})
);
}
async function createSelectedCalendarForDelegationCredential(data: {
userId: number;
credentialId: number | null;
delegationCredentialId: string;
externalId: string;
integration: string;
googleChannelId: string | null;
googleChannelKind: string | null;
googleChannelResourceId: string | null;
googleChannelResourceUri: string | null;
googleChannelExpiration: string | null;
}) {
if (!data.delegationCredentialId) {
throw new Error("delegationCredentialId is required");
}
return await prismock.selectedCalendar.create({
data: {
...data,
},
});
}
/**
* The flow that sets CalendarCache must use CredentialForCalendarCache
*/
async function createDelegationCredentialForCalendarCache({
user,
delegatedTo,
delegationCredentialId,
}: {
user?: { email: string } | null;
delegatedTo?: typeof defaultDelegatedCredential;
delegationCredentialId: string;
}) {
delegatedTo = delegatedTo || defaultDelegatedCredential;
const credentialInDb = await createCredentialForCalendarService({
user: user || {
email: "[email protected]",
},
});
return {
...createInMemoryCredential({
userId: credentialInDb.userId!,
delegationCredentialId,
delegatedTo,
}),
...credentialInDb,
};
}
const testSelectedCalendar = {
userId: 1,
integration: "google_calendar",
externalId: "[email protected]",
};
const calendarCacheHelpers = {
FUTURE_EXPIRATION_DATE: new Date(Date.now() + 100000000),
getDatePair: () => {
// Keep it small to not go to next month
const timeDiffInMinutes = 1;
const dateFrom = new Date(Date.now()).toISOString();
const dateTo = new Date(Date.now() + timeDiffInMinutes * 60 * 1000).toISOString();
return { dateFrom, dateTo, minDateFrom: getTimeMin(dateFrom), maxDateTo: getTimeMax(dateTo) };
},
setCache: async ({
credentialId,
key,
value,
userId,
expiresAt,
}: {
credentialId: number;
key: string;
value: string;
userId: number | null;
expiresAt: Date;
}) => {
log.info("Setting Calendar Cache", safeStringify({ key, value, expiresAt, credentialId, userId }));
await prismock.calendarCache.create({
data: {
key,
value,
expiresAt,
credentialId,
userId,
},
});
},
setRegularCredentialCache: async ({
credentialId,
userId,
key,
value,
expiresAt,
}: {
credentialId: number;
userId: number;
key: string;
value: string;
expiresAt: Date;
}) => {
await calendarCacheHelpers.setCache({
credentialId,
key,
value,
userId,
expiresAt,
});
},
};
function expectGoogleSubscriptionToHaveOccurredAndClearMock({ calendarId }: { calendarId: string }) {
expect(calendarMock.calendar_v3.Calendar().events.watch).toHaveBeenCalledTimes(1);
expect(calendarMock.calendar_v3.Calendar().events.watch).toHaveBeenCalledWith(
expect.objectContaining({
calendarId,
requestBody: expect.objectContaining({
type: "web_hook",
token: process.env.GOOGLE_WEBHOOK_TOKEN,
}),
})
);
calendarMock.calendar_v3.Calendar().events.watch.mockClear();
}
function expectGoogleSubscriptionToNotHaveOccurredAndClearMock() {
expect(calendarMock.calendar_v3.Calendar().events.watch).not.toHaveBeenCalled();
calendarMock.calendar_v3.Calendar().events.watch.mockClear();
}
function expectGoogleUnsubscriptionToHaveOccurredAndClearMock(
channels: {
resourceId: string;
channelId: string;
}[]
) {
expect(calendarMock.calendar_v3.Calendar().channels.stop).toHaveBeenCalledTimes(1);
channels.forEach((channel) => {
expect(calendarMock.calendar_v3.Calendar().channels.stop).toHaveBeenCalledWith({
requestBody: {
resourceId: channel.resourceId,
id: channel.channelId,
},
});
});
calendarMock.calendar_v3.Calendar().channels.stop.mockClear();
}
function expectGoogleUnsubscriptionToNotHaveOccurredAndClearMock() {
expect(calendarMock.calendar_v3.Calendar().channels.stop).not.toHaveBeenCalled();
calendarMock.calendar_v3.Calendar().channels.stop.mockClear();
}
async function expectSelectedCalendarToHaveGoogleChannelProps(
id: string,
googleChannelProps: {
googleChannelId: string;
googleChannelKind: string;
googleChannelResourceId: string;
googleChannelResourceUri: string;
googleChannelExpiration: string;
}
) {
const selectedCalendar = await SelectedCalendarRepository.findById(id);
expect(selectedCalendar).toEqual(expect.objectContaining(googleChannelProps));
}
async function expectSelectedCalendarToNotHaveGoogleChannelProps(selectedCalendarId: string) {
const selectedCalendar = await SelectedCalendarRepository.findFirst({
where: {
id: selectedCalendarId,
},
});
expect(selectedCalendar).toEqual(
expect.objectContaining({
googleChannelId: null,
googleChannelKind: null,
googleChannelResourceId: null,
googleChannelResourceUri: null,
googleChannelExpiration: null,
})
);
}
beforeEach(() => {
vi.clearAllMocks();
setCredentialsMock.mockClear();
oAuthManagerMock.OAuthManager = defaultMockOAuthManager;
calendarMock.calendar_v3.Calendar.mockClear();
adminMock.admin_directory_v1.Admin.mockClear();
setLastCreatedJWT(null);
setLastCreatedOAuth2Client(null);
createMockJWTInstance({});
});
describe("Calendar Cache", () => {
test("Calendar Cache is being read on cache HIT", async () => {
const credentialInDb1 = await createCredentialForCalendarService();
const dateFrom1 = new Date().toISOString();
const dateTo1 = new Date().toISOString();
// Create cache
const calendarCache = await CalendarCache.init(null);
await calendarCache.upsertCachedAvailability({
credentialId: credentialInDb1.id,
userId: credentialInDb1.userId,
args: {
timeMin: getTimeMin(dateFrom1),
timeMax: getTimeMax(dateTo1),
items: [{ id: testSelectedCalendar.externalId }],
},
value: JSON.parse(
JSON.stringify({
calendars: [
{
busy: [
{
start: "2023-12-01T18:00:00Z",
end: "2023-12-01T19:00:00Z",
},
],
},
],
})
),
});
oAuthManagerMock.OAuthManager = defaultMockOAuthManager;
const calendarService = new CalendarService(credentialInDb1);
// Test cache hit
const data = await calendarService.getAvailability(dateFrom1, dateTo1, [testSelectedCalendar]);
expect(data).toEqual([
{
start: "2023-12-01T18:00:00Z",
end: "2023-12-01T19:00:00Z",
},
]);
});
test("Cache HIT: Should avoid Google API calls when cache is available", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
const dateFrom = new Date().toISOString();
const dateTo = new Date().toISOString();
// Set up cache with test data
const calendarCache = await CalendarCache.init(null);
await calendarCache.upsertCachedAvailability({
credentialId: credentialInDb.id,
userId: credentialInDb.userId,
args: {
timeMin: getTimeMin(dateFrom),
timeMax: getTimeMax(dateTo),
items: [{ id: testSelectedCalendar.externalId }],
},
value: {
calendars: {
[testSelectedCalendar.externalId]: {
busy: [
{
start: "2023-12-01T18:00:00Z",
end: "2023-12-01T19:00:00Z",
},
],
},
},
},
});
// Spy on Google API methods that should NOT be called on cache hit
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
const getAllCalendarsSpy = vi.spyOn(calendarService, "getAllCalendars");
const fetchAvailabilitySpy = vi.spyOn(calendarService, "fetchAvailability");
// Call getAvailability with selected calendars (should hit cache)
const result = await calendarService.getAvailability(dateFrom, dateTo, [testSelectedCalendar], true);
// Verify cache hit returned correct data
expect(result).toEqual([
{
start: "2023-12-01T18:00:00Z",
end: "2023-12-01T19:00:00Z",
},
]);
// Verify NO Google API calls were made
expect(authedCalendarSpy).not.toHaveBeenCalled();
expect(getAllCalendarsSpy).not.toHaveBeenCalled();
expect(fetchAvailabilitySpy).not.toHaveBeenCalled();
// Clean up spies
authedCalendarSpy.mockRestore();
getAllCalendarsSpy.mockRestore();
fetchAvailabilitySpy.mockRestore();
});
test("Cache MISS: Should make Google API calls when cache is not available", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
setFullMockOAuthManagerRequest();
const dateFrom = new Date().toISOString();
const dateTo = new Date(Date.now() + 100000000).toISOString(); // Different date to ensure cache miss
// Mock Google API responses
freebusyQueryMock.mockResolvedValueOnce({
data: {
calendars: {
[testSelectedCalendar.externalId]: {
busy: [
{
start: "2023-12-01T10:00:00Z",
end: "2023-12-01T11:00:00Z",
},
],
},
},
},
});
// Spy on Google API methods that SHOULD be called on cache miss
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
const fetchAvailabilitySpy = vi.spyOn(calendarService, "fetchAvailability");
// Call getAvailability with selected calendars (should miss cache)
const result = await calendarService.getAvailability(dateFrom, dateTo, [testSelectedCalendar], true);
// Verify API call returned correct data
expect(result).toEqual([
{
start: "2023-12-01T10:00:00Z",
end: "2023-12-01T11:00:00Z",
},
]);
// Verify Google API calls WERE made
expect(authedCalendarSpy).toHaveBeenCalled();
expect(fetchAvailabilitySpy).toHaveBeenCalled();
// Clean up spies
authedCalendarSpy.mockRestore();
fetchAvailabilitySpy.mockRestore();
});
test("Cache DISABLED: Should bypass cache when shouldServeCache=false", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
setFullMockOAuthManagerRequest();
const dateFrom = new Date().toISOString();
const dateTo = new Date().toISOString();
// Set up cache with test data
const calendarCache = await CalendarCache.init(null);
await calendarCache.upsertCachedAvailability({
credentialId: credentialInDb.id,
userId: credentialInDb.userId,
args: {
timeMin: getTimeMin(dateFrom),
timeMax: getTimeMax(dateTo),
items: [{ id: testSelectedCalendar.externalId }],
},
value: {
calendars: {
[testSelectedCalendar.externalId]: {
busy: [
{
start: "2023-12-01T18:00:00Z",
end: "2023-12-01T19:00:00Z",
},
],
},
},
},
});
// Mock Google API to return different data than cache
freebusyQueryMock.mockResolvedValueOnce({
data: {
calendars: {
[testSelectedCalendar.externalId]: {
busy: [
{
start: "2023-12-01T20:00:00Z",
end: "2023-12-01T21:00:00Z",
},
],
},
},
},
});
// Spy on Google API methods
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
const fetchAvailabilitySpy = vi.spyOn(calendarService, "fetchAvailability");
// Call getAvailability with shouldServeCache=false (should bypass cache)
const result = await calendarService.getAvailability(dateFrom, dateTo, [testSelectedCalendar], false);
// Verify API data was returned (not cache data)
expect(result).toEqual([
{
start: "2023-12-01T20:00:00Z",
end: "2023-12-01T21:00:00Z",
},
]);
// Verify Google API calls WERE made even though cache existed
expect(authedCalendarSpy).toHaveBeenCalled();
expect(fetchAvailabilitySpy).toHaveBeenCalled();
// Clean up spies
authedCalendarSpy.mockRestore();
fetchAvailabilitySpy.mockRestore();
});
test("NO SELECTED CALENDARS: Should skip cache logic when no selectedCalendarIds", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
setFullMockOAuthManagerRequest();
const dateFrom = new Date().toISOString();
const dateTo = new Date().toISOString();
// Mock Google API response for fallback scenario
calendarListMock.mockResolvedValueOnce({
data: {
items: [
{
id: "[email protected]",
primary: true,
},
],
},
});
freebusyQueryMock.mockResolvedValueOnce({
data: {
calendars: {
"[email protected]": {
busy: [
{
start: "2023-12-01T12:00:00Z",
end: "2023-12-01T13:00:00Z",
},
],
},
},
},
});
// Spy on cache method that should NOT be called
const tryGetAvailabilityFromCacheSpy = vi.spyOn(calendarService, "tryGetAvailabilityFromCache" as any);
// Spy on Google API methods that SHOULD be called
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
const getAllCalendarsSpy = vi.spyOn(calendarService, "getAllCalendars");
// Call getAvailability with empty selectedCalendars but fallbackToPrimary=true
const result = await calendarService.getAvailability(dateFrom, dateTo, [], true, true);
// Verify fallback logic worked
expect(result).toEqual([
{
start: "2023-12-01T12:00:00Z",
end: "2023-12-01T13:00:00Z",
},
]);
// Verify cache was NOT checked
expect(tryGetAvailabilityFromCacheSpy).not.toHaveBeenCalled();
// Verify Google API calls WERE made for fallback logic
expect(authedCalendarSpy).toHaveBeenCalled();
expect(getAllCalendarsSpy).toHaveBeenCalled();
// Clean up spies
tryGetAvailabilityFromCacheSpy.mockRestore();
authedCalendarSpy.mockRestore();
getAllCalendarsSpy.mockRestore();
});
test("CACHE ERROR: Should handle cache errors gracefully and fall back to API", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
setFullMockOAuthManagerRequest();
const dateFrom = new Date().toISOString();
const dateTo = new Date().toISOString();
// Mock cache to throw an error
const mockCalendarCache = {
getCachedAvailability: vi.fn().mockRejectedValueOnce(new Error("Cache error")),
};
vi.spyOn(CalendarCache, "init").mockResolvedValueOnce(mockCalendarCache as any);
// Mock Google API response
freebusyQueryMock.mockResolvedValueOnce({
data: {
calendars: {
[testSelectedCalendar.externalId]: {
busy: [
{
start: "2023-12-01T14:00:00Z",
end: "2023-12-01T15:00:00Z",
},
],
},
},
},
});
// Spy on Google API methods that SHOULD be called on cache error
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
const fetchAvailabilitySpy = vi.spyOn(calendarService, "fetchAvailability");
// Call getAvailability (cache should fail, API should be called)
const result = await calendarService.getAvailability(dateFrom, dateTo, [testSelectedCalendar], true);
// Verify API fallback worked
expect(result).toEqual([
{
start: "2023-12-01T14:00:00Z",
end: "2023-12-01T15:00:00Z",
},
]);
// Verify Google API calls WERE made due to cache error
expect(authedCalendarSpy).toHaveBeenCalled();
expect(fetchAvailabilitySpy).toHaveBeenCalled();
// Clean up spies
authedCalendarSpy.mockRestore();
fetchAvailabilitySpy.mockRestore();
});
test("OTHER INTEGRATIONS ONLY: Should return empty array without cache or API calls", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
const dateFrom = new Date().toISOString();
const dateTo = new Date().toISOString();
// Spy on methods that should NOT be called
const tryGetAvailabilityFromCacheSpy = vi.spyOn(calendarService, "tryGetAvailabilityFromCache" as any);
const authedCalendarSpy = vi.spyOn(calendarService, "authedCalendar");
// Call getAvailability with only other integration calendars
const result = await calendarService.getAvailability(
dateFrom,
dateTo,
[
{
integration: "outlook_calendar", // Different integration
externalId: "[email protected]",
},
],
true
);
// Verify early return with empty array
expect(result).toEqual([]);
// Verify NO cache or API calls were made
expect(tryGetAvailabilityFromCacheSpy).not.toHaveBeenCalled();
expect(authedCalendarSpy).not.toHaveBeenCalled();
// Clean up spies
tryGetAvailabilityFromCacheSpy.mockRestore();
authedCalendarSpy.mockRestore();
});
test("Calendar Cache is being ignored on cache MISS", async () => {
const calendarCache = await CalendarCache.init(null);
const credentialInDb = await createCredentialForCalendarService();
const dateFrom = new Date(Date.now()).toISOString();
// Tweak date so that it's a cache miss
const dateTo = new Date(Date.now() + 100000000).toISOString();
const calendarService = new CalendarService(credentialInDb);
// Test Cache Miss
await calendarService.getAvailability(dateFrom, dateTo, [testSelectedCalendar]);
// Expect cache to be ignored in case of a MISS
const cachedAvailability = await calendarCache.getCachedAvailability({
credentialId: credentialInDb.id,
userId: null,
args: {
timeMin: dateFrom,
timeMax: dateTo,
items: [{ id: testSelectedCalendar.externalId }],
},
});
expect(cachedAvailability).toBeNull();
});
test("fetchAvailabilityAndSetCache should fetch and cache availability for selected calendars grouped by eventTypeId", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
const selectedCalendars = [
{
externalId: "[email protected]",
eventTypeId: 1,
},
{
externalId: "[email protected]",
eventTypeId: 1,
},
{
externalId: "[email protected]",
eventTypeId: 2,
},
{
externalId: "[email protected]",
eventTypeId: null,
},
{
externalId: "[email protected]",
eventTypeId: null,
},
];
const mockAvailabilityData = { busy: [] };
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.spyOn(calendarService, "fetchAvailability").mockResolvedValue(mockAvailabilityData as any);
const setAvailabilityInCacheSpy = vi.spyOn(calendarService, "setAvailabilityInCache");
await calendarService.fetchAvailabilityAndSetCache(selectedCalendars);
// Should make 2 calls - one for each unique eventTypeId
expect(calendarService.fetchAvailability).toHaveBeenCalledTimes(3);
// First call for eventTypeId 1 calendars
expect(calendarService.fetchAvailability).toHaveBeenNthCalledWith(1, {
timeMin: expect.any(String),
timeMax: expect.any(String),
items: [{ id: "[email protected]" }, { id: "[email protected]" }],
});
// Second call for eventTypeId 2 calendar
expect(calendarService.fetchAvailability).toHaveBeenNthCalledWith(2, {
timeMin: expect.any(String),
timeMax: expect.any(String),
items: [{ id: "[email protected]" }],
});
// Second call for eventTypeId 2 calendar
expect(calendarService.fetchAvailability).toHaveBeenNthCalledWith(3, {
timeMin: expect.any(String),
timeMax: expect.any(String),
items: [{ id: "[email protected]" }, { id: "[email protected]" }],
});
// Should cache results for both calls
expect(setAvailabilityInCacheSpy).toHaveBeenCalledTimes(3);
expect(setAvailabilityInCacheSpy).toHaveBeenCalledWith(
expect.objectContaining({
items: expect.any(Array),
}),
mockAvailabilityData
);
});
test("A cache set through fetchAvailabilityAndSetCache should be used when doing getAvailability", async () => {
const credentialInDb = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb);
vi.setSystemTime(new Date("2025-04-01T00:00:00.000Z"));
setFullMockOAuthManagerRequest();
const selectedCalendars = [
{
externalId: "[email protected]",
integration: "google_calendar",
eventTypeId: null,
credentialId: credentialInDb.id,
userId: credentialInDb.userId!,
},
];
const mockedBusyTimes = [{ end: "2025-04-02T18:30:00Z", start: "2025-04-01T18:30:00Z" }];
// Mock Once so that the getAvailability call doesn't accidentally reuse this mock result
freebusyQueryMock.mockResolvedValueOnce({
data: {
calendars: {
"[email protected]": {
busy: mockedBusyTimes,
},
},
},
});
const calendarCachesBefore = await prismock.calendarCache.findMany();
expect(calendarCachesBefore).toHaveLength(0);
await calendarService.fetchAvailabilityAndSetCache(selectedCalendars);
const calendarCachesAfter = await prismock.calendarCache.findMany();
console.log({ calendarCachesAfter });
expect(calendarCachesAfter).toHaveLength(1);
const datesForWhichCachedAvailabilityIsUsed = [
{
dateFrom: "2025-04-01T00:00:00.000Z",
dateTo: "2025-06-01T00:00:00.000Z",
},
// Add more dates for which cached availability should be used
// {
// dateFrom: "2025-04-01T00:00:00.000Z",
// dateTo: "2025-04-30T00:00:00.000Z",
// },
];
try {
for (const { dateFrom, dateTo } of datesForWhichCachedAvailabilityIsUsed) {
const result = await calendarService.getAvailability(dateFrom, dateTo, selectedCalendars, true);
expect(result).toEqual(mockedBusyTimes);
}
} catch (error) {
console.log({ error });
throw "Looks like cache was not used";
}
// The following is not working because getBusyCalendarTimes expands the date range a bit.
// const busyCalendarTimesResult = await getBusyCalendarTimes(
// [credentialInDb],
// "2025-04-01T00:00:00.000Z",
// "2025-04-30T00:00:00.000Z",
// selectedCalendars,
// true
// );
// expect(busyCalendarTimesResult).toEqual(mockedBusyTimes);
});
});
describe("Watching and unwatching calendar", () => {
test("Calendar can be watched and unwatched", async () => {
const credentialInDb1 = await createCredentialForCalendarService();
const calendarService = new CalendarService(credentialInDb1);
await calendarService.watchCalendar({
calendarId: testSelectedCalendar.externalId,
eventTypeIds: [null],
});
// Watching a non-existent selectedCalendar creates it
const watchedCalendar = await prismock.selectedCalendar.findFirst({
where: {
userId: credentialInDb1.userId!,
externalId: testSelectedCalendar.externalId,
integration: "google_calendar",
},
});
expect(watchedCalendar).toEqual(
expect.objectContaining({
userId: 1,
eventTypeId: null,
integration: "google_calendar",
externalId: "[email protected]",
credentialId: 1,
delegationCredentialId: null,
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
})
);
expect(watchedCalendar?.id).toBeDefined();
await calendarService.unwatchCalendar({
calendarId: testSelectedCalendar.externalId,
eventTypeIds: [null],
});
const calendarAfterUnwatch = await prismock.selectedCalendar.findFirst({
where: {
userId: credentialInDb1.userId!,
externalId: testSelectedCalendar.externalId,
integration: "google_calendar",
},
});
expect(calendarAfterUnwatch).toEqual(
expect.objectContaining({
userId: 1,
eventTypeId: null,
integration: "google_calendar",
externalId: "[email protected]",
credentialId: 1,
delegationCredentialId: null,
googleChannelId: null,
googleChannelKind: null,
googleChannelResourceId: null,
googleChannelResourceUri: null,
googleChannelExpiration: null,
})
);
expect(calendarAfterUnwatch?.id).toBeDefined();
});
describe("Delegation Credential", () => {
test("On watching a SelectedCalendar having delegationCredential, it should set googleChannelId and other props", async () => {
const delegationCredential1Member1 = await createInMemoryDelegationCredentialForCalendarService({
user: { email: "[email protected]" },
delegationCredentialId: "delegation-credential-id-1",
});
await prismock.selectedCalendar.create({
data: {
userId: delegationCredential1Member1.userId!,
externalId: testSelectedCalendar.externalId,
integration: "google_calendar",
},
});
const calendarService = new CalendarService(delegationCredential1Member1);
await calendarService.watchCalendar({
calendarId: testSelectedCalendar.externalId,
eventTypeIds: [null],
});
expectGoogleSubscriptionToHaveOccurredAndClearMock({
calendarId: testSelectedCalendar.externalId,
});
const calendars = await prismock.selectedCalendar.findMany();
// Ensure no new calendar is created
expect(calendars).toHaveLength(1);
const watchedCalendar = calendars[0];
await expectSelectedCalendarToHaveGoogleChannelProps(watchedCalendar.id, {
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
});
test("On unwatching a SelectedCalendar connected to Delegation Credential, it should remove googleChannelId and other props", async () => {
const delegationCredential1Member1 = await createDelegationCredentialForCalendarCache({
user: { email: "[email protected]" },
delegationCredentialId: "delegation-credential-id-1",
});
const selectedCalendar = await createSelectedCalendarForDelegationCredential({
userId: delegationCredential1Member1.userId!,
delegationCredentialId: delegationCredential1Member1.delegatedToId!,
credentialId: delegationCredential1Member1.id,
externalId: testSelectedCalendar.externalId,
integration: "google_calendar",
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
const calendarService = new CalendarService(delegationCredential1Member1);
await calendarService.unwatchCalendar({
calendarId: selectedCalendar.externalId,
eventTypeIds: [null],
});
expectGoogleUnsubscriptionToHaveOccurredAndClearMock([
{
resourceId: "mock-resource-id",
channelId: "mock-channel-id",
},
]);
const calendars = await prismock.selectedCalendar.findMany();
expect(calendars).toHaveLength(1);
const calendarAfterUnwatch = calendars[0];
expectSelectedCalendarToNotHaveGoogleChannelProps(calendarAfterUnwatch.id);
});
});
test("watchCalendar should not do google subscription if already subscribed for the same calendarId", async () => {
const credentialInDb1 = await createCredentialForCalendarService();
const calendarCache = await CalendarCache.initFromCredentialId(credentialInDb1.id);
const userLevelCalendar = await SelectedCalendarRepository.create({
userId: credentialInDb1.userId!,
externalId: "[email protected]",
integration: "google_calendar",
eventTypeId: null,
credentialId: credentialInDb1.id,
});
const eventTypeLevelCalendar = await SelectedCalendarRepository.create({
userId: credentialInDb1.userId!,
externalId: "[email protected]",
integration: "google_calendar",
eventTypeId: 1,
credentialId: credentialInDb1.id,
});
await calendarCache.watchCalendar({
calendarId: userLevelCalendar.externalId,
eventTypeIds: [userLevelCalendar.eventTypeId],
});
expectGoogleSubscriptionToHaveOccurredAndClearMock({
calendarId: userLevelCalendar.externalId,
});
await expectSelectedCalendarToHaveGoogleChannelProps(userLevelCalendar.id, {
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
// Watch different selectedcalendar with same externalId and credentialId
await calendarCache.watchCalendar({
calendarId: eventTypeLevelCalendar.externalId,
eventTypeIds: [eventTypeLevelCalendar.eventTypeId],
});
expectGoogleSubscriptionToNotHaveOccurredAndClearMock();
// Google Subscription didn't occur but still the eventTypeLevelCalendar has the same googleChannelProps
await expectSelectedCalendarToHaveGoogleChannelProps(eventTypeLevelCalendar.id, {
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
});
test("watchCalendar should do google subscription if already subscribed but for different calendarId", async () => {
const credentialInDb1 = await createCredentialForCalendarService();
const calendarCache = await CalendarCache.initFromCredentialId(credentialInDb1.id);
const userLevelCalendar = await SelectedCalendarRepository.create({
userId: credentialInDb1.userId!,
externalId: "[email protected]",
integration: "google_calendar",
eventTypeId: null,
credentialId: credentialInDb1.id,
});
const eventTypeLevelCalendar = await SelectedCalendarRepository.create({
userId: credentialInDb1.userId!,
externalId: "[email protected]",
integration: "google_calendar",
eventTypeId: 1,
credentialId: credentialInDb1.id,
});
await calendarCache.watchCalendar({
calendarId: userLevelCalendar.externalId,
eventTypeIds: [userLevelCalendar.eventTypeId],
});
expectGoogleSubscriptionToHaveOccurredAndClearMock({
calendarId: userLevelCalendar.externalId,
});
await expectSelectedCalendarToHaveGoogleChannelProps(userLevelCalendar.id, {
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
// Watch different selectedcalendar with same externalId and credentialId
await calendarCache.watchCalendar({
calendarId: eventTypeLevelCalendar.externalId,
eventTypeIds: [eventTypeLevelCalendar.eventTypeId],
});
expectGoogleSubscriptionToHaveOccurredAndClearMock({
calendarId: eventTypeLevelCalendar.externalId,
});
// Google Subscription didn't occur but still the eventTypeLevelCalendar has the same googleChannelProps
await expectSelectedCalendarToHaveGoogleChannelProps(eventTypeLevelCalendar.id, {
googleChannelId: "mock-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "mock-resource-id",
googleChannelResourceUri: "mock-resource-uri",
googleChannelExpiration: "1111111111",
});
});
test("unwatchCalendar should not unsubscribe from google if there is another selectedCalendar with same externalId and credentialId", async () => {
const credentialInDb1 = await createCredentialForCalendarService();
const calendarCache = await CalendarCache.initFromCredentialId(credentialInDb1.id);
await prismock.calendarCache.create({
data: {
key: "test-key",
value: "test-value",
expiresAt: new Date(Date.now() + 100000000),
credentialId: credentialInDb1.id,
},
});
const someOtherCache = await prismock.calendarCache.create({
data: {
key: JSON.stringify({
items: [{ id: "[email protected]" }],
}),
value: "test-value-2",
expiresAt: new Date(Date.now() + 100000000),
credentialId: 999,
},
});
const googleChannelProps = {
googleChannelId: "test-channel-id",
googleChannelKind: "api#channel",
googleChannelResourceId: "test-resource-id",
googleChannelResourceUri: "test-resource-uri",
googleChannelExpiration: "1111111111",
};
const commonProps = {
userId: credentialInDb1.userId!,
externalId: "[email protected]",
integration: "google_calendar",
credentialId: credentialInDb1.id,
...googleChannelProps,
};
const userLevelCalendar = await SelectedCalendarRepository.create({
...commonProps,
eventTypeId: null,
});
const eventTypeLevelCalendar = await SelectedCalendarRepository.create({
...commonProps,
eventTypeId: 1,
});
const eventTypeLevelCalendarForSomeOtherExternalIdButSameCredentialId =
await SelectedCalendarRepository.create({
...commonProps,
externalId: "[email protected]",
eventTypeId: 2,
});
await calendarCache.unwatchCalendar({
calendarId: userLevelCalendar.externalId,
eventTypeIds: [userLevelCalendar.eventTypeId],
});
// There is another selectedCalendar with same externalId and credentialId, so actual unsubscription does not happen
expectGoogleUnsubscriptionToNotHaveOccurredAndClearMock();
await expectSelectedCalendarToNotHaveGoogleChannelProps(userLevelCalendar.id);
await calendarCache.unwatchCalendar({
calendarId: eventTypeLevelCalendar.externalId,
eventTypeIds: [eventTypeLevelCalendar.eventTypeId],
});
expectGoogleUnsubscriptionToHaveOccurredAndClearMock([
{
resourceId: "test-resource-id",
channelId: "test-channel-id",
},
]);
// Concerned cache will just have remaining externalIds
await expectCacheToBeSet({
credentialId: credentialInDb1.id,
itemsInKey: [{ id: eventTypeLevelCalendarForSomeOtherExternalIdButSameCredentialId.externalId }],
});
await expectCacheToBeSet({
credentialId: someOtherCache.credentialId,
itemsInKey: JSON.parse(someOtherCache.key).items,
});
await expectSelectedCalendarToNotHaveGoogleChannelProps(eventTypeLevelCalendar.id);
// Some other selectedCalendar stays unaffected
await expectSelectedCalendarToHaveGoogleChannelProps(
eventTypeLevelCalendarForSomeOtherExternalIdButSameCredentialId.id,
googleChannelProps
);
});
});
describe("getAvailability", () => {
test("returns availability for selected calendars", async () => {
const credential = await createCredentialForCalendarService();
const calendarService = new CalendarService(credential);
setFullMockOAuthManagerRequest();
const mockedBusyTimes1 = [
{
start: "2024-01-01",
end: "2024-01-02",
},
];
const mockedBusyTimes2 = [
{
start: "2024-01-03",
end: "2024-01-04",
},
];
const mockedBusyTimes = [mockedBusyTimes1, mockedBusyTimes2];
calendarListMock.mockImplementation(() => {
return {
data: {
items: [
{
id: "[email protected]",
},
{
id: "[email protected]",
},
],
},
};
});
// Mock Once so that the getAvailability call doesn't accidentally reuse this mock result
freebusyQueryMock.mockImplementation(({ requestBody }: { requestBody: any }) => {
const calendarsObject: any = {};
requestBody.items.forEach((item: any, index: number) => {
calendarsObject[item.id] = {
busy: mockedBusyTimes[index],
};
});
return {
data: {
calendars: calendarsObject,
},
};
});
const availabilityWithPrimaryAsFallback = await calendarService.getAvailability(
"2024-01-01",
"2024-01-02",
[],
false,
true
);
expect(availabilityWithPrimaryAsFallback).toEqual(mockedBusyTimes1);
const availabilityWithAllCalendarsAsFallback = await calendarService.getAvailability(
"2024-01-01",
"2024-01-02",
[],
false,
false
);
expect(availabilityWithAllCalendarsAsFallback).toEqual([...mockedBusyTimes1, ...mockedBusyTimes2]);
});
});
describe("getPrimaryCalendar", () => {
test("should fetch primary calendar using 'primary' keyword", async () => {
const credential = await createCredentialForCalendarService();
const calendarService = new CalendarService(credential);
setFullMockOAuthManagerRequest();
const mockPrimaryCalendar = {
id: "[email protected]",
summary: "Primary Calendar",
description: "Primary calendar for [email protected]",
timeZone: "America/New_York",
};
const calendarsGetMock = vi.fn().mockResolvedValue({
data: mockPrimaryCalendar,
});
calendarMock.calendar_v3.Calendar().calendars.get = calendarsGetMock;
const result = await calendarService.getPrimaryCalendar();
expect(calendarsGetMock).toHaveBeenCalledTimes(1);
expect(calendarsGetMock).toHaveBeenCalledWith({
calendarId: "primary",
});
expect(result).toEqual(mockPrimaryCalendar);
});
});
describe("Date Optimization Benchmarks", () => {
test("native Date calculations should be significantly faster than dayjs while producing identical results", async () => {
const dayjs = (await import("@calcom/dayjs")).default;
const testCases = [
{
dateFrom: "2024-01-01T00:00:00Z",
dateTo: "2024-01-31T00:00:00Z",
name: "30 days",
expectedDiff: 30,
},
{
dateFrom: "2024-01-01T00:00:00Z",
dateTo: "2024-03-31T00:00:00Z",
name: "90 days (API limit)",
expectedDiff: 90,
},
{
dateFrom: "2024-01-01T00:00:00Z",
dateTo: "2024-07-01T00:00:00Z",
name: "182 days (chunking required)",
expectedDiff: 182,
},
];
const iterations = 1000; // Reduced for test performance
for (const testCase of testCases) {
log.info(`Testing ${testCase.name}...`);
// Test correctness first
const dayjsDiff = dayjs(testCase.dateTo).diff(dayjs(testCase.dateFrom), "days");
const nativeDiff = Math.floor(
(new Date(testCase.dateTo).getTime() - new Date(testCase.dateFrom).getTime()) / (1000 * 60 * 60 * 24)
);
// Verify identical results
expect(nativeDiff).toBe(dayjsDiff);
expect(nativeDiff).toBe(testCase.expectedDiff);
// Performance test - dayjs approach
const dayjsStart = performance.now();
for (let i = 0; i < iterations; i++) {
const start = dayjs(testCase.dateFrom);
const end = dayjs(testCase.dateTo);
const diff = end.diff(start, "days");
}
const dayjsTime = performance.now() - dayjsStart;
// Performance test - native Date approach
const nativeStart = performance.now();
for (let i = 0; i < iterations; i++) {
const start = new Date(testCase.dateFrom);
const end = new Date(testCase.dateTo);
const diff = Math.floor((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
}
const nativeTime = performance.now() - nativeStart;
const speedupRatio = dayjsTime / nativeTime;
log.info(
`${testCase.name} - Dayjs: ${dayjsTime.toFixed(2)}ms, Native: ${nativeTime.toFixed(
2
)}ms, Speedup: ${speedupRatio.toFixed(1)}x`
);
// Assert significant performance improvement (at least 5x faster)
expect(speedupRatio).toBeGreaterThan(5);
}
});
test("chunking logic should produce identical results between dayjs and native Date implementations", async () => {
const dayjs = (await import("@calcom/dayjs")).default;
const testCases = [
{
dateFrom: "2024-01-01T00:00:00Z",
dateTo: "2024-04-01T00:00:00Z", // 91 days - requires chunking
name: "91 days (minimal chunking)",
},
{
dateFrom: "2024-01-01T00:00:00Z",
dateTo: "2024-07-01T00:00:00Z", // 182 days - multiple chunks
name: "182 days (multiple chunks)",
},
];
for (const testCase of testCases) {
const fromDate = new Date(testCase.dateFrom);
const toDate = new Date(testCase.dateTo);
const diff = Math.floor((toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60 * 24));
// Only test cases that require chunking (> 90 days)
if (diff <= 90) continue;
// OLD WAY (dayjs-based chunking)
const originalStartDate = dayjs(testCase.dateFrom);
const originalEndDate = dayjs(testCase.dateTo);
const loopsNumber = Math.ceil(diff / 90);
let startDate = originalStartDate;
let endDate = originalStartDate.add(90, "days");
const oldChunks = [];
for (let i = 0; i < loopsNumber; i++) {
if (endDate.isAfter(originalEndDate)) endDate = originalEndDate;
oldChunks.push({
start: startDate.toISOString(),
end: endDate.toISOString(),
});
startDate = endDate.add(1, "minutes");
endDate = startDate.add(90, "days");
}
// NEW WAY (native Date-based chunking)
let currentStartTime = fromDate.getTime();
const originalEndTime = toDate.getTime();
const ninetyDaysMs = 90 * 24 * 60 * 60 * 1000;
const oneMinuteMs = 60 * 1000;
const newChunks = [];
for (let i = 0; i < loopsNumber; i++) {
let currentEndTime = currentStartTime + ninetyDaysMs;
if (currentEndTime > originalEndTime) {
currentEndTime = originalEndTime;
}
newChunks.push({
start: new Date(currentStartTime).toISOString(),
end: new Date(currentEndTime).toISOString(),
});
currentStartTime = currentEndTime + oneMinuteMs;
}
// Verify identical chunking results
expect(newChunks).toHaveLength(oldChunks.length);
for (let i = 0; i < oldChunks.length; i++) {
expect(newChunks[i].start).toBe(oldChunks[i].start);
expect(newChunks[i].end).toBe(oldChunks[i].end);
}
log.info(`${testCase.name} - Generated ${newChunks.length} identical chunks`);
}
});
test("date parsing should be consistent between dayjs and native Date for all expected input formats", async () => {
const dayjs = (await import("@calcom/dayjs")).default;
// Test various date formats that Google Calendar API might return
const testDates = [
"2024-01-01T00:00:00Z", // UTC
"2024-01-01T12:30:45.123Z", // UTC with milliseconds
"2024-01-01T00:00:00-08:00", // Timezone offset
"2024-01-01T00:00:00+05:30", // Positive timezone offset
"2024-12-31T23:59:59Z", // End of year
"2024-02-29T12:00:00Z", // Leap year date
];
for (const dateString of testDates) {
const dayjsTime = dayjs(dateString).valueOf();
const nativeTime = new Date(dateString).getTime();
expect(nativeTime).toBe(dayjsTime);
// Also verify ISO string output consistency
const dayjsISO = dayjs(dateString).toISOString();
const nativeISO = new Date(dateString).toISOString();
expect(nativeISO).toBe(dayjsISO);
log.debug(`Date parsing verified: ${dateString} -> ${nativeTime}`);
}
});
test("fetchAvailabilityData should handle both single API call and chunked scenarios correctly", async () => {
const credential = await createCredentialForCalendarService();
const calendarService = new CalendarService(credential);
setFullMockOAuthManagerRequest();
const mockBusyData = [
{ start: "2024-01-01T10:00:00Z", end: "2024-01-01T11:00:00Z" },
{ start: "2024-01-01T14:00:00Z", end: "2024-01-01T15:00:00Z" },
];
// Mock the getCacheOrFetchAvailability method to return consistent data
const getCacheOrFetchAvailabilitySpy = vi
.spyOn(calendarService as any, "getCacheOrFetchAvailability")
.mockResolvedValue(mockBusyData.map((item) => ({ ...item, id: "[email protected]" })));
// Test single API call scenario (≤ 90 days)
const shortRangeResult = await (calendarService as any).fetchAvailabilityData(
["[email protected]"],
"2024-01-01T00:00:00Z",
"2024-01-31T00:00:00Z", // 30 days
false
);
expect(shortRangeResult).toEqual(mockBusyData);
expect(getCacheOrFetchAvailabilitySpy).toHaveBeenCalledTimes(1);
getCacheOrFetchAvailabilitySpy.mockClear();
// Test chunked scenario (> 90 days)
const longRangeResult = await (calendarService as any).fetchAvailabilityData(
["[email protected]"],
"2024-01-01T00:00:00Z",
"2024-07-01T00:00:00Z", // 182 days - should require chunking
false
);
// Should return concatenated results from multiple chunks
expect(longRangeResult.length).toBeGreaterThan(0);
expect(getCacheOrFetchAvailabilitySpy).toHaveBeenCalledTimes(3); // 182 days / 90 = ~2.02 -> 3 chunks
getCacheOrFetchAvailabilitySpy.mockRestore();
});
});
describe("createEvent", () => {
test("should create event with correct input/output format and handle all expected properties", async () => {
const credential = await createCredentialForCalendarService();
const calendarService = new CalendarService(credential);
setFullMockOAuthManagerRequest();
// Mock Google Calendar API response
const mockGoogleEvent = {
id: "mock-event-id-123",
summary: "Test Meeting",
description: "Test meeting description",
start: {
dateTime: "2024-06-15T10:00:00Z",
timeZone: "UTC",
},
end: {
dateTime: "2024-06-15T11:00:00Z",
timeZone: "UTC",
},
attendees: [
{
email: "[email protected]",
displayName: "Test Organizer",
responseStatus: "accepted",
organizer: true,
},
{
email: "[email protected]",
displayName: "Test Attendee",
responseStatus: "accepted",
},
],
location: "Test Location",
iCalUID: "[email protected]",
recurrence: null,
};
// Mock calendar.events.insert
const eventsInsertMock = vi.fn().mockResolvedValue({
data: mockGoogleEvent,
});
calendarMock.calendar_v3.Calendar().events.insert = eventsInsertMock;
// Test input - simplified CalendarServiceEvent
const testCalEvent = {
type: "test-event-type",
uid: "cal-event-uid-123",
title: "Test Meeting",
startTime: "2024-06-15T10:00:00Z",
endTime: "2024-06-15T11:00:00Z",
organizer: {
id: 1,
name: "Test Organizer",
email: "[email protected]",
timeZone: "UTC",
language: {
translate: (...args: any[]) => args[0], // Mock translate function
locale: "en",
},
},
attendees: [
{
id: 2,
name: "Test Attendee",
email: "[email protected]",
timeZone: "UTC",
language: {
translate: (...args: any[]) => args[0], // Mock translate function
locale: "en",
},
},
],
location: "Test Location",
calendarDescription: "Test meeting description",
destinationCalendar: [
{
id: 1,
integration: "google_calendar",
externalId: "primary",
primaryEmail: null,
userId: credential.userId,
eventTypeId: null,
credentialId: credential.id,
delegationCredentialId: null,
domainWideDelegationCredentialId: null,
createdAt: new Date("2024-06-15T11:00:00Z"),
updatedAt: new Date("2024-06-15T11:00:00Z"),
},
],
iCalUID: "[email protected]",
conferenceData: undefined,
hideCalendarEventDetails: false,
seatsPerTimeSlot: null,
seatsShowAttendees: true,
};
// Call createEvent and verify result using inline snapshot
const result = await calendarService.createEvent(testCalEvent, credential.id);
// Verify input processing - check that Google API was called with correct payload
expect(eventsInsertMock).toHaveBeenCalledTimes(1);
const insertCall = eventsInsertMock.mock.calls[0][0];
// Use inline snapshot for input validation
expect(insertCall).toMatchInlineSnapshot(`
{
"calendarId": "primary",
"conferenceDataVersion": 1,
"requestBody": {
"attendees": [
{
"displayName": "Test Organizer",
"email": "primary",
"id": "1",
"language": {
"locale": "en",
"translate": [Function],
},
"name": "Test Organizer",
"organizer": true,
"responseStatus": "accepted",
"timeZone": "UTC",
},
{
"email": "[email protected]",
"language": {
"locale": "en",
"translate": [Function],
},
"name": "Test Attendee",
"responseStatus": "accepted",
"timeZone": "UTC",
},
],
"description": "Test meeting description",
"end": {
"dateTime": "2024-06-15T11:00:00Z",
"timeZone": "UTC",
},
"guestsCanSeeOtherGuests": true,
"iCalUID": "[email protected]",
"location": "Test Location",
"reminders": {
"useDefault": true,
},
"start": {
"dateTime": "2024-06-15T10:00:00Z",
"timeZone": "UTC",
},
"summary": "Test Meeting",
},
"sendUpdates": "none",
}
`);
// Use inline snapshot for output validation
expect(result).toMatchInlineSnapshot(`
{
"additionalInfo": {
"hangoutLink": "",
},
"attendees": [
{
"displayName": "Test Organizer",
"email": "[email protected]",
"organizer": true,
"responseStatus": "accepted",
},
{
"displayName": "Test Attendee",
"email": "[email protected]",
"responseStatus": "accepted",
},
],
"description": "Test meeting description",
"end": {
"dateTime": "2024-06-15T11:00:00Z",
"timeZone": "UTC",
},
"iCalUID": "[email protected]",
"id": "mock-event-id-123",
"location": "Test Location",
"password": "",
"recurrence": null,
"start": {
"dateTime": "2024-06-15T10:00:00Z",
"timeZone": "UTC",
},
"summary": "Test Meeting",
"thirdPartyRecurringEventId": null,
"type": "google_calendar",
"uid": "",
"url": "",
}
`);
log.info("createEvent test passed - input/output formats verified");
});
test("should handle recurring events correctly", async () => {
const credential = await createCredentialForCalendarService();
const calendarService = new CalendarService(credential);
setFullMockOAuthManagerRequest();
// Mock recurring event response
const mockRecurringEvent = {
id: "recurring-event-id",
summary: "Weekly Meeting",
recurrence: ["RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=10"],
start: { dateTime: "2024-06-15T10:00:00Z", timeZone: "UTC" },
end: { dateTime: "2024-06-15T11:00:00Z", timeZone: "UTC" },
};
const mockFirstInstance = {
id: "recurring-event-id_20240615T100000Z",
summary: "Weekly Meeting",
start: { dateTime: "2024-06-15T10:00:00Z", timeZone: "UTC" },
end: { dateTime: "2024-06-15T11:00:00Z", timeZone: "UTC" },
};
calendarMock.calendar_v3.Calendar().events.insert = vi.fn().mockResolvedValue({
data: mockRecurringEvent,
});
calendarMock.calendar_v3.Calendar().events.instances = vi.fn().mockResolvedValue({
data: { items: [mockFirstInstance] },
});
const recurringCalEvent = {
type: "recurring-meeting",
title: "Weekly Meeting",
startTime: "2024-06-15T10:00:00Z",
endTime: "2024-06-15T11:00:00Z",
organizer: {
id: 1,
name: "Organizer",
email: "[email protected]",
timeZone: "UTC",
language: {
translate: (...args: any[]) => args[0], // Mock translate function
locale: "en",
},
},
attendees: [],
recurringEvent: {
freq: 2, // Weekly
interval: 1,
count: 10,
},
destinationCalendar: [
{
id: 1,
integration: "google_calendar",
externalId: "primary",
primaryEmail: null,
userId: credential.userId,
eventTypeId: null,
credentialId: credential.id,
delegationCredentialId: null,
domainWideDelegationCredentialId: null,
createdAt: new Date("2024-06-15T11:00:00Z"),
updatedAt: new Date("2024-06-15T11:00:00Z"),
},
],
calendarDescription: "Weekly team meeting",
};
const result = await calendarService.createEvent(recurringCalEvent, credential.id);
// Use inline snapshot for recurring event result
expect(result).toMatchInlineSnapshot(`
{
"additionalInfo": {
"hangoutLink": "",
},
"end": {
"dateTime": "2024-06-15T11:00:00Z",
"timeZone": "UTC",
},
"iCalUID": undefined,
"id": "recurring-event-id_20240615T100000Z",
"password": "",
"start": {
"dateTime": "2024-06-15T10:00:00Z",
"timeZone": "UTC",
},
"summary": "Weekly Meeting",
"thirdPartyRecurringEventId": "recurring-event-id",
"type": "google_calendar",
"uid": "",
"url": "",
}
`);
// Verify recurrence rule was included in the request
const insertCall = calendarMock.calendar_v3.Calendar().events.insert.mock.calls[0][0];
expect(insertCall.requestBody.recurrence).toEqual(["RRULE:FREQ=WEEKLY;INTERVAL=1;COUNT=10"]);
log.info("createEvent recurring event test passed");
});
});