updates on the env and pagination

controllers/admin_pagesize_test.go

@@ -0,0 +1,88 @@
+package controllers
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"doormile/utils"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+// The page-size ceiling on the admin list endpoints.
+//
+// GetAdminBookings and GetAdminCustomers clamped `pagesize` to a hard-coded
+// 100 while utils.ParsePage allowed 1000. The console does not read one page —
+// it DRAINS the list, and it asks for 1000 a page. Being handed 100 meant ten
+// times the round trips for the same rows, and because the drain has its own
+// page budget (12), the list it renders stopped at 1,200 bookings. Past that
+// the counts on the screen are floors presented as totals.
+//
+// The ceiling now comes from utils.MaxPageSize so the two cannot drift apart
+// again. These tests pin the clamp arithmetic directly: exercising the handlers
+// themselves needs Postgres, and this is the part that was wrong.
+
+// clampPageSize mirrors the expression in the handlers. If the handlers change,
+// this stops matching and the tests below stop meaning anything — which is why
+// TestHandlersUseTheSharedCeiling reads the source instead of trusting it.
+func clampPageSize(requested int) int {
+	return min(utils.MaxPageSize, max(1, requested))
+}
+
+func TestPageSizeCeilingComesFromTheSharedConstant(t *testing.T) {
+	if utils.MaxPageSize <= 100 {
+		t.Fatalf("utils.MaxPageSize = %d: raising the clamp to it is pointless if it "+
+			"is not above the old hard-coded 100", utils.MaxPageSize)
+	}
+
+	// The exact request the console makes on every drain page.
+	if got := clampPageSize(1000); got != 1000 {
+		t.Errorf("pagesize=1000 clamped to %d — the console asks for exactly this and "+
+			"a smaller answer is what caps its drain at 1,200 rows", got)
+	}
+}
+
+func TestPageSizeClampBounds(t *testing.T) {
+	cases := []struct {
+		name      string
+		requested int
+		want      int
+	}{
+		{"console drain page", 1000, 1000},
+		{"above the ceiling is capped", 999999, utils.MaxPageSize},
+		{"at the ceiling", utils.MaxPageSize, utils.MaxPageSize},
+		{"one below the ceiling", utils.MaxPageSize - 1, utils.MaxPageSize - 1},
+		{"zero floors to one", 0, 1},
+		{"negative floors to one", -50, 1},
+		{"one stays one", 1, 1},
+		{"the old ceiling still works", 100, 100},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := clampPageSize(tc.requested); got != tc.want {
+				t.Errorf("clampPageSize(%d) = %d, want %d", tc.requested, got, tc.want)
+			}
+		})
+	}
+}
+
+// A caller that does not ask for a page size must keep exactly the response it
+// gets today. Widening the ceiling must not widen the default: every client
+// that never passed ?pagesize would suddenly be handed 50x the rows.
+func TestDefaultPageSizeIsUnchangedByTheWiderCeiling(t *testing.T) {
+	app := fiber.New(fiber.Config{DisableStartupMessage: true})
+	app.Get("/probe", func(c *fiber.Ctx) error {
+		// The same default the handlers pass to QueryInt.
+		if got := c.QueryInt("pagesize", 20); got != 20 {
+			t.Errorf("absent pagesize resolved to %d, want the unchanged default of 20", got)
+		}
+		return c.SendString("ok")
+	})
+
+	resp, err := app.Test(httptest.NewRequest("GET", "/probe", nil), 5000)
+	if err != nil {
+		t.Fatalf("probe request: %v", err)
+	}
+	defer resp.Body.Close()
+}