Scheduling infrastructure for absolutely everyone.
import dayjs from "@calcom/dayjs";
import type { EventBusyDetails } from "@calcom/types/Calendar";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { EventType, GetUserAvailabilityInitialData } from "./getUserAvailability";
import { UserAvailabilityService } from "./getUserAvailability";
vi.mock("@calcom/features/di/containers/BusyTimes", () => ({
getBusyTimesService: vi.fn(() => mockBusyTimesService),
}));
vi.mock("@calcom/features/busyTimes/lib/getBusyTimesFromLimits", () => ({
getBusyTimesFromLimits: vi.fn().mockResolvedValue([]),
getBusyTimesFromTeamLimits: vi.fn().mockResolvedValue([]),
}));
vi.mock("@calcom/app-store/_utils/getCalendar", () => ({
getCalendar: vi.fn(),
}));
vi.mock("@calcom/lib/holidays", () => ({
getHolidayService: vi.fn(() => ({
getHolidayDatesInRange: vi.fn().mockResolvedValue([]),
})),
}));
const mockBusyTimesService = {
getStartEndDateforLimitCheck: vi.fn().mockReturnValue({
limitDateFrom: dayjs("2025-01-01T00:00:00Z"),
limitDateTo: dayjs("2025-01-31T23:59:59Z"),
}),
getBusyTimesForLimitChecks: vi.fn().mockResolvedValue([]),
getBusyTimes: vi.fn().mockResolvedValue([]),
};
const mockDependencies: ConstructorParameters<typeof UserAvailabilityService>[0] = {
oooRepo: {
findUserOOODays: vi.fn().mockResolvedValue([]),
},
bookingRepo: {
findAcceptedBookingByEventTypeId: vi.fn().mockResolvedValue([]),
},
redisClient: {
get: vi.fn().mockResolvedValue(null),
set: vi.fn(),
},
eventTypeRepo: {
findByIdForUserAvailability: vi.fn().mockResolvedValue(null),
findForSlots: vi.fn().mockResolvedValue(null),
},
holidayRepo: {
findUserSettingsSelect: vi.fn().mockResolvedValue(null),
},
};
const DATE_FROM = "2025-01-06T00:00:00Z";
const DATE_TO = "2025-01-10T23:59:59Z";
const DATE_FROM_ISO = "2025-01-06T00:00:00.000Z";
const DATE_TO_ISO = "2025-01-10T23:59:59.000Z";
const LIMIT_DATE_FROM_FORMATTED = "2025-01-01T00:00:00+00:00";
const LIMIT_DATE_TO_FORMATTED = "2025-01-31T23:59:59+00:00";
const createMockUser = (
overrides?: Partial<NonNullable<GetUserAvailabilityInitialData["user"]>>
): NonNullable<GetUserAvailabilityInitialData["user"]> => ({
id: 1,
username: "testuser",
email: "[email protected]",
bufferTime: 0,
timeZone: "UTC",
availability: [
{
id: 1,
userId: 1,
eventTypeId: null,
scheduleId: 1,
days: [1, 2, 3, 4, 5],
startTime: new Date("1970-01-01T09:00:00Z"),
endTime: new Date("1970-01-01T17:00:00Z"),
date: null,
},
],
timeFormat: 12,
defaultScheduleId: 1,
isPlatformManaged: false,
schedules: [
{
id: 1,
availability: [
{
days: [1, 2, 3, 4, 5],
startTime: new Date("1970-01-01T09:00:00Z"),
endTime: new Date("1970-01-01T17:00:00Z"),
date: null,
},
],
timeZone: "UTC",
},
],
credentials: [],
allSelectedCalendars: [],
userLevelSelectedCalendars: [],
travelSchedules: [],
...overrides,
});
const createMockEventType = (overrides?: Partial<NonNullable<EventType>>): NonNullable<EventType> => ({
id: 100,
length: 30,
seatsPerTimeSlot: null,
timeZone: null,
schedule: null,
availability: [],
hosts: [],
bookingLimits: null,
durationLimits: null,
metadata: null,
useEventLevelSelectedCalendars: false,
team: null,
parent: null,
schedulingType: null,
assignAllTeamMembers: false,
...overrides,
});
const createParams = (overrides?: Record<string, unknown>) => ({
dateFrom: dayjs(DATE_FROM),
dateTo: dayjs(DATE_TO),
returnDateOverrides: false,
...overrides,
});
describe("UserAvailabilityService.getUserAvailabilityIncludingBusyTimesFromLimits", () => {
let service: UserAvailabilityService;
beforeEach(() => {
vi.clearAllMocks();
service = new UserAvailabilityService(mockDependencies);
});
it("skips fetching limit busy times when busyTimesFromLimitsBookings is already in initialData", async () => {
const user = createMockUser();
const eventType = createMockEventType({ bookingLimits: { PER_DAY: 3 } });
const existingBusyTimes: EventBusyDetails[] = [
{
start: "2025-01-06T10:00:00Z",
end: "2025-01-06T23:59:59Z",
source: "Event Booking Limit",
},
];
const result = await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
busyTimesFromLimitsBookings: existingBusyTimes,
});
expect(mockBusyTimesService.getBusyTimesForLimitChecks).not.toHaveBeenCalled();
expect(result).toBeDefined();
expect(result.busy).toBeDefined();
});
it("preserves pre-existing busyTimesFromLimitsBookings from initialData instead of overwriting with empty array", async () => {
const user = createMockUser();
const eventType = createMockEventType({ bookingLimits: { PER_DAY: 3 } });
const existingBusyTimes: EventBusyDetails[] = [
{
start: "2025-01-06T10:00:00Z",
end: "2025-01-06T23:59:59Z",
source: "Event Booking Limit for User: 3 per day",
},
];
const getUserAvailabilitySpy = vi.spyOn(service, "_getUserAvailability" as keyof typeof service);
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
busyTimesFromLimitsBookings: existingBusyTimes,
});
// Verify that the pre-existing busyTimesFromLimitsBookings is passed through
// and NOT overwritten with an empty array
expect(getUserAvailabilitySpy).toHaveBeenCalledWith(
createParams(),
expect.objectContaining({
user,
eventType,
busyTimesFromLimitsBookings: existingBusyTimes,
})
);
});
it("fetches busy times when eventType has booking limits", async () => {
const user = createMockUser();
const eventType = createMockEventType({ bookingLimits: { PER_DAY: 3 } });
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams({ eventTypeId: 100 }), {
user,
eventType,
});
expect(mockBusyTimesService.getStartEndDateforLimitCheck).toHaveBeenCalledWith(
DATE_FROM_ISO,
DATE_TO_ISO,
{ PER_DAY: 3 },
null
);
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [1],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: undefined,
bookingLimits: { PER_DAY: 3 },
durationLimits: null,
});
});
it("fetches busy times when eventType has duration limits", async () => {
const user = createMockUser();
const eventType = createMockEventType({ durationLimits: { PER_WEEK: 120 } });
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(mockBusyTimesService.getStartEndDateforLimitCheck).toHaveBeenCalledWith(
DATE_FROM_ISO,
DATE_TO_ISO,
null,
{ PER_WEEK: 120 }
);
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [1],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: undefined,
bookingLimits: null,
durationLimits: { PER_WEEK: 120 },
});
});
it("passes both bookingLimits and durationLimits separately to getStartEndDateforLimitCheck", async () => {
const user = createMockUser();
const eventType = createMockEventType({
bookingLimits: { PER_DAY: 3 },
durationLimits: { PER_WEEK: 120 },
});
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(mockBusyTimesService.getStartEndDateforLimitCheck).toHaveBeenCalledWith(
DATE_FROM_ISO,
DATE_TO_ISO,
{ PER_DAY: 3 },
{ PER_WEEK: 120 }
);
});
it("skips fetching limit busy times when eventType has no limits", async () => {
const user = createMockUser();
const eventType = createMockEventType();
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(mockBusyTimesService.getStartEndDateforLimitCheck).not.toHaveBeenCalled();
expect(mockBusyTimesService.getBusyTimesForLimitChecks).not.toHaveBeenCalled();
});
it("skips fetching limit busy times when no eventType exists", async () => {
const user = createMockUser();
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
});
expect(mockBusyTimesService.getBusyTimesForLimitChecks).not.toHaveBeenCalled();
});
it("uses host user IDs for team events with booking limits", async () => {
const user = createMockUser();
const eventType = createMockEventType({
bookingLimits: { PER_DAY: 5 },
hosts: [
{ user: { id: 1, email: "[email protected]" }, schedule: null },
{ user: { id: 2, email: "[email protected]" }, schedule: null },
{ user: { id: 3, email: "[email protected]" }, schedule: null },
],
});
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [1, 2, 3],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: undefined,
bookingLimits: { PER_DAY: 5 },
durationLimits: null,
});
});
it("uses only the user ID for solo events with booking limits", async () => {
const user = createMockUser({ id: 42 });
const eventType = createMockEventType({
bookingLimits: { PER_DAY: 2 },
hosts: [],
});
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [42],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: undefined,
bookingLimits: { PER_DAY: 2 },
durationLimits: null,
});
});
it("fetches eventType by eventTypeId when not provided in initialData", async () => {
const user = createMockUser();
const fetchedEventType = createMockEventType({ bookingLimits: { PER_DAY: 1 } });
vi.mocked(mockDependencies.eventTypeRepo.findByIdForUserAvailability).mockResolvedValueOnce(
fetchedEventType
);
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams({ eventTypeId: 100 }), {
user,
});
expect(mockDependencies.eventTypeRepo.findByIdForUserAvailability).toHaveBeenCalledWith({ id: 100 });
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [1],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: undefined,
bookingLimits: { PER_DAY: 1 },
durationLimits: null,
});
});
it("passes fetched busyTimesFromLimitsBookings to _getUserAvailability", async () => {
const user = createMockUser();
const eventType = createMockEventType({ bookingLimits: { PER_DAY: 3 } });
const fetchedBusyTimes: EventBusyDetails[] = [
{
start: "2025-01-06T09:00:00Z",
end: "2025-01-06T10:00:00Z",
source: "eventType-100-booking-1",
title: "Test Booking",
},
];
mockBusyTimesService.getBusyTimesForLimitChecks.mockResolvedValueOnce(fetchedBusyTimes);
const getUserAvailabilitySpy = vi.spyOn(service, "_getUserAvailability" as keyof typeof service);
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
expect(getUserAvailabilitySpy).toHaveBeenCalledWith(
createParams(),
expect.objectContaining({
user,
eventType,
busyTimesFromLimitsBookings: fetchedBusyTimes,
})
);
});
it("does not pass busyTimesFromLimitsBookings when no limits and no initialData bookings", async () => {
const user = createMockUser();
const eventType = createMockEventType(); // no limits
const getUserAvailabilitySpy = vi.spyOn(service, "_getUserAvailability" as keyof typeof service);
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
});
// When there are no limits and no pre-existing busyTimesFromLimitsBookings,
// the property should not be spread into the call
const callArgs = getUserAvailabilitySpy.mock.calls[0];
expect(callArgs[1]).not.toHaveProperty("busyTimesFromLimitsBookings");
});
it("passes fetched eventType to _getUserAvailability to avoid duplicate DB query", async () => {
const user = createMockUser();
const fetchedEventType = createMockEventType({ bookingLimits: { PER_DAY: 1 } });
vi.mocked(mockDependencies.eventTypeRepo.findByIdForUserAvailability).mockResolvedValueOnce(
fetchedEventType
);
const getUserAvailabilitySpy = vi.spyOn(service, "_getUserAvailability" as keyof typeof service);
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams({ eventTypeId: 100 }), {
user,
});
expect(getUserAvailabilitySpy).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
eventType: fetchedEventType,
})
);
});
it("passes rescheduleUid to getBusyTimesForLimitChecks when provided", async () => {
const user = createMockUser();
const eventType = createMockEventType({ bookingLimits: { PER_DAY: 3 } });
await service.getUserAvailabilityIncludingBusyTimesFromLimits(createParams(), {
user,
eventType,
rescheduleUid: "reschedule-uid-123",
});
expect(mockBusyTimesService.getBusyTimesForLimitChecks).toHaveBeenCalledWith({
userIds: [1],
eventTypeId: 100,
startDate: LIMIT_DATE_FROM_FORMATTED,
endDate: LIMIT_DATE_TO_FORMATTED,
rescheduleUid: "reschedule-uid-123",
bookingLimits: { PER_DAY: 3 },
durationLimits: null,
});
});
});