Skip to content

Scheduling infrastructure for absolutely everyone.

feat: add race condition test with dynamic date selection (#22533)

Anik Dhabal Babud78ed21a9f98
diff --git a/apps/web/playwright/booking-race-condition.e2e.ts b/apps/web/playwright/booking-race-condition.e2e.ts
new file mode 100644
index 00000000000..0635f7dbee5
--- /dev/null
+++ b/apps/web/playwright/booking-race-condition.e2e.ts
@@ -0,0 +1,444 @@
+import { expect } from "@playwright/test";
+import type { Page, Browser, Route, Response } from "@playwright/test";
+import type { Team, EventType, User } from "@prisma/client";
+import type { z } from "zod";
+
+import { CalendarCacheRepository } from "@calcom/features/calendar-cache/calendar-cache.repository";
+import { getTimeMin, getTimeMax } from "@calcom/features/calendar-cache/lib/datesForCache";
+import { prisma } from "@calcom/prisma";
+import { MembershipRole, SchedulingType } from "@calcom/prisma/enums";
+import type { teamMetadataSchema } from "@calcom/prisma/zod-utils";
+
+import { test } from "./lib/fixtures";
+import type { Fixtures } from "./lib/fixtures";
+import { bookTimeSlot, doOnOrgDomain, selectFirstAvailableTimeSlotNextMonth } from "./lib/testUtils";
+
+/**
+ * Booking Race Condition Prevention Test
+ *
+ * This test validates that the calendar caching system and booking logic correctly
+ * prevent double-booking race conditions that occurred in production. It serves as
+ * a regression test to ensure the following mechanisms work properly:
+ *
+ * 1. **Race Condition Prevention**: Ensures concurrent booking requests for the same
+ * time slot don't result in double bookings to the same host.
+ *
+ * 2. **Calendar Cache Functionality**: Validates that the calendar cache system works
+ * correctly with proper cache key generation using expanded date ranges.
+ *
+ * 3. **Round-Robin Distribution**: Verifies that when both bookings succeed, they are
+ * distributed to different hosts as expected in round-robin scheduling.
+ *
+ * 4. **Database Constraint Protection**: Confirms that unique constraints prevent
+ * duplicate bookings when race conditions are detected.
+ *
+ * **Test Setup**:
+ * - Creates a round-robin team with multiple hosts
+ * - Populates calendar cache with deterministic availability data
+ * - Mocks Google Calendar API to simulate real-world scenarios
+ * - Executes concurrent booking requests at the same time slot
+ *
+ * **Expected Outcomes**:
+ * - [200, 409]: One booking succeeds, one fails due to constraint violation (preferred)
+ * - [200, 200]: Both succeed but distributed to different hosts (acceptable)
+ * - [200, 200] with same host: Double booking occurred (test failure - race condition)
+ *
+ * **Production Context**:
+ * The original race condition was caused by:
+ * - Stale calendar cache showing hosts as available
+ * - Microsecond timing differences in Date.valueOf() for idempotency keys
+ * - Both requests selecting the same host due to identical cache state
+ *
+ * This test recreates similar conditions but in a controlled way to verify
+ * the prevention mechanisms work correctly.
+ */
+
+test.describe("Booking Race Condition Prevention", () => {
+ test("Prevents double-booking race condition and validates cache functionality", async ({
+ page,
+ users,
+ orgs,
+ browser,
+ }) => {
+ const { org, team, teamEvent, teamMembers } = await setupTeamWithRoundRobin(users, orgs);
+
+ await setupGoogleCalendarCredentials(teamMembers);
+ await createIdenticalBookingHistories(teamMembers, teamEvent.id);
+
+ const { selectedDate, selectedDateISO } = await getDynamicBookingDate(page, org, team, teamEvent);
+
+ const { targetHost, calendarCacheHits } = await setupCalendarCache(teamMembers, selectedDateISO);
+ await enableCalendarCacheFeatures(team.id);
+
+ const { firstResponse, secondResponse } = await performConcurrentBookings(
+ page,
+ browser,
+ org,
+ team,
+ teamEvent,
+ selectedDate
+ );
+
+ const bookingResults = await analyzeBookingResults(teamEvent.id, firstResponse, secondResponse);
+
+ expect(bookingResults.isRaceConditionPrevented).toBe(true);
+
+ console.log("Race condition prevention test results:", {
+ totalBookings: bookingResults.bookings.length,
+ responseStatuses: bookingResults.responseStatuses,
+ sameHostSelected: bookingResults.sameHostSelected,
+ preventionMechanism: bookingResults.preventionMechanism,
+ });
+ });
+});
+
+async function setupTeamWithRoundRobin(users: Fixtures["users"], orgs: Fixtures["orgs"]) {
+ const org = await orgs.create({ name: "TestOrg" });
+ const teamMatesObj = [{ name: "teammate-1" }, { name: "teammate-2" }];
+
+ const owner = await users.create(
+ {
+ username: "pro-user",
+ name: "pro-user",
+ organizationId: org.id,
+ roleInOrganization: MembershipRole.MEMBER,
+ },
+ {
+ hasTeam: true,
+ teammates: teamMatesObj,
+ schedulingType: SchedulingType.ROUND_ROBIN,
+ }
+ );
+
+ const { team } = await owner.getFirstTeamMembership();
+ const teamEvent = await owner.getFirstTeamEvent(team.id);
+
+ const teamMemberships = await prisma.membership.findMany({
+ where: { teamId: team.id },
+ select: {
+ user: true,
+ },
+ });
+
+ const teamMembers = teamMemberships.map((membership) => membership.user);
+
+ return { org, team, teamEvent, teamMembers };
+}
+
+async function setupGoogleCalendarCredentials(teamMembers: User[]) {
+ const googleCalendarApp = await prisma.app.findFirst({
+ where: { slug: "google-calendar" },
+ });
+
+ if (!googleCalendarApp) {
+ await prisma.app.create({
+ data: {
+ slug: "google-calendar",
+ dirName: "google-calendar",
+ },
+ });
+ }
+
+ for (const member of teamMembers) {
+ await prisma.credential.create({
+ data: {
+ type: "google_calendar",
+ key: {
+ access_token: "test_access_token",
+ refresh_token: "test_refresh_token",
+ scope: "https://www.googleapis.com/auth/calendar.events",
+ token_type: "Bearer",
+ expiry_date: Date.now() + 3600000,
+ },
+ userId: member.id,
+ appId: "google-calendar",
+ invalid: false,
+ },
+ });
+ }
+}
+
+async function createIdenticalBookingHistories(teamMembers: User[], eventTypeId: number) {
+ const identicalTimestamp = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+ for (const member of teamMembers) {
+ for (let i = 0; i < 3; i++) {
+ await prisma.booking.create({
+ data: {
+ uid: `test-booking-${member.id}-${i}-${Date.now()}`,
+ title: `Test booking ${i}`,
+ startTime: new Date(Date.now() - (i + 2) * 24 * 60 * 60 * 1000),
+ endTime: new Date(Date.now() - (i + 2) * 24 * 60 * 60 * 1000 + 30 * 60 * 1000),
+ eventTypeId,
+ userId: member.id,
+ status: "ACCEPTED",
+ createdAt: identicalTimestamp,
+ updatedAt: identicalTimestamp,
+ attendees: {
+ create: {
+ email: `test${i}@example.com`,
+ name: `Test Attendee ${i}`,
+ timeZone: "UTC",
+ },
+ },
+ },
+ });
+ }
+ }
+}
+
+async function getDynamicBookingDate(
+ page: Page,
+ org: any,
+ team: any,
+ teamEvent: EventType
+): Promise<{ selectedDate: string; selectedDateISO: string }> {
+ await doOnOrgDomain({ orgSlug: org.slug, page }, async () => {
+ await page.goto(`/org/${org.slug}/${team.slug}/${teamEvent.slug}`);
+
+ await page.waitForSelector('[data-testid="day"]');
+
+ await page.getByTestId("incrementMonth").click();
+
+ await page.locator('[data-testid="day"][data-disabled="false"]').nth(0).waitFor();
+ });
+
+ const firstAvailableDayText = await page
+ .locator('[data-testid="day"][data-disabled="false"]')
+ .nth(0)
+ .textContent();
+
+ if (!firstAvailableDayText) {
+ throw new Error("No available day found");
+ }
+
+ const currentDate = new Date();
+ const nextMonth = new Date(
+ currentDate.getFullYear(),
+ currentDate.getMonth() + 1,
+ parseInt(firstAvailableDayText)
+ );
+ const selectedDateISO = nextMonth.toISOString();
+
+ return {
+ selectedDate: firstAvailableDayText,
+ selectedDateISO,
+ };
+}
+
+async function setupCalendarCache(teamMembers: User[], selectedDateISO: string) {
+ const cacheTimeRange = {
+ timeMin: getTimeMin(selectedDateISO),
+ timeMax: getTimeMax(selectedDateISO),
+ };
+
+ const credentials = await prisma.credential.findMany({
+ where: {
+ userId: { in: teamMembers.map((m) => m.id) },
+ type: "google_calendar",
+ },
+ });
+
+ const calendarCacheRepo = new CalendarCacheRepository(null);
+ const targetHost = teamMembers[0];
+ const calendarCacheHits: string[] = [];
+
+ for (let i = 0; i < credentials.length; i++) {
+ const credential = credentials[i];
+ const member = teamMembers[i];
+
+ const cacheArgs = {
+ timeMin: cacheTimeRange.timeMin,
+ timeMax: cacheTimeRange.timeMax,
+ items: [{ id: member.email! }],
+ };
+
+ const availabilityData = {
+ kind: "calendar#freeBusy",
+ calendars: {
+ [member.email!]: {
+ busy:
+ member.id === targetHost.id
+ ? []
+ : [
+ {
+ start: `${selectedDateISO.slice(0, 10)}T08:00:00.000Z`,
+ end: `${selectedDateISO.slice(0, 10)}T08:30:00.000Z`,
+ },
+ ],
+ },
+ },
+ };
+
+ await calendarCacheRepo.upsertCachedAvailability({
+ credentialId: credential.id,
+ userId: member.id,
+ args: cacheArgs,
+ value: availabilityData,
+ });
+
+ calendarCacheHits.push(`${member.email}-${credential.id}`);
+ }
+
+ return { targetHost, calendarCacheHits };
+}
+
+async function enableCalendarCacheFeatures(teamId: number) {
+ await prisma.teamFeatures.createMany({
+ data: [
+ {
+ teamId,
+ featureId: "calendar-cache",
+ assignedAt: new Date(),
+ assignedBy: "race-condition-test",
+ },
+ {
+ teamId,
+ featureId: "calendar-cache-serve",
+ assignedAt: new Date(),
+ assignedBy: "race-condition-test",
+ },
+ ],
+ });
+}
+
+async function mockGoogleCalendarAPI(page: Page, selectedDateISO: string) {
+ const busyStart = `${selectedDateISO.slice(0, 10)}T08:00:00.000Z`;
+ const busyEnd = `${selectedDateISO.slice(0, 10)}T09:00:00.000Z`;
+ await page.route("**/calendar/v3/freeBusy**", async (route: Route) => {
+ const mockResponse = {
+ kind: "calendar#freeBusy",
+ calendars: {
+ busy: [
+ {
+ start: busyStart,
+ end: busyEnd,
+ },
+ ],
+ },
+ busy: [
+ {
+ start: busyStart,
+ end: busyEnd,
+ },
+ ],
+ },
+ busy: [
+ {
+ start: busyStart,
+ end: busyEnd,
+ },
+ ],
+ },
+ },
+ };
+
+ await route.fulfill({
+ status: 200,
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(mockResponse),
+ });
+ });
+}
+
+export type TeamWithMetadata = Team & { metadata: z.infer<typeof teamMetadataSchema> };
+
+async function performConcurrentBookings(
+ page: Page,
+ browser: Browser,
+ org: TeamWithMetadata,
+ team: TeamWithMetadata,
+ teamEvent: EventType,
+ selectedDate: string
+) {
+ let firstResponse: Response | undefined;
+ let secondResponse: Response | undefined;
+
+ await doOnOrgDomain({ orgSlug: org.slug, page }, async () => {
+ const context1 = await browser.newContext();
+ const context2 = await browser.newContext();
+ const page1 = await context1.newPage();
+ const page2 = await context2.newPage();
+
+ const currentDate = new Date();
+ const nextMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, parseInt(selectedDate));
+ const selectedDateISO = nextMonth.toISOString();
+
+ await mockGoogleCalendarAPI(page1, selectedDateISO);
+ await mockGoogleCalendarAPI(page2, selectedDateISO);
+
+ await page1.goto(`/org/${org.slug}/${team.slug}/${teamEvent.slug}`);
+ await page2.goto(`/org/${org.slug}/${team.slug}/${teamEvent.slug}`);
+
+ await selectFirstAvailableTimeSlotNextMonth(page1);
+ await selectFirstAvailableTimeSlotNextMonth(page2);
+
+ const responsePromise1 = page1.waitForResponse(
+ (response) => response.url().includes("/api/book/event") && response.request().method() === "POST"
+ );
+ const responsePromise2 = page2.waitForResponse(
+ (response) => response.url().includes("/api/book/event") && response.request().method() === "POST"
+ );
+
+ const bookingPromise1 = bookTimeSlot(page1, {
+ name: "Test User 1",
+ email: "[email protected]",
+ });
+ const bookingPromise2 = bookTimeSlot(page2, {
+ name: "Test User 2",
+ email: "[email protected]",
+ });
+
+ const [response1, response2] = await Promise.all([responsePromise1, responsePromise2]);
+ await Promise.allSettled([bookingPromise1, bookingPromise2]);
+
+ firstResponse = response1;
+ secondResponse = response2;
+
+ await context1.close();
+ await context2.close();
+ });
+
+ return { firstResponse, secondResponse };
+}
+
+async function analyzeBookingResults(
+ eventTypeId: number,
+ firstResponse?: Response,
+ secondResponse?: Response
+) {
+ const bookings = await prisma.booking.findMany({
+ where: { eventTypeId },
+ include: { attendees: true },
+ orderBy: { createdAt: "desc" },
+ take: 10,
+ });
+
+ const responseStatuses = [firstResponse?.status(), secondResponse?.status()].filter(Boolean);
+
+ const recentBookings = bookings.slice(0, 2);
+ const sameHostSelected =
+ recentBookings.length === 2 && recentBookings[0].userId === recentBookings[1].userId;
+
+ let preventionMechanism = "unknown";
+ if (responseStatuses.includes(409)) {
+ preventionMechanism = "database-constraint";
+ } else if (responseStatuses.every((status) => status === 200) && !sameHostSelected) {
+ preventionMechanism = "round-robin-distribution";
+ } else if (sameHostSelected) {
+ preventionMechanism = "race-condition-occurred";
+ }
+
+ const isRaceConditionPrevented = preventionMechanism !== "race-condition-occurred";
+
+ return {
+ bookings,
+ responseStatuses,
+ sameHostSelected,
+ preventionMechanism,
+ isRaceConditionPrevented,
+ };
+}