@htlkg/data 0.0.19 → 0.0.21

package/src/mutations/reservations.test.ts

@@ -0,0 +1,459 @@
+/**
+ * Reservation Mutation Tests
+ *
+ * Tests for reservation CRUD operations including date validation,
+ * status transitions, soft delete, and restoration.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+	createReservation,
+	updateReservation,
+	softDeleteReservation,
+	restoreReservation,
+	deleteReservation,
+	updateReservationStatus,
+	ReservationValidationError,
+	type ReservationStatus,
+} from "./reservations";
+
+// Mock the systemSettings query functions
+vi.mock("../queries/systemSettings", () => ({
+	checkRestoreEligibility: vi.fn((deletedAt: string | null, retentionDays: number) => {
+		if (!deletedAt) {
+			return { canRestore: false, daysRemaining: 0, daysExpired: 0 };
+		}
+		const deletedDate = new Date(deletedAt);
+		const now = new Date();
+		const diffMs = now.getTime() - deletedDate.getTime();
+		const diffDays = diffMs / (1000 * 60 * 60 * 24);
+
+		if (diffDays > retentionDays) {
+			return {
+				canRestore: false,
+				daysRemaining: 0,
+				daysExpired: Math.floor(diffDays - retentionDays),
+			};
+		}
+
+		return {
+			canRestore: true,
+			daysRemaining: Math.ceil(retentionDays - diffDays),
+			daysExpired: 0,
+		};
+	}),
+	DEFAULT_SOFT_DELETE_RETENTION_DAYS: 30,
+}));
+
+describe("Reservation Mutations", () => {
+	describe("createReservation", () => {
+		const validInput = {
+			brandId: "brand-123",
+			visitId: "visit-456",
+			confirmationCode: "ABC123",
+			checkIn: "2024-06-01",
+			checkOut: "2024-06-05",
+			status: "confirmed" as const,
+			source: "direct",
+			room: "101",
+		};
+
+		it("should create a reservation with valid dates", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", ...validInput },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			const result = await createReservation(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe("reservation-001");
+			expect(mockCreate).toHaveBeenCalledTimes(1);
+		});
+
+		it("should calculate nights automatically when not provided", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			await createReservation(mockClient, validInput);
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			expect(callArgs.nights).toBe(4); // June 1 to June 5 = 4 nights
+		});
+
+		it("should throw ReservationValidationError for invalid check-in date", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "invalid-date",
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				ReservationValidationError
+			);
+		});
+
+		it("should throw ReservationValidationError when check-out is before check-in", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "2024-06-05",
+				checkOut: "2024-06-01",
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				"Check-out date must be after check-in date"
+			);
+		});
+
+		it("should throw ReservationValidationError for minimum stay violation", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "2024-06-01T10:00:00",
+				checkOut: "2024-06-01T11:00:00", // Only 1 hour
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				"Minimum stay is 4 hours"
+			);
+		});
+
+		it("should return null when GraphQL returns errors", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Database error" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			const result = await createReservation(mockClient, validInput);
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("updateReservation", () => {
+		it("should update a reservation without status change", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", room: "202" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateReservation(mockClient, {
+				id: "reservation-001",
+				room: "202",
+			});
+
+			expect(result).toBeTruthy();
+			expect(mockUpdate).toHaveBeenCalledWith({ id: "reservation-001", room: "202" });
+		});
+
+		it("should validate status transition when status is being changed", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", status: "checked_out" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: {
+						get: mockGet,
+						update: vi.fn(),
+					},
+				},
+			};
+
+			// Try to change from checked_out to confirmed (not allowed)
+			await expect(
+				updateReservation(mockClient, {
+					id: "reservation-001",
+					status: "confirmed",
+				})
+			).rejects.toThrow(ReservationValidationError);
+		});
+
+		it("should recalculate nights when dates are updated", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			await updateReservation(mockClient, {
+				id: "reservation-001",
+				checkIn: "2024-06-01",
+				checkOut: "2024-06-10",
+			});
+
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.nights).toBe(9); // 9 nights
+		});
+	});
+
+	describe("updateReservationStatus", () => {
+		const statusTransitionTests: Array<{
+			from: ReservationStatus;
+			to: ReservationStatus;
+			allowed: boolean;
+		}> = [
+			{ from: "confirmed", to: "checked_in", allowed: true },
+			{ from: "confirmed", to: "cancelled", allowed: true },
+			{ from: "confirmed", to: "no_show", allowed: true },
+			{ from: "confirmed", to: "checked_out", allowed: false },
+			{ from: "checked_in", to: "checked_out", allowed: true },
+			{ from: "checked_in", to: "cancelled", allowed: true },
+			{ from: "checked_in", to: "confirmed", allowed: false },
+			{ from: "checked_out", to: "confirmed", allowed: false },
+			{ from: "checked_out", to: "checked_in", allowed: false },
+			{ from: "cancelled", to: "confirmed", allowed: false },
+			{ from: "no_show", to: "confirmed", allowed: false },
+		];
+
+		statusTransitionTests.forEach(({ from, to, allowed }) => {
+			it(`should ${allowed ? "allow" : "reject"} transition from '${from}' to '${to}'`, async () => {
+				const mockGet = vi.fn().mockResolvedValue({
+					data: { id: "reservation-001", status: from },
+					errors: null,
+				});
+				const mockUpdate = vi.fn().mockResolvedValue({
+					data: { id: "reservation-001", status: to },
+					errors: null,
+				});
+
+				const mockClient = {
+					models: {
+						Reservation: {
+							get: mockGet,
+							update: mockUpdate,
+						},
+					},
+				};
+
+				if (allowed) {
+					const result = await updateReservationStatus(mockClient, "reservation-001", to);
+					expect(result).toBeTruthy();
+					expect(mockUpdate).toHaveBeenCalledWith({ id: "reservation-001", status: to });
+				} else {
+					await expect(
+						updateReservationStatus(mockClient, "reservation-001", to)
+					).rejects.toThrow(ReservationValidationError);
+				}
+			});
+		});
+
+		it("should return null when reservation not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await updateReservationStatus(mockClient, "nonexistent", "checked_in");
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("softDeleteReservation", () => {
+		it("should set deletedAt and deletedBy", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteReservation(
+				mockClient,
+				"reservation-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(true);
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.id).toBe("reservation-001");
+			expect(callArgs.deletedAt).toBeDefined();
+			expect(callArgs.deletedBy).toBe("admin@example.com");
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Error" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteReservation(
+				mockClient,
+				"reservation-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("restoreReservation", () => {
+		it("should restore a recently deleted reservation", async () => {
+			const recentDeletedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(); // 5 days ago
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", deletedAt: recentDeletedAt },
+				errors: null,
+			});
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: mockUpdate },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "reservation-001");
+
+			expect(result.success).toBe(true);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: "reservation-001",
+				deletedAt: null,
+				deletedBy: null,
+			});
+		});
+
+		it("should reject restoration after retention period expires", async () => {
+			const oldDeletedAt = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString(); // 60 days ago
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", deletedAt: oldDeletedAt },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "reservation-001", 30);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Retention period");
+		});
+
+		it("should return error when reservation not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "nonexistent");
+
+			expect(result.success).toBe(false);
+			expect(result.error).toBe("Reservation not found");
+		});
+	});
+
+	describe("deleteReservation", () => {
+		it("should permanently delete a reservation", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteReservation(mockClient, "reservation-001");
+
+			expect(result).toBe(true);
+			expect(mockDelete).toHaveBeenCalledWith({ id: "reservation-001" });
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Cannot delete" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteReservation(mockClient, "reservation-001");
+
+			expect(result).toBe(false);
+		});
+	});
+});