api_test.go

package integration_test

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/privapps/github-copilot-svcs/internal"
)

var (
	testServer *internal.Server
	baseURL    string
	cleanup    func()
)

// TestMain sets up and tears down the test server for all integration tests
func TestMain(m *testing.M) {
	// Set up test server
	var err error
	testServer, baseURL, cleanup, err = setupTestServer()
	if err != nil {
		fmt.Printf("Failed to setup test server: %v\n", err)
		os.Exit(1)
	}

	// Wait for server to be ready
	if !waitForServer(baseURL, 15*time.Second) {
		cleanup()
		fmt.Println("Server failed to start within timeout")
		os.Exit(1)
	}

	fmt.Printf("Test server ready at %s\n", baseURL)

	// Run tests
	code := m.Run()

	// Cleanup
	cleanup()

	os.Exit(code)
}

func TestHealthEndpoint(t *testing.T) {
	tests := []struct {
		name           string
		endpoint       string
		expectedStatus int
		expectedFields []string
	}{
		{
			name:           "basic health check",
			endpoint:       "/health",
			expectedStatus: http.StatusOK,
			expectedFields: []string{"status", "timestamp", "version"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			resp, err := http.Get(baseURL + tt.endpoint)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				t.Errorf("Expected status %d, got %d", tt.expectedStatus, resp.StatusCode)
			}

			// Check response body is valid JSON with expected fields
			var result map[string]interface{}
			if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
				t.Errorf("Failed to decode JSON response: %v", err)
				return
			}

			for _, field := range tt.expectedFields {
				if _, exists := result[field]; !exists {
					t.Errorf("Expected field '%s' not found in response", field)
				}
			}

			// Verify status is "healthy"
			if status, ok := result["status"].(string); !ok || status != "healthy" {
				t.Errorf("Expected status 'healthy', got %v", result["status"])
			}
		})
	}
}

func TestModelsEndpoint(t *testing.T) {
	tests := []struct {
		name           string
		method         string
		endpoint       string
		expectedStatus int
		checkJSON      bool
		expectedFields []string
	}{
		{
			name:           "get models list",
			method:         "GET",
			endpoint:       "/v1/models",
			expectedStatus: http.StatusOK,
			checkJSON:      true,
			expectedFields: []string{"object", "data"},
		},
		{
			name:           "models endpoint with POST method",
			method:         "POST",
			endpoint:       "/v1/models",
			expectedStatus: http.StatusOK, // Models endpoint accepts POST
			checkJSON:      true,
			expectedFields: []string{"object", "data"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, err := http.NewRequest(tt.method, baseURL+tt.endpoint, http.NoBody)
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}

			client := &http.Client{Timeout: 10 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				body, _ := io.ReadAll(resp.Body)
				t.Errorf("Expected status %d, got %d. Response: %s", tt.expectedStatus, resp.StatusCode, string(body))
			}

			if tt.checkJSON {
				var result map[string]interface{}
				if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
					t.Errorf("Failed to decode JSON response: %v", err)
					return
				}

				for _, field := range tt.expectedFields {
					if _, exists := result[field]; !exists {
						t.Errorf("Expected field '%s' not found in response", field)
					}
				}

				// Check that data is an array
				if data, ok := result["data"].([]interface{}); !ok {
					t.Errorf("Expected 'data' to be an array, got %T", result["data"])
				} else if len(data) == 0 {
					t.Log("Note: Models list is empty - this may be expected in test environment")
				}
			}
		})
	}
}

func TestChatCompletionsEndpoint(t *testing.T) {
	tests := []struct {
		name           string
		method         string
		endpoint       string
		body           string
		expectedStatus int
		contentType    string
	}{
		{
			name:           "chat completions with empty body",
			method:         "POST",
			endpoint:       "/v1/chat/completions",
			body:           "",
			expectedStatus: http.StatusBadRequest,
			contentType:    "application/json",
		},
		{
			name:           "chat completions with invalid JSON",
			method:         "POST",
			endpoint:       "/v1/chat/completions",
			body:           `{"invalid": json}`,
			expectedStatus: http.StatusBadRequest,
			contentType:    "application/json",
		},
		{
			name:           "chat completions with wrong method",
			method:         "GET",
			endpoint:       "/v1/chat/completions",
			body:           "",
			expectedStatus: http.StatusMethodNotAllowed,
			contentType:    "application/json",
		},
		{
			name:           "chat completions with basic valid request",
			method:         "POST",
			endpoint:       "/v1/chat/completions",
			body:           `{"model":"gpt-4","messages":[{"role":"user","content":"test"}]}`,
			expectedStatus: http.StatusUnauthorized, // Should be 401 if auth is missing
			contentType:    "application/json",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var body io.Reader
			if tt.body != "" {
				body = strings.NewReader(tt.body)
			}

			req, err := http.NewRequest(tt.method, baseURL+tt.endpoint, body)
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}

			if tt.contentType != "" {
				req.Header.Set("Content-Type", tt.contentType)
			}

			client := &http.Client{Timeout: 10 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				respBody, _ := io.ReadAll(resp.Body)
				t.Errorf("Expected status %d, got %d. Response: %s", tt.expectedStatus, resp.StatusCode, string(respBody))
			}
		})
	}
}

// TestHeaderForwardingProxy checks correct forwarding and defaulting of Content-Type, Accept, Accept-Encoding, TE headers
func TestHeaderForwardingProxy(t *testing.T) {
	// --- Setup fake upstream server to capture proxied headers ---
	var capturedHeaders http.Header
	mux := http.NewServeMux()
	mux.HandleFunc("/chat/completions", func(w http.ResponseWriter, r *http.Request) {
		capturedHeaders = r.Header.Clone()
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(200)
		_, _ = w.Write([]byte(`{"ok":true}`))
	})
	ts := httptest.NewServer(mux)
	defer ts.Close()

	// Point the proxy at our fake upstream
	internal.SetCopilotAPIBase(ts.URL)
	defer internal.ResetCopilotAPIBase()

	// Patch config to point upstream base URLs to our fake server
	cfg := &internal.Config{
		Port:          0,
		CopilotToken:  "token",
		ExpiresAt:     time.Now().Add(1 * time.Hour).Unix(),
		AllowedModels: []string{"gpt-4"},
	}
	internal.SetDefaultTimeouts(cfg)
	internal.SetDefaultHeaders(cfg)
	internal.SetDefaultCORS(cfg)

	httpClient := &http.Client{Transport: &http.Transport{}}
	proxy := internal.NewProxyService(cfg, httpClient, internal.NewAuthService(httpClient), internal.NewWorkerPool(1))
	srv := httptest.NewServer(proxy.Handler())
	defer srv.Close()

	cases := []struct {
		name         string
		headers      map[string]string
		wantExpected map[string]string
	}{
		{
			name: "all client headers set",
			headers: map[string]string{
				"Content-Type":    "custom/type",
				"Accept":          "foo/bar",
				"Accept-Encoding": "gzip, deflate",
				"TE":              "trailers",
			},
			wantExpected: map[string]string{
				"Content-Type":    "custom/type",
				"Accept":          "foo/bar",
				"Accept-Encoding": "gzip, deflate",
				"TE":              "trailers",
			},
		},
		{
			name: "content-type only",
			headers: map[string]string{
				"Content-Type": "foo/baz",
			},
			wantExpected: map[string]string{
				"Content-Type": "foo/baz",
				"Accept":       "application/json",
			},
		},
		{
			name: "accept only",
			headers: map[string]string{
				"Accept": "bar/foo",
			},
			wantExpected: map[string]string{
				"Content-Type": "application/json",
				"Accept":       "bar/foo",
			},
		},
		{
			name:    "neither set (default both)",
			headers: map[string]string{},
			wantExpected: map[string]string{
				"Content-Type": "application/json",
				"Accept":       "application/json",
			},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			capturedHeaders = nil // Reset
			jsonBody := `{"model":"gpt-4","messages":[{"role":"user","content":"test"}]}`
			client := &http.Client{}
			req, err := http.NewRequest("POST", srv.URL+"/v1/chat/completions", strings.NewReader(jsonBody))
			if err != nil {
				t.Fatalf("new req err: %v", err)
			}
			for k, v := range tc.headers {
				req.Header.Set(k, v)
			}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("proxy req failed: %v", err)
			}
			io.ReadAll(resp.Body)
			resp.Body.Close()

			for wantKey, wantVal := range tc.wantExpected {
				got := capturedHeaders.Get(wantKey)
				if got != wantVal {
					t.Errorf("expected header %q to be %q, got %q. All headers: %+v", wantKey, wantVal, got, capturedHeaders)
				}
			}
			// TE should not be forwarded unless explicitly set by client.
			// Note: Accept-Encoding may be added automatically by Go's HTTP client.
			if _, ok := tc.headers["TE"]; !ok {
				if capturedHeaders.Get("TE") != "" {
					t.Errorf("expected header %q absent, got %q. All headers: %+v", "TE", capturedHeaders.Get("TE"), capturedHeaders)
				}
			}
		})
	}
}

// TestResponsesEndpoint tests the /v1/responses endpoint for GPT-5.x models
func TestResponsesEndpoint(t *testing.T) {
	tests := []struct {
		name           string
		method         string
		endpoint       string
		body           string
		expectedStatus int
		contentType    string
	}{
		{
			name:           "responses with empty body",
			method:         "POST",
			endpoint:       "/v1/responses",
			body:           "",
			expectedStatus: http.StatusBadRequest,
			contentType:    "application/json",
		},
		{
			name:           "responses with invalid JSON",
			method:         "POST",
			endpoint:       "/v1/responses",
			body:           `{"invalid": json}`,
			expectedStatus: http.StatusBadRequest,
			contentType:    "application/json",
		},
		{
			name:           "responses with wrong method",
			method:         "GET",
			endpoint:       "/v1/responses",
			body:           "",
			expectedStatus: http.StatusMethodNotAllowed,
			contentType:    "application/json",
		},
		{
			name:           "responses with basic valid request",
			method:         "POST",
			endpoint:       "/v1/responses",
			body:           `{"model":"gpt-5.6-luna","input":"test","max_output_tokens":50}`,
			expectedStatus: http.StatusUnauthorized, // Should be 401 if auth is missing
			contentType:    "application/json",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var body io.Reader
			if tt.body != "" {
				body = strings.NewReader(tt.body)
			}

			req, err := http.NewRequest(tt.method, baseURL+tt.endpoint, body)
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}

			if tt.contentType != "" {
				req.Header.Set("Content-Type", tt.contentType)
			}

			client := &http.Client{Timeout: 10 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				respBody, _ := io.ReadAll(resp.Body)
				t.Errorf("Expected status %d, got %d. Response: %s", tt.expectedStatus, resp.StatusCode, string(respBody))
			}
		})
	}
}

func TestCORSHeaders(t *testing.T) {
	tests := []struct {
		name           string
		endpoint       string
		origin         string
		method         string
		expectedStatus int
		checkCORS      bool
	}{
		{
			name:           "CORS preflight request",
			endpoint:       "/v1/models",
			origin:         "http://localhost:3000",
			method:         "OPTIONS",
			expectedStatus: http.StatusOK,
			checkCORS:      true,
		},
		{
			name:           "CORS actual request",
			endpoint:       "/health",
			origin:         "http://localhost:3000",
			method:         "GET",
			expectedStatus: http.StatusOK,
			checkCORS:      true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, err := http.NewRequest(tt.method, baseURL+tt.endpoint, http.NoBody)
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}

			if tt.origin != "" {
				req.Header.Set("Origin", tt.origin)
			}

			if tt.method == "OPTIONS" {
				req.Header.Set("Access-Control-Request-Method", "GET")
				req.Header.Set("Access-Control-Request-Headers", "Content-Type")
			}

			client := &http.Client{Timeout: 5 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				t.Errorf("Expected status %d, got %d", tt.expectedStatus, resp.StatusCode)
			}

			if tt.checkCORS {
				// Check for CORS headers
				allowOrigin := resp.Header.Get("Access-Control-Allow-Origin")
				if allowOrigin == "" {
					t.Error("Expected Access-Control-Allow-Origin header")
				}

				if tt.method == "OPTIONS" {
					allowMethods := resp.Header.Get("Access-Control-Allow-Methods")
					if allowMethods == "" {
						t.Error("Expected Access-Control-Allow-Methods header for preflight")
					}
				}
			}
		})
	}
}

func TestErrorConditions(t *testing.T) {
	tests := []struct {
		name           string
		endpoint       string
		expectedStatus int
	}{
		{
			name:           "nonexistent endpoint",
			endpoint:       "/nonexistent",
			expectedStatus: http.StatusNotFound,
		},
		{
			name:           "invalid path",
			endpoint:       "/v1/invalid",
			expectedStatus: http.StatusNotFound,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			resp, err := http.Get(baseURL + tt.endpoint)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode != tt.expectedStatus {
				t.Errorf("Expected status %d, got %d", tt.expectedStatus, resp.StatusCode)
			}
		})
	}
}

func TestSecurityHeaders(t *testing.T) {
	resp, err := http.Get(baseURL + "/health")
	if err != nil {
		t.Fatalf("Failed to make request: %v", err)
	}
	defer resp.Body.Close()

	expectedHeaders := map[string]string{
		"X-Content-Type-Options": "nosniff",
		"X-Frame-Options":        "DENY",
		"X-XSS-Protection":       "1; mode=block",
	}

	for header, expectedValue := range expectedHeaders {
		actualValue := resp.Header.Get(header)
		if actualValue != expectedValue {
			t.Errorf("Expected header %s to be '%s', got '%s'", header, expectedValue, actualValue)
		}
	}
}

func TestServerShutdown(t *testing.T) {
	// This test verifies that the server can be gracefully shut down
	// We'll create a separate server instance for this test
	server, serverURL, shutdownFunc, err := setupTestServer()
	if err != nil {
		t.Fatalf("Failed to setup test server: %v", err)
	}

	// Wait for server to be ready
	if !waitForServer(serverURL, 5*time.Second) {
		shutdownFunc()
		t.Fatal("Server failed to start within timeout")
	}

	// Make a request to ensure server is working
	resp, err := http.Get(serverURL + "/health")
	if err != nil {
		shutdownFunc()
		t.Fatalf("Failed to make request: %v", err)
	}
	resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		t.Errorf("Expected status %d, got %d", http.StatusOK, resp.StatusCode)
	}

	// Shutdown the server
	shutdownFunc()

	// Verify server is no longer responding
	time.Sleep(200 * time.Millisecond) // Give time for shutdown
	resp2, err := http.Get(serverURL + "/health")
	if resp2 != nil {
		defer resp2.Body.Close()
	}
	if err == nil {
		t.Error("Expected server to be shut down, but it's still responding")
	}

	_ = server // Use server variable to avoid unused warning
}

// setupTestServer creates a test server instance and returns cleanup function
func setupTestServer() (server *internal.Server, baseURL string, cleanup func(), err error) {
	// Find an available port
	listener, err := net.Listen("tcp", ":0")
	if err != nil {
		return nil, "", nil, fmt.Errorf("failed to find available port: %w", err)
	}
	port := listener.Addr().(*net.TCPAddr).Port
	listener.Close()

	// Create test configuration with proper defaults
	cfg := &internal.Config{
		Port: port,
	}

	// Set default headers to prevent validation errors
	internal.SetDefaultHeaders(cfg)
	internal.SetDefaultCORS(cfg)
	internal.SetDefaultTimeouts(cfg)

	// Create HTTP client for the server
	httpClient := &http.Client{
		Timeout: 30 * time.Second,
	}

	// Create server instance
	server = internal.NewServer(cfg, httpClient)
	baseURL = fmt.Sprintf("http://localhost:%d", port)

	// Start server in background goroutine
	serverErrCh := make(chan error, 1)

	go func() {
		// For testing, we'll just call Start() which blocks
		if err := server.Start(); err != nil && err != http.ErrServerClosed {
			serverErrCh <- err
		}
	}()

	cleanup = func() {
		if server != nil {
			if err := server.Stop(); err != nil {
				fmt.Printf("Error stopping server: %v\n", err)
			}
		}
		// Give server time to shutdown gracefully
		time.Sleep(200 * time.Millisecond)
	}

	// Check for immediate startup errors
	select {
	case err := <-serverErrCh:
		cleanup()
		return nil, "", nil, fmt.Errorf("server failed to start: %w", err)
	case <-time.After(1 * time.Second):
		// Server seems to be starting OK
	}

	return server, baseURL, cleanup, nil
}

// waitForServer waits for the server to be ready to accept connections
func waitForServer(baseURL string, timeout time.Duration) bool {
	client := &http.Client{Timeout: 1 * time.Second}
	deadline := time.Now().Add(timeout)

	for time.Now().Before(deadline) {
		resp, err := client.Get(baseURL + "/health")
		if err == nil {
			resp.Body.Close()
			if resp.StatusCode == http.StatusOK {
				return true
			}
		}
		time.Sleep(200 * time.Millisecond)
	}
	return false
}

// TestVisionSupport tests that the proxy correctly handles vision/image requests
func TestVisionSupport(t *testing.T) {
	// Create a small 1x1 transparent PNG image for testing
	pngData, _ := base64.StdEncoding.DecodeString("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==")
	imageDataURL := "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngData)

	tests := []struct {
		name           string
		payload        string
		expectedStatus int
		description    string
	}{
		{
			name: "vision request with image_url",
			payload: fmt.Sprintf(`{
"model": "gpt-4o",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "Describe this image"},
{"type": "image_url", "image_url": {"url": "%s"}}
]
}],
"max_tokens": 100
}`, imageDataURL),
			expectedStatus: http.StatusUnauthorized, // Will fail auth, but should accept the payload structure
			description:    "Multi-part content with image should be accepted",
		},
		{
			name: "vision request with base64 image",
			payload: fmt.Sprintf(`{
"model": "gpt-4o",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{"type": "image_url", "image_url": {"url": "%s", "detail": "high"}}
]
}],
"max_tokens": 200
}`, imageDataURL),
			expectedStatus: http.StatusUnauthorized,
			description:    "Image with detail parameter should be accepted",
		},
		{
			name: "text-only request still works",
			payload: `{
"model": "gpt-4o",
"messages": [{
"role": "user",
"content": "Hello"
}],
"max_tokens": 50
}`,
			expectedStatus: http.StatusUnauthorized,
			description:    "Backward compatibility: text-only content should still work",
		},
		{
			name: "mixed text and vision in same conversation",
			payload: fmt.Sprintf(`{
"model": "gpt-4o",
"messages": [
{
"role": "user",
"content": "Hello"
},
{
"role": "assistant",
"content": "Hi! How can I help?"
},
{
"role": "user",
"content": [
{"type": "text", "text": "Look at this"},
{"type": "image_url", "image_url": {"url": "%s"}}
]
}
],
"max_tokens": 150
}`, imageDataURL),
			expectedStatus: http.StatusUnauthorized,
			description:    "Mixed text and vision messages should be accepted",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, err := http.NewRequest("POST", baseURL+"/v1/chat/completions", strings.NewReader(tt.payload))
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}
			req.Header.Set("Content-Type", "application/json")

			client := &http.Client{Timeout: 10 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			// We expect 401 because we don't have auth in tests
			// But the important part is that the request is not rejected as "bad request"
			if resp.StatusCode != tt.expectedStatus {
				body, _ := io.ReadAll(resp.Body)
				t.Errorf("%s: Expected status %d, got %d. Response: %s",
					tt.description, tt.expectedStatus, resp.StatusCode, string(body))
			}

			// If we got a 400, it means the payload structure was rejected
			if resp.StatusCode == http.StatusBadRequest {
				body, _ := io.ReadAll(resp.Body)
				t.Errorf("%s: Vision payload was rejected as bad request. Response: %s",
					tt.description, string(body))
			}
		})
	}
}

// TestVisionPayloadValidation ensures vision payloads pass JSON validation
func TestVisionPayloadValidation(t *testing.T) {
	pngData, _ := base64.StdEncoding.DecodeString("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==")
	imageDataURL := "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngData)

	tests := []struct {
		name        string
		payload     string
		shouldPass  bool
		description string
	}{
		{
			name: "valid vision payload",
			payload: fmt.Sprintf(`{
"model": "gpt-4o",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "test"},
{"type": "image_url", "image_url": {"url": "%s"}}
]
}]
}`, imageDataURL),
			shouldPass:  true,
			description: "Valid vision payload should pass validation",
		},
		{
			name:        "missing model field",
			payload:     `{"messages": [{"role": "user", "content": "test"}]}`,
			shouldPass:  true,
			description: "Missing model field results in empty model",
		},
		{
			name:        "invalid json",
			payload:     `{"model": "gpt-4o", invalid}`,
			shouldPass:  false,
			description: "Invalid JSON should fail",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req, err := http.NewRequest("POST", baseURL+"/v1/chat/completions", strings.NewReader(tt.payload))
			if err != nil {
				t.Fatalf("Failed to create request: %v", err)
			}
			req.Header.Set("Content-Type", "application/json")

			client := &http.Client{Timeout: 10 * time.Second}
			resp, err := client.Do(req)
			if err != nil {
				t.Fatalf("Failed to make request: %v", err)
			}
			defer resp.Body.Close()

			isBadRequest := resp.StatusCode == http.StatusBadRequest
			if tt.shouldPass && isBadRequest {
				body, _ := io.ReadAll(resp.Body)
				t.Errorf("%s: Expected to pass, got 400. Response: %s", tt.description, string(body))
			}
			if !tt.shouldPass && !isBadRequest {
				t.Errorf("%s: Expected to fail validation, got status %d", tt.description, resp.StatusCode)
			}
		})
	}
}