Skip to content

Scheduling infrastructure for absolutely everyone.

Revert "feat: add race condition test for calendar-cache-serve booking flow (…" (#22400)

Omar López2fb2458eeefd
diff --git a/apps/web/playwright/booking-race-condition.e2e.ts b/apps/web/playwright/booking-race-condition.e2e.ts
deleted file mode 100644
index b2e3c4a0ad4..00000000000
--- a/apps/web/playwright/booking-race-condition.e2e.ts
+++ /dev/null
@@ -1,455 +0,0 @@
-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 } 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 { targetHost, calendarCacheHits } = await setupCalendarCache(teamMembers);
- await enableCalendarCacheFeatures(team.id);
-
- const { firstResponse, secondResponse } = await performConcurrentBookings(
- page,
- browser,
- org,
- team,
- teamEvent
- );
-
- const bookingResults = await analyzeBookingResults(teamEvent.id, firstResponse, secondResponse);
-
- // Validate race condition prevention
- expect(bookingResults.isRaceConditionPrevented).toBe(true);
-
- // Log results for monitoring
- console.log("Race condition prevention test results:", {
- totalBookings: bookingResults.bookings.length,
- responseStatuses: bookingResults.responseStatuses,
- sameHostSelected: bookingResults.sameHostSelected,
- preventionMechanism: bookingResults.preventionMechanism,
- });
- });
-});
-
-// Helper Functions
-
-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 },
- include: { user: true },
- });
-
- const teamMembers = teamMemberships.map((membership) => membership.user);
-
- return { org, team, teamEvent, teamMembers };
-}
-
-async function setupGoogleCalendarCredentials(teamMembers: User[]) {
- // Ensure Google Calendar app exists
- const googleCalendarApp = await prisma.app.findFirst({
- where: { slug: "google-calendar" },
- });
-
- if (!googleCalendarApp) {
- await prisma.app.create({
- data: {
- slug: "google-calendar",
- dirName: "google-calendar",
- },
- });
- }
-
- // Create credentials for each team member
- 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) {
- // Create identical booking histories to ensure deterministic round-robin behavior
- // This prevents random host selection from interfering with race condition testing
- const identicalTimestamp = new Date(Date.now() - 24 * 60 * 60 * 1000);
-
- for (const member of teamMembers) {
- // Create multiple bookings with identical timestamps
- 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 setupCalendarCache(teamMembers: User[]) {
- // Set up calendar cache with stale data to test cache functionality
- // This simulates the production scenario where cache shows availability
- // but real calendar API might show different data
- const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000);
- const cacheTimeRange = {
- timeMin: getTimeMin(tomorrow.toISOString()),
- timeMax: getTimeMax(tomorrow.toISOString()),
- };
-
- 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]; // First host should be selected by round-robin
- 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! }],
- };
-
- // Cache shows target host as available, others as busy
- // This ensures deterministic host selection during concurrent requests
- const availabilityData = {
- kind: "calendar#freeBusy",
- calendars: {
- [member.email!]: {
- busy:
- member.id === targetHost.id
- ? []
- : [
- {
- start: "2025-07-02T08:00:00.000Z",
- end: "2025-07-02T08: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) {
- // Mock Google Calendar API to simulate real-world calendar data
- // This creates a mismatch with cache data to test cache functionality
- await page.route("**/calendar/v3/freeBusy**", async (route: Route) => {
- const mockResponse = {
- kind: "calendar#freeBusy",
- calendars: {
- busy: [
- {
- start: "2025-07-02T08:00:00.000Z",
- end: "2025-07-02T09:00:00.000Z",
- },
- ],
- },
- busy: [
- {
- start: "2025-07-02T08:00:00.000Z",
- end: "2025-07-02T09:00:00.000Z",
- },
- ],
- },
- busy: [
- {
- start: "2025-07-02T08:00:00.000Z",
- end: "2025-07-02T09:00:00.000Z",
- },
- ],
- },
- },
- };
-
- await route.fulfill({
- status: 200,
- headers: { "Content-Type": "application/json" },
- body: JSON.stringify(mockResponse),
- });
- });
-}
-
-// Local type for org/team with parsed metadata
-export type TeamWithMetadata = Team & { metadata: z.infer<typeof teamMetadataSchema> };
-
-async function performConcurrentBookings(
- page: Page,
- browser: Browser,
- org: TeamWithMetadata,
- team: TeamWithMetadata,
- teamEvent: EventType
-) {
- 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();
-
- // Apply API mocking
- await mockGoogleCalendarAPI(page1);
- await mockGoogleCalendarAPI(page2);
-
- // Navigate to booking page
- await page1.goto(`/org/${org.slug}/${team.slug}/${teamEvent.slug}`);
- await page2.goto(`/org/${org.slug}/${team.slug}/${teamEvent.slug}`);
-
- // Select tomorrow's date
- const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000);
- const targetDay = tomorrow.getDate().toString();
-
- await page1
- .locator(`[data-testid="day"][data-disabled="false"]`)
- .filter({ hasText: new RegExp(`^${targetDay}$`) })
- .click();
- await page2
- .locator(`[data-testid="day"][data-disabled="false"]`)
- .filter({ hasText: new RegExp(`^${targetDay}$`) })
- .click();
-
- // Select first available time slot
- await page1.locator('[data-testid="time"]').nth(0).waitFor();
- await page2.locator('[data-testid="time"]').nth(0).waitFor();
- await page1.locator('[data-testid="time"]').nth(0).click();
- await page2.locator('[data-testid="time"]').nth(0).click();
-
- // Set up response listeners
- const responsePromise1 = page1.waitForResponse((response) => response.url().includes("/api/book/event"));
- const responsePromise2 = page2.waitForResponse((response) => response.url().includes("/api/book/event"));
-
- // Execute concurrent bookings
- const bookingPromise1 = bookTimeSlot(page1, {
- name: "Guest A",
- email: "[email protected]",
- expectedStatusCode: undefined,
- });
-
- const bookingPromise2 = bookTimeSlot(page2, {
- name: "Guest B",
- email: "[email protected]",
- expectedStatusCode: undefined,
- });
-
- // Wait for both bookings to complete
- await Promise.allSettled([bookingPromise1, bookingPromise2]);
- const [firstResponseLocal, secondResponseLocal] = await Promise.all([responsePromise1, responsePromise2]);
-
- firstResponse = firstResponseLocal;
- secondResponse = secondResponseLocal;
-
- // Verify success pages for successful bookings
- if (firstResponse && firstResponse.status() === 200) {
- await expect(page1.getByTestId("success-page")).toBeVisible();
- }
- if (secondResponse && secondResponse.status() === 200) {
- await expect(page2.getByTestId("success-page")).toBeVisible();
- }
-
- await context1.close();
- await context2.close();
- });
-
- return { firstResponse, secondResponse };
-}
-
-async function analyzeBookingResults(
- eventTypeId: number,
- firstResponse: Response | undefined,
- secondResponse: Response | undefined
-) {
- if (!firstResponse || !secondResponse) {
- throw new Error("Booking response(s) missing");
- }
- const bookings = await prisma.booking.findMany({
- where: {
- eventTypeId,
- status: "ACCEPTED",
- attendees: {
- some: {
- email: {
- },
- },
- },
- },
- include: {
- attendees: true,
- user: true,
- },
- });
-
- const responseStatuses = [firstResponse.status(), secondResponse.status()].sort();
- const bothSucceeded = responseStatuses.every((s) => s === 200);
- const hasConflict = responseStatuses.includes(200) && responseStatuses.includes(409);
- const sameHostSelected = bookings.length === 2 && bookings[0].userId === bookings[1].userId;
-
- // Determine prevention mechanism
- const isRaceConditionPrevented = hasConflict || (bothSucceeded && !sameHostSelected);
-
- let preventionMechanism = "unknown";
- if (hasConflict) {
- preventionMechanism = "unique_constraint_violation";
- } else if (bothSucceeded && !sameHostSelected) {
- preventionMechanism = "round_robin_distribution";
- } else if (bothSucceeded && sameHostSelected) {
- preventionMechanism = "none_detected";
- }
-
- return {
- bookings,
- responseStatuses,
- bothSucceeded,
- hasConflict,
- sameHostSelected,
- isRaceConditionPrevented,
- preventionMechanism,
- };
-}