Scheduling infrastructure for absolutely everyone.
fix: flaky E2E tests and refactor (#25974)
Anik Dhabal Babu4beebd227b3c
diff --git a/apps/web/playwright/booking-limits.e2e.ts b/apps/web/playwright/booking-limits.e2e.tsindex b45591218af..f5349aab08f 100644--- a/apps/web/playwright/booking-limits.e2e.ts+++ b/apps/web/playwright/booking-limits.e2e.ts@@ -7,7 +7,6 @@ import { expect } from "@playwright/test";import type { Dayjs } from "@calcom/dayjs";import dayjs from "@calcom/dayjs";import { intervalLimitKeyToUnit } from "@calcom/lib/intervalLimits/intervalLimit";-import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";import prisma from "@calcom/prisma";import { BookingStatus } from "@calcom/prisma/enums";import { entries } from "@calcom/prisma/zod-utils";@@ -199,25 +198,19 @@ test.describe("Booking limits", () => {});});- test("multiple", async ({ page, users }) => {- const slug = "booking-limit-multiple";+ test.describe("multiple limits", () => {+ test("day limit with multiple limits set", async ({ page, users }) => {+ const slug = "booking-limit-multiple-day";- const user = await createUserWithLimits({- users,- slug,- length: EVENT_LENGTH,- bookingLimits: BOOKING_LIMITS_MULTIPLE,- });-- let slotUrl = "";-- let bookingDate = firstMondayInBookingMonth;-- // keep track of total bookings across multiple limits- let bookingCount = 0;+ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ bookingLimits: BOOKING_LIMITS_MULTIPLE,+ });- for (const [limitKey, limitValue] of entries(BOOKING_LIMITS_MULTIPLE)) {- const limitUnit = intervalLimitKeyToUnit(limitKey);+ const bookingDate = firstMondayInBookingMonth;+ const limitValue = BOOKING_LIMITS_MULTIPLE.PER_DAY;const monthUrl = getLastEventUrlWithMonth(user, bookingDate);await page.goto(monthUrl);@@ -227,16 +220,16 @@ test.describe("Booking limits", () => {// finish rendering days before countingawait expect(bookingDay).toBeVisible({ timeout: 10_000 });-const availableDaysBefore = await availableDays.count();- await test.step(`can book up ${limitUnit} to limit`, async () => {- for (let i = 0; i + bookingCount < limitValue; i++) {+ let slotUrl = "";++ await test.step("can book up to day limit", async () => {+ for (let i = 0; i < limitValue; i++) {await bookingDay.click();await page.getByTestId("time").nth(0).click();await bookTimeSlot(page);- bookingCount++;slotUrl = page.url();@@ -246,13 +239,6 @@ test.describe("Booking limits", () => {}});- const expectedAvailableDays = {- day: -1,- week: -4, // one day will already be blocked by daily limit- month: 0,- year: 0,- };-await test.step("but not over", async () => {// should already have navigated to monthUrl - just ensure days are renderedawait expect(page.getByTestId("day").nth(0)).toBeVisible();@@ -263,66 +249,138 @@ test.describe("Booking limits", () => {const availableDaysAfter = await availableDays.count();// equals 0 if no available days, otherwise signed difference- expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(- expectedAvailableDays[limitUnit]- );+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(-1);// try to book directly via form pageawait page.goto(slotUrl);await expectSlotNotAllowedToBook(page);});+ });- await test.step(`month after booking`, async () => {- await page.goto(getLastEventUrlWithMonth(user, bookingDate.add(1, "month")));+ test("week limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "booking-limit-multiple-week";- // finish rendering days before counting- await expect(page.getByTestId("day").nth(0)).toBeVisible({ timeout: 10_000 });+ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ bookingLimits: BOOKING_LIMITS_MULTIPLE,+ });- // the month after we made bookings should have availability unless we hit a yearly limit- // TODO: Temporary fix for failing test. It passes locally but fails on CI.- // See #13097- // await expect((await availableDays.count()) === 0).toBe(limitUnit === "year");+ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ // Pre-create 1 booking on Monday (same week as UI booking)+ // This satisfies the daily limit for Monday and counts toward the weekly limit+ const preBookingDate = baseBookingDate.hour(10).minute(0);+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: preBookingDate.toDate(),+ endTime: preBookingDate.add(EVENT_LENGTH, "minutes").toDate(),});- // increment date by unit after hitting each limit- bookingDate = incrementDate(bookingDate, limitUnit);- }- });-});+ // Test week limit on Tuesday (same week, different day to avoid daily limit conflict)+ // Need to book 1 more to hit weekly limit of 2 (1 already exists from pre-booking)+ const bookingDate = baseBookingDate.add(1, "day");+ const weekLimitValue = BOOKING_LIMITS_MULTIPLE.PER_WEEK;+ const bookingsToMake = weekLimitValue - 1;-test.describe("Duration limits", () => {- entries(BOOKING_LIMITS_SINGLE).forEach(([limitKey, bookingLimit]) => {- const limitUnit = intervalLimitKeyToUnit(limitKey);+ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);+ await page.goto(monthUrl);- // test one limit at a time- test(limitUnit, async ({ page, users }) => {- const slug = `duration-limit-${limitUnit}`;- const singleLimit = { [limitKey]: bookingLimit * EVENT_LENGTH };+ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ let slotUrl = "";++ await test.step("can book up to week limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // After hitting weekly limit, all remaining days in the week should be blocked+ // Monday was already blocked by daily limit, Tuesday is now blocked+ // The remaining weekdays (Wed-Fri) should also be blocked = 3 more days+ // Total blocked: 1 (Tuesday we just booked) + 3 (Wed-Fri) = 4 days+ // But Monday was already blocked before we started, so delta is -4+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(-4);++ // try to book directly via form page+ await page.goto(slotUrl);++ await expectSlotNotAllowedToBook(page);+ });+ });++ test("month limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "booking-limit-multiple-month";const user = await createUserWithLimits({users,slug,length: EVENT_LENGTH,- durationLimits: singleLimit,+ bookingLimits: BOOKING_LIMITS_MULTIPLE,});- let slotUrl = "";+ // Pre-create bookings for day (1) and week (2 total, so 1 more) limits+ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ // Create 2 bookings (day limit: 1, week limit: 2 total)+ // First booking on Monday at 10:00, second on Tuesday at 10:00+ for (let i = 0; i < 2; i++) {+ const date = baseBookingDate.add(i, "day").hour(10).minute(0);+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: date.toDate(),+ endTime: date.add(EVENT_LENGTH, "minutes").toDate(),+ });+ }- const monthUrl = getLastEventUrlWithMonth(user, firstMondayInBookingMonth);+ // Test month limit - need to book 1 more (total 3, but 2 already exist)+ // Move to next week for month limit test (similar to week limit test)+ const bookingDate = baseBookingDate.add(1, "week");+ const monthLimitValue = BOOKING_LIMITS_MULTIPLE.PER_MONTH;+ const bookingsToMake = monthLimitValue - 2; // 2 already exist from previous limits++ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);await page.goto(monthUrl);const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');- const bookingDay = availableDays.getByText(firstMondayInBookingMonth.date().toString(), {- exact: true,- });+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });// finish rendering days before countingawait expect(bookingDay).toBeVisible({ timeout: 10_000 });const availableDaysBefore = await availableDays.count();- await test.step("can book up to limit", async () => {- for (let i = 0; i < bookingLimit; i++) {+ let slotUrl = "";++ await test.step("can book up to month limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {await bookingDay.click();await page.getByTestId("time").nth(0).click();@@ -336,13 +394,6 @@ test.describe("Duration limits", () => {}});- const expectedAvailableDays = {- day: -1,- week: -5,- month: 0,- year: 0,- };-await test.step("but not over", async () => {// should already have navigated to monthUrl - just ensure days are renderedawait expect(page.getByTestId("day").nth(0)).toBeVisible();@@ -353,54 +404,52 @@ test.describe("Duration limits", () => {const availableDaysAfter = await availableDays.count();// equals 0 if no available days, otherwise signed difference- expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(- expectedAvailableDays[limitUnit]- );+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(0);// try to book directly via form pageawait page.goto(slotUrl);- await expectSlotNotAllowedToBook(page);- });- await test.step(`month after booking`, async () => {- await page.goto(getLastEventUrlWithMonth(user, firstMondayInBookingMonth.add(1, "month")));-- // finish rendering days before counting- await expect(page.getByTestId("day").nth(0)).toBeVisible({ timeout: 10_000 });-- // the month after we made bookings should have availability unless we hit a yearly limit- await expect((await availableDays.count()) === 0).toBe(limitUnit === "year");+ await expectSlotNotAllowedToBook(page);});});- });- test("multiple", async ({ page, users }) => {- const slug = "duration-limit-multiple";+ test("year limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "booking-limit-multiple-year";- // multiply all booking limits by EVENT_LENGTH- const durationLimits = entries(BOOKING_LIMITS_MULTIPLE).reduce((limits, [limitKey, bookingLimit]) => {- return {- ...limits,- [limitKey]: bookingLimit * EVENT_LENGTH,- };- }, {} as Record<keyof IntervalLimit, number>);-- const user = await createUserWithLimits({- users,- slug,- length: EVENT_LENGTH,- durationLimits,- });-- let slotUrl = "";+ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ bookingLimits: BOOKING_LIMITS_MULTIPLE,+ });- let bookingDate = firstMondayInBookingMonth;+ // Pre-create bookings for day (1), week (2 total), and month (3 total) limits+ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ // Create 3 bookings (day: 1, week: 2, month: 3 total)+ // Spread across different days to satisfy day/week/month limits+ // Monday, Tuesday, and next Monday (to span a week)+ const dates = [+ baseBookingDate.hour(10).minute(0),+ baseBookingDate.add(1, "day").hour(10).minute(0),+ baseBookingDate.add(1, "week").hour(10).minute(0),+ ];++ for (const date of dates) {+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: date.toDate(),+ endTime: date.add(EVENT_LENGTH, "minutes").toDate(),+ });+ }- // keep track of total bookings across multiple limits- let bookingCount = 0;+ // Test year limit - need to book 1 more (total 4, but 3 already exist)+ const yearLimitValue = BOOKING_LIMITS_MULTIPLE.PER_YEAR;+ const bookingsToMake = yearLimitValue - 3; // 3 already exist from previous limits- for (const [limitKey, limitValue] of entries(BOOKING_LIMITS_MULTIPLE)) {- const limitUnit = intervalLimitKeyToUnit(limitKey);+ // Move to next month for year limit test+ const bookingDate = incrementDate(baseBookingDate, "month");const monthUrl = getLastEventUrlWithMonth(user, bookingDate);await page.goto(monthUrl);@@ -410,16 +459,16 @@ test.describe("Duration limits", () => {// finish rendering days before countingawait expect(bookingDay).toBeVisible({ timeout: 10_000 });-const availableDaysBefore = await availableDays.count();- await test.step(`can book up ${limitUnit} to limit`, async () => {- for (let i = 0; i + bookingCount < limitValue; i++) {+ let slotUrl = "";++ await test.step("can book up to year limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {await bookingDay.click();await page.getByTestId("time").nth(0).click();await bookTimeSlot(page);- bookingCount++;slotUrl = page.url();@@ -429,13 +478,6 @@ test.describe("Duration limits", () => {}});- const expectedAvailableDays = {- day: -1,- week: -4, // one day will already be blocked by daily limit- month: 0,- year: 0,- };-await test.step("but not over", async () => {// should already have navigated to monthUrl - just ensure days are renderedawait expect(page.getByTestId("day").nth(0)).toBeVisible();@@ -446,27 +488,13 @@ test.describe("Duration limits", () => {const availableDaysAfter = await availableDays.count();// equals 0 if no available days, otherwise signed difference- expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(- expectedAvailableDays[limitUnit]- );+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(0);// try to book directly via form pageawait page.goto(slotUrl);- await expectSlotNotAllowedToBook(page);- });-- await test.step(`month after booking`, async () => {- await page.goto(getLastEventUrlWithMonth(user, bookingDate.add(1, "month")));- // finish rendering days before counting- await expect(page.getByTestId("day").nth(0)).toBeVisible({ timeout: 10_000 });-- // the month after we made bookings should have availability unless we hit a yearly limit- await expect((await availableDays.count()) === 0).toBe(limitUnit === "year");+ await expectSlotNotAllowedToBook(page);});-- // increment date by unit after hitting each limit- bookingDate = incrementDate(bookingDate, limitUnit);- }+ });});});diff --git a/apps/web/playwright/duration-limits.e2e.ts b/apps/web/playwright/duration-limits.e2e.tsnew file mode 100644index 00000000000..5f4eaec52d9--- /dev/null+++ b/apps/web/playwright/duration-limits.e2e.ts@@ -0,0 +1,460 @@+/**+ * These e2e tests only aim to cover standard cases+ * Edge cases are currently handled in integration tests only+ */+import { expect } from "@playwright/test";++import type { Dayjs } from "@calcom/dayjs";+import dayjs from "@calcom/dayjs";+import { intervalLimitKeyToUnit } from "@calcom/lib/intervalLimits/intervalLimit";+import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";+import { entries } from "@calcom/prisma/zod-utils";++import { test } from "./lib/fixtures";+import { bookTimeSlot, createUserWithLimits, expectSlotNotAllowedToBook } from "./lib/testUtils";++test.describe.configure({ mode: "parallel" });+test.afterEach(async ({ users }) => {+ await users.deleteAll();+});++// used as a multiplier for duration limits+const EVENT_LENGTH = 30;++// limits used when testing each limit separately+const BOOKING_LIMITS_SINGLE = {+ PER_DAY: 2,+ PER_WEEK: 2,+ PER_MONTH: 2,+ PER_YEAR: 2,+};++// limits used when testing multiple limits together+const BOOKING_LIMITS_MULTIPLE = {+ PER_DAY: 1,+ PER_WEEK: 2,+ PER_MONTH: 3,+ PER_YEAR: 4,+};++// prevent tests from crossing year boundaries - if currently in Oct or later, start booking in Jan instead of Nov+// (we increment months twice when checking multiple limits)+const firstDayInBookingMonth =+ dayjs().month() >= 9 ? dayjs().add(1, "year").month(0).date(1) : dayjs().add(1, "month").date(1);++// avoid weekly edge cases+const firstMondayInBookingMonth = firstDayInBookingMonth.day(+ firstDayInBookingMonth.date() === firstDayInBookingMonth.startOf("week").date() ? 1 : 8+);++// ensure we land on the same weekday when incrementing month+const incrementDate = (date: Dayjs, unit: dayjs.ManipulateType) => {+ if (unit !== "month") return date.add(1, unit);+ return date.add(1, "month").day(date.day());+};++const getLastEventUrlWithMonth = (user: Awaited<ReturnType<typeof createUserWithLimits>>, date: Dayjs) => {+ return `/${user.username}/${user.eventTypes.at(-1)?.slug}?month=${date.format("YYYY-MM")}`;+};++test.describe("Duration limits", () => {+ entries(BOOKING_LIMITS_SINGLE).forEach(([limitKey, bookingLimit]) => {+ const limitUnit = intervalLimitKeyToUnit(limitKey);++ // test one limit at a time+ test(limitUnit, async ({ page, users }) => {+ const slug = `duration-limit-${limitUnit}`;+ const singleLimit = { [limitKey]: bookingLimit * EVENT_LENGTH };++ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ durationLimits: singleLimit,+ });++ let slotUrl = "";++ const monthUrl = getLastEventUrlWithMonth(user, firstMondayInBookingMonth);+ await page.goto(monthUrl);++ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(firstMondayInBookingMonth.date().toString(), {+ exact: true,+ });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ await test.step("can book up to limit", async () => {+ for (let i = 0; i < bookingLimit; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ const expectedAvailableDays = {+ day: -1,+ week: -5,+ month: 0,+ year: 0,+ };++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // equals 0 if no available days, otherwise signed difference+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(+ expectedAvailableDays[limitUnit]+ );++ // try to book directly via form page+ await page.goto(slotUrl);+ await expectSlotNotAllowedToBook(page);+ });++ await test.step(`month after booking`, async () => {+ await page.goto(getLastEventUrlWithMonth(user, firstMondayInBookingMonth.add(1, "month")));++ // finish rendering days before counting+ await expect(page.getByTestId("day").nth(0)).toBeVisible({ timeout: 10_000 });++ // the month after we made bookings should have availability unless we hit a yearly limit+ await expect((await availableDays.count()) === 0).toBe(limitUnit === "year");+ });+ });+ });++ test.describe("multiple limits", () => {+ test("day limit with multiple limits set", async ({ page, users }) => {+ const slug = "duration-limit-multiple-day";++ const durationLimits = entries(BOOKING_LIMITS_MULTIPLE).reduce((limits, [limitKey, bookingLimit]) => {+ return {+ ...limits,+ [limitKey]: bookingLimit * EVENT_LENGTH,+ };+ }, {} as Record<keyof IntervalLimit, number>);++ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ durationLimits,+ });++ const bookingDate = firstMondayInBookingMonth;+ const limitValue = BOOKING_LIMITS_MULTIPLE.PER_DAY;++ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);+ await page.goto(monthUrl);++ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ let slotUrl = "";++ await test.step("can book up to day limit", async () => {+ for (let i = 0; i < limitValue; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // equals 0 if no available days, otherwise signed difference+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(-1);++ // try to book directly via form page+ await page.goto(slotUrl);++ await expectSlotNotAllowedToBook(page);+ });+ });++ test("week limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "duration-limit-multiple-week";++ const durationLimits = entries(BOOKING_LIMITS_MULTIPLE).reduce((limits, [limitKey, bookingLimit]) => {+ return {+ ...limits,+ [limitKey]: bookingLimit * EVENT_LENGTH,+ };+ }, {} as Record<keyof IntervalLimit, number>);++ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ durationLimits,+ });++ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ // Pre-create 1 booking on Monday (same week as UI booking)+ // This satisfies the daily limit for Monday and counts toward the weekly limit+ const preBookingDate = baseBookingDate.hour(10).minute(0);+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: preBookingDate.toDate(),+ endTime: preBookingDate.add(EVENT_LENGTH, "minutes").toDate(),+ });++ // Test week limit on Tuesday (same week, different day to avoid daily limit conflict)+ // Need to book 1 more to hit weekly limit of 2 (1 already exists from pre-booking)+ const bookingDate = baseBookingDate.add(1, "day");+ const weekLimitValue = BOOKING_LIMITS_MULTIPLE.PER_WEEK;+ const bookingsToMake = weekLimitValue - 1;++ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);+ await page.goto(monthUrl);++ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ let slotUrl = "";++ await test.step("can book up to week limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // After hitting weekly limit, all remaining days in the week should be blocked+ // Monday was already blocked by daily limit, Tuesday is now blocked+ // The remaining weekdays (Wed-Fri) should also be blocked = 3 more days+ // Total blocked: 1 (Tuesday we just booked) + 3 (Wed-Fri) = 4 days+ // But Monday was already blocked before we started, so delta is -4+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(-4);++ // try to book directly via form page+ await page.goto(slotUrl);++ await expectSlotNotAllowedToBook(page);+ });+ });++ test("month limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "duration-limit-multiple-month";++ const durationLimits = entries(BOOKING_LIMITS_MULTIPLE).reduce((limits, [limitKey, bookingLimit]) => {+ return {+ ...limits,+ [limitKey]: bookingLimit * EVENT_LENGTH,+ };+ }, {} as Record<keyof IntervalLimit, number>);++ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ durationLimits,+ });++ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ for (let i = 0; i < 2; i++) {+ const date = baseBookingDate.add(i, "day").hour(10).minute(0);+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: date.toDate(),+ endTime: date.add(EVENT_LENGTH, "minutes").toDate(),+ });+ }++ // Move to next week for month limit test (similar to booking-limits test)+ const bookingDate = baseBookingDate.add(1, "week");+ const monthLimitValue = BOOKING_LIMITS_MULTIPLE.PER_MONTH;+ const bookingsToMake = monthLimitValue - 2;++ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);+ await page.goto(monthUrl);++ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ let slotUrl = "";++ await test.step("can book up to month limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // equals 0 if no available days, otherwise signed difference+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(0);++ // try to book directly via form page+ await page.goto(slotUrl);++ await expectSlotNotAllowedToBook(page);+ });+ });++ test("year limit with multiple limits set", async ({ page, users, bookings }) => {+ const slug = "duration-limit-multiple-year";++ const durationLimits = entries(BOOKING_LIMITS_MULTIPLE).reduce((limits, [limitKey, bookingLimit]) => {+ return {+ ...limits,+ [limitKey]: bookingLimit * EVENT_LENGTH,+ };+ }, {} as Record<keyof IntervalLimit, number>);++ const user = await createUserWithLimits({+ users,+ slug,+ length: EVENT_LENGTH,+ durationLimits,+ });++ const baseBookingDate = firstMondayInBookingMonth;+ const eventTypeId = user.eventTypes.at(-1)?.id;+ if (!eventTypeId) throw new Error("Event type not found");++ const dates = [+ baseBookingDate.hour(10).minute(0),+ baseBookingDate.add(1, "day").hour(10).minute(0),+ baseBookingDate.add(1, "week").hour(10).minute(0),+ ];++ for (const date of dates) {+ await bookings.create(user.id, user.username, eventTypeId, {+ startTime: date.toDate(),+ endTime: date.add(EVENT_LENGTH, "minutes").toDate(),+ });+ }++ const yearLimitValue = BOOKING_LIMITS_MULTIPLE.PER_YEAR;+ const bookingsToMake = yearLimitValue - 3;++ const bookingDate = incrementDate(baseBookingDate, "month");++ const monthUrl = getLastEventUrlWithMonth(user, bookingDate);+ await page.goto(monthUrl);++ const availableDays = page.locator('[data-testid="day"][data-disabled="false"]');+ const bookingDay = availableDays.getByText(bookingDate.date().toString(), { exact: true });++ // finish rendering days before counting+ await expect(bookingDay).toBeVisible({ timeout: 10_000 });+ const availableDaysBefore = await availableDays.count();++ let slotUrl = "";++ await test.step("can book up to year limit", async () => {+ for (let i = 0; i < bookingsToMake; i++) {+ await bookingDay.click();++ await page.getByTestId("time").nth(0).click();+ await bookTimeSlot(page);++ slotUrl = page.url();++ await expect(page.getByTestId("success-page")).toBeVisible();++ await page.goto(monthUrl);+ }+ });++ await test.step("but not over", async () => {+ // should already have navigated to monthUrl - just ensure days are rendered+ await expect(page.getByTestId("day").nth(0)).toBeVisible();++ // ensure the day we just booked is now blocked+ await expect(bookingDay).toBeHidden({ timeout: 10_000 });++ const availableDaysAfter = await availableDays.count();++ // equals 0 if no available days, otherwise signed difference+ expect(availableDaysAfter && availableDaysAfter - availableDaysBefore).toBe(0);++ // try to book directly via form page+ await page.goto(slotUrl);++ await expectSlotNotAllowedToBook(page);+ });+ });+ });+});