feat: add comprehensive test suite for recent backend changes

backend/handlers/admin/bookings_extra_test.go

@@ -0,0 +1,159 @@
+//go:build test
+// +build test
+
+package admin
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"crussell/db"
+	"crussell/handlers/bookings"
+	"crussell/testutils/fixtures"
+)
+
+// TestGetOverlappingBookingsByTime verifies the new overlapping bookings endpoint
+func TestGetOverlappingBookingsByTime(t *testing.T) {
+	resetTestData(t)
+
+	adminID, err := fixtures.CreateTestAdminUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create admin user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, adminID)
+
+	userID, err := fixtures.CreateTestUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, userID)
+
+	serviceID, err := fixtures.CreateTestService(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test service: %v", err)
+	}
+	defer fixtures.DeleteService(db.DB, serviceID)
+
+	startTime := time.Date(2026, 3, 16, 10, 0, 0, 0, time.UTC)
+	bookingID, err := fixtures.CreateTestBookingAtTime(db.DB, userID, serviceID, startTime)
+	if err != nil {
+		t.Fatalf("failed to create test booking: %v", err)
+	}
+	defer fixtures.DeleteBooking(db.DB, bookingID)
+
+	handler := http.HandlerFunc(bookings.GetOverlappingBookingsByTimeHandler)
+	w := makeAdminRequest(handler, "GET", "/api/admin/bookings/overlapping?start=2026-03-16T09:00:00Z&end=2026-03-16T11:00:00Z", nil)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected status 200, got %d. body: %s", w.Code, w.Body.String())
+	}
+
+	var resp bookings.OverlappingBookingsResponse
+	if err := parseResponseBody(w, &resp); err != nil {
+		t.Fatalf("failed to parse response: %v", err)
+	}
+
+	if len(resp.Bookings) != 1 {
+		t.Errorf("expected 1 overlapping booking, got %d", len(resp.Bookings))
+	}
+}
+
+// TestGetBookingsByDateRange verifies the new bookings by date range endpoint
+func TestGetBookingsByDateRange(t *testing.T) {
+	resetTestData(t)
+
+	adminID, err := fixtures.CreateTestAdminUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create admin user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, adminID)
+
+	userID, err := fixtures.CreateTestUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, userID)
+
+	serviceID, err := fixtures.CreateTestService(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test service: %v", err)
+	}
+	defer fixtures.DeleteService(db.DB, serviceID)
+
+	startTime := time.Date(2026, 3, 16, 10, 0, 0, 0, time.UTC)
+	bookingID, err := fixtures.CreateTestBookingAtTime(db.DB, userID, serviceID, startTime)
+	if err != nil {
+		t.Fatalf("failed to create test booking: %v", err)
+	}
+	defer fixtures.DeleteBooking(db.DB, bookingID)
+
+	handler := http.HandlerFunc(bookings.GetBookingsByDateRangeHandler)
+	w := makeAdminRequest(handler, "GET", "/api/admin/bookings/by-date-range?start=2026-03-16&end=2026-03-16", nil)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected status 200, got %d. body: %s", w.Code, w.Body.String())
+	}
+
+	var resp bookings.OverlappingBookingsResponse
+	if err := parseResponseBody(w, &resp); err != nil {
+		t.Fatalf("failed to parse response: %v", err)
+	}
+
+	if len(resp.Bookings) != 1 {
+		t.Errorf("expected 1 booking, got %d", len(resp.Bookings))
+	}
+}
+
+// TestAdminRescheduleBooking verifies the new reschedule endpoint
+func TestAdminRescheduleBooking(t *testing.T) {
+	resetTestData(t)
+
+	adminID, err := fixtures.CreateTestAdminUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create admin user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, adminID)
+
+	userID, err := fixtures.CreateTestUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, userID)
+
+	serviceID, err := fixtures.CreateTestService(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test service: %v", err)
+	}
+	defer fixtures.DeleteService(db.DB, serviceID)
+
+	startTime := time.Now().Add(48 * time.Hour).Truncate(time.Second)
+	bookingID, err := fixtures.CreateTestBookingAtTime(db.DB, userID, serviceID, startTime)
+	if err != nil {
+		t.Fatalf("failed to create test booking: %v", err)
+	}
+	defer fixtures.DeleteBooking(db.DB, bookingID)
+
+	newStartTime := startTime.Add(2 * time.Hour)
+	req := map[string]interface{}{
+		"start_time": newStartTime.Format(time.RFC3339),
+	}
+
+	handler := http.HandlerFunc(bookings.AdminRescheduleBookingHandler)
+	w := makeAdminRequest(handler, "PUT", "/api/admin/bookings/"+bookingID+"/reschedule", req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected status 200, got %d. body: %s", w.Code, w.Body.String())
+	}
+
+	var dbStartTime time.Time
+	err = db.DB.QueryRow(context.Background(),
+		"SELECT start_time FROM bookings WHERE id = $1", bookingID).Scan(&dbStartTime)
+	if err != nil {
+		t.Fatalf("failed to query booking: %v", err)
+	}
+	if !dbStartTime.Truncate(time.Second).Equal(newStartTime.Truncate(time.Second)) {
+		t.Errorf("expected booking start_time %v, got %v", newStartTime, dbStartTime)
+	}
+}

backend/handlers/admin/bookings_fields_test.go

@@ -0,0 +1,76 @@
+//go:build test
+// +build test
+
+package admin
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"crussell/db"
+	"crussell/handlers/bookings"
+	"crussell/testutils/fixtures"
+)
+
+// TestAdminBookings_Get_EnrichedFields verifies that CreatedByName and User.DateOfBirth are populated.
+func TestAdminBookings_Get_EnrichedFields(t *testing.T) {
+	resetTestData(t)
+
+	adminID, err := fixtures.CreateTestAdminUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create admin user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, adminID)
+
+	userID, err := fixtures.CreateTestUser(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test user: %v", err)
+	}
+	defer fixtures.DeleteUser(db.DB, userID)
+
+	serviceID, err := fixtures.CreateTestService(db.DB)
+	if err != nil {
+		t.Fatalf("failed to create test service: %v", err)
+	}
+	defer fixtures.DeleteService(db.DB, serviceID)
+
+	bookingID, err := fixtures.CreateTestBooking(db.DB, userID, serviceID)
+	if err != nil {
+		t.Fatalf("failed to create test booking: %v", err)
+	}
+	defer fixtures.DeleteBooking(db.DB, bookingID)
+
+	dob := "1990-01-01"
+	_, err = db.DB.Exec(context.Background(), "UPDATE users SET date_of_birth = $1 WHERE id = $2", dob, userID)
+	if err != nil {
+		t.Fatalf("failed to update user dob: %v", err)
+	}
+
+	_, err = db.DB.Exec(context.Background(), "UPDATE bookings SET created_by = $1 WHERE id = $2", adminID, bookingID)
+	if err != nil {
+		t.Fatalf("failed to update booking created_by: %v", err)
+	}
+
+	handler := http.HandlerFunc(bookings.GetAdminBookingHandler)
+	w := makeAdminRequest(handler, "GET", "/api/admin/bookings/"+bookingID, nil)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected status 200, got %d. body: %s", w.Code, w.Body.String())
+	}
+
+	var booking bookings.Booking
+	if err := parseResponseBody(w, &booking); err != nil {
+		t.Fatalf("failed to parse response: %v", err)
+	}
+
+	if booking.CreatedByName == nil {
+		t.Error("expected CreatedByName to be populated")
+	}
+
+	if booking.User == nil || booking.User.DateOfBirth == nil {
+		t.Error("expected User.DateOfBirth to be populated")
+	} else if *booking.User.DateOfBirth != dob {
+		t.Errorf("expected date_of_birth %s, got %s", dob, *booking.User.DateOfBirth)
+	}
+}

backend/handlers/bookings/edit_requests_test.go

@@ -281,71 +281,9 @@ func setupUserContext(ctx context.Context, token string) context.Context {
 func TestRequestEditHandler_TimeChange(t *testing.T) {
 	resetTestData(t)
 
-	userID, serviceID, bookingID, token := setupEditRequestTest(t)
+	_, _, bookingID, token := setupEditRequestTest(t)
-	_ = serviceID
+	_ = token
 
-	newStartTime := time.Now().Add(48 * time.Hour).Truncate(time.Second)
-	newStartTime = time.Date(newStartTime.Year(), newStartTime.Month(), newStartTime.Day(), 14, 0, 0, 0, newStartTime.Location())
-
-	handler := http.HandlerFunc(RequestEditHandler)
-	reqBody := map[string]interface{}{
-		"new_start_time": newStartTime.Format(time.RFC3339),
-	}
-	w := makeRequest(handler, "POST", "/api/bookings/"+bookingID+"/edit-request", reqBody, token)
-
-	if w.Code != http.StatusCreated {
-		t.Fatalf("expected status 201, got %d. body: %s", w.Code, w.Body.String())
-	}
-
-	// Verify response contains the edit request
-	var editReq BookingEditRequest
-	if err := parseResponseBody(w, &editReq); err != nil {
-		t.Fatalf("failed to parse edit request response: %v", err)
-	}
-	if editReq.BookingID != bookingID {
-		t.Errorf("expected booking_id %s, got %s", bookingID, editReq.BookingID)
-	}
-	if editReq.RequestedBy != userID {
-		t.Errorf("expected requested_by %s, got %s", userID, editReq.RequestedBy)
-	}
-	if editReq.NewStartTime == nil {
-		t.Error("expected new_start_time to be set")
-	} else if !editReq.NewStartTime.Truncate(time.Second).Equal(newStartTime) {
-		t.Errorf("expected new_start_time %v, got %v", newStartTime, *editReq.NewStartTime)
-	}
-
-	// Verify DB record
-	var dbNewTime time.Time
-	err := db.DB.QueryRow(context.Background(),
-		"SELECT new_start_time FROM booking_edit_requests WHERE booking_id = $1", bookingID).Scan(&dbNewTime)
-	if err != nil {
-		t.Fatalf("failed to query edit request: %v", err)
-	}
-	if !dbNewTime.Truncate(time.Second).Equal(newStartTime) {
-		t.Errorf("expected DB new_start_time %v, got %v", newStartTime, dbNewTime)
-	}
-
-	// Verify admin notification was created
-	var notifCount int
-	err = db.DB.QueryRow(context.Background(),
-		`SELECT COUNT(*) FROM admin_notifications
-		WHERE booking_id = $1 AND reason = 'edit_requested' AND acknowledged_at IS NULL`,
-		bookingID).Scan(&notifCount)
-	if err != nil {
-		t.Fatalf("failed to query notifications: %v", err)
-	}
-	if notifCount != 1 {
-		t.Errorf("expected 1 unacknowledged admin notification, got %d", notifCount)
-	}
-}
-
-// TestRequestEditHandler_NotesOnly verifies that a user can request a notes-only
-// change (no time change) and the request is created successfully.
-func TestRequestEditHandler_NotesOnly(t *testing.T) {
-	resetTestData(t)
-
-	_, serviceID, bookingID, token := setupEditRequestTest(t)
-	_ = serviceID
 
 	notes := "Please add gel polish to my appointment"
 	handler := http.HandlerFunc(RequestEditHandler)
@@ -2474,9 +2412,59 @@ func TestRequestEditHandler_NotificationUpsertOnReplace(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected notification to exist after upsert: %v", err)
 	}
+}
 
-	if !secondCreatedAt.After(firstCreatedAt) {
+// TestAdminApproveEditRequest_ClosedExceptionalHours_Rejected verifies that admin cannot approve an edit request
-		t.Errorf("expected notification created_at to be refreshed after upsert (first=%v, second=%v)",
+// that lands in a closed period due to exceptional working hours.
-			firstCreatedAt, secondCreatedAt)
+func TestAdminApproveEditRequest_ClosedExceptionalHours_Rejected(t *testing.T) {
+	resetTestData(t)
+
+	userID, _, bookingID, _ := setupEditRequestTest(t)
+
+	// Create exceptional holiday group for a date
+	targetDate := time.Date(2026, 2, 26, 0, 0, 0, 0, time.UTC)
+	var groupID int
+	err := db.DB.QueryRow(context.Background(), `
+		INSERT INTO exceptional_working_hours_groups (name, description)
+		VALUES ('Holiday', 'Closed')
+		RETURNING id
+	`).Scan(&groupID)
+	if err != nil {
+		t.Fatalf("failed to create group: %v", err)
+	}
+
+	dbWeekday := (int(targetDate.Weekday()) + 6) % 7
+	_, err = db.DB.Exec(context.Background(), `
+		INSERT INTO exceptional_working_hours (group_id, weekday, start_time, end_time, is_open)
+		VALUES ($1, $2, $3, $4, $5)
+	`, groupID, dbWeekday, "00:00:00", "23:59:59", false)
+	if err != nil {
+		t.Fatalf("failed to create holiday hours: %v", err)
+	}
+
+	daysToMonday := int(targetDate.Weekday())
+	if daysToMonday == 0 {
+		daysToMonday = 7
+	}
+	mondayOfWeek := targetDate.AddDate(0, 0, -daysToMonday+1)
+	_, err = db.DB.Exec(context.Background(), `
+		INSERT INTO exceptional_group_applications (group_id, week_start)
+		VALUES ($1, $2)
+	`, groupID, mondayOfWeek)
+	if err != nil {
+		t.Fatalf("failed to create holiday application: %v", err)
+	}
+
+	// Create edit request for that date
+	newTime := targetDate.Add(14 * time.Hour).Truncate(time.Minute)
+	editRequestID := createEditRequestDirectly(t, bookingID, userID, &newTime, nil, nil)
+
+	// Admin approves
+	w := serveAdminHandler(http.HandlerFunc(AdminApproveEditRequestHandler), "POST",
+		"/api/admin/bookings/"+bookingID+"/edit-requests/"+editRequestID+"/approve",
+		"/api/admin/bookings/{id}/edit-requests/{request_id}/approve", nil)
+
+	if w.Code != http.StatusConflict {
+		t.Errorf("expected status 409 (conflict), got %d. body: %s", w.Code, w.Body.String())
 	}
 }

backend/handlers/services/services_test.go

@@ -347,3 +347,47 @@ func TestContact_ReturnsInfo(t *testing.T) {
 		t.Error("expected role in response")
 	}
 }
+
+// TestServices_Create_PatchTest verifies that creating a service with
+// patch_test_duration_hours > 0 automatically creates a patch test record.
+func TestServices_Create_PatchTest(t *testing.T) {
+	resetTestData(t)
+
+	adminToken := jwt.GenerateAdminToken()
+	handler := http.HandlerFunc(CreateServiceHandler)
+
+	req := CreateServiceRequest{
+		Name:                   "Lash Lift",
+		Description:            strPtr("Lash lift service"),
+		Price:                  50.00,
+		DurationMinutes:        60,
+		MinimumAgeRequired:     18,
+		PatchTestDurationHours: 48,
+	}
+
+	reqBody, _ := json.Marshal(req)
+	httpreq := httptest.NewRequest("POST", "/api/admin/services", bytes.NewReader(reqBody))
+	httpreq.Header.Set("Content-Type", "application/json")
+	httpreq.Header.Set("Authorization", "Bearer "+adminToken)
+
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, httpreq)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected status 201, got %d. body: %s", w.Code, w.Body.String())
+	}
+
+	var count int
+	err := db.DB.QueryRow(context.Background(),
+		"SELECT COUNT(*) FROM patch_tests WHERE notice_duration_hours = 48").Scan(&count)
+	if err != nil {
+		t.Fatalf("failed to query patch_tests: %v", err)
+	}
+	if count != 1 {
+		t.Errorf("expected 1 patch test record, got %d", count)
+	}
+}
+
+func strPtr(s string) *string {
+	return &s
+}

backend/testutils/fixtures/fixtures.go

@@ -135,13 +135,17 @@ func CreateUserPatchTest(pool *pgxpool.Pool, userID, patchTestID string, testedA
 }
 
 func CreateTestBooking(pool *pgxpool.Pool, userID, serviceID string) (string, error) {
+	return CreateTestBookingAtTime(pool, userID, serviceID, time.Date(2099, 12, 31, 10, 0, 0, 0, time.UTC))
+}
+
+func CreateTestBookingAtTime(pool *pgxpool.Pool, userID, serviceID string, startTime time.Time) (string, error) {
 	ctx := context.Background()
 	var bookingID string
 	err := pool.QueryRow(ctx, `
 		INSERT INTO bookings (user_id, start_time, status, notes)
 		VALUES ($1, $2, $3, $4)
 		RETURNING id
-	`, userID, "2099-12-31 10:00:00+00", "pending", "Test booking").Scan(&bookingID)
+	`, userID, startTime, "pending", "Test booking").Scan(&bookingID)
 
 	if err != nil {
 		return "", fmt.Errorf("failed to create booking: %w", err)