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.tsnew file mode 100644index 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: {+ "[email protected]": {+ busy: [+ {+ start: busyStart,+ end: busyEnd,+ },+ ],+ },+ "[email protected]": {+ busy: [+ {+ start: busyStart,+ end: busyEnd,+ },+ ],+ },+ "[email protected]": {+ 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,+ };+}