initiall commit

apps/backend/internal/handlers/http_integration_test.go

@@ -0,0 +1,132 @@
+// +build integration
+
+package handlers_test
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/tdvorak/primora/apps/backend/internal/handlers"
+	"github.com/tdvorak/primora/apps/backend/internal/observability"
+	"github.com/tdvorak/primora/apps/backend/internal/repositories"
+	"github.com/tdvorak/primora/apps/backend/internal/services"
+	"github.com/tdvorak/primora/apps/backend/internal/storage"
+)
+
+// Integration tests require a running PostgreSQL instance
+// Run with: go test -tags=integration ./...
+
+func TestHealthEndpoints(t *testing.T) {
+	router := setupTestRouter(t)
+
+	t.Run("liveness check", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("GET", "/api/v1/health/liveness", nil)
+		router.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusOK, w.Code)
+		
+		var response map[string]any
+		err := json.Unmarshal(w.Body.Bytes(), &response)
+		require.NoError(t, err)
+		assert.Equal(t, "ok", response["status"])
+	})
+
+	t.Run("readiness check", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("GET", "/api/v1/health/readiness", nil)
+		router.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusOK, w.Code)
+		
+		var response map[string]any
+		err := json.Unmarshal(w.Body.Bytes(), &response)
+		require.NoError(t, err)
+		assert.Contains(t, response, "status")
+		assert.Contains(t, response, "checks")
+	})
+}
+
+func TestAuthenticationFlow(t *testing.T) {
+	router := setupTestRouter(t)
+
+	t.Run("requires authentication", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("GET", "/api/v1/me", nil)
+		router.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusUnauthorized, w.Code)
+	})
+
+	t.Run("rejects invalid token", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("GET", "/api/v1/me", nil)
+		req.Header.Set("Authorization", "Bearer invalid-token")
+		router.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusUnauthorized, w.Code)
+	})
+}
+
+func TestBootstrapFlow(t *testing.T) {
+	router := setupTestRouter(t)
+
+	// This test requires a valid JWT token
+	// In a real integration test, you would:
+	// 1. Create a test user in the auth service
+	// 2. Get a valid JWT token
+	// 3. Use that token to test the bootstrap endpoint
+
+	t.Skip("Requires auth service integration")
+}
+
+func setupTestRouter(t *testing.T) *gin.Engine {
+	gin.SetMode(gin.TestMode)
+	
+	// This would need to connect to a test database
+	// For now, we'll create a minimal setup
+	
+	router := gin.New()
+	
+	// Create minimal dependencies
+	store, err := storage.NewLocalStore(t.TempDir())
+	require.NoError(t, err)
+	
+	// In a real integration test, you would:
+	// - Connect to a test PostgreSQL database
+	// - Run migrations
+	// - Create a CoreRepository
+	// - Create a PlatformService
+	
+	// For this example, we'll just set up the health endpoints
+	metrics := observability.NewMetrics()
+	
+	handler := &handlers.HTTPHandler{
+		Platform:  nil, // Would be initialized with real services
+		Validate:  validator.New(),
+		Metrics:   metrics,
+		Readiness: func(c *gin.Context) map[string]any {
+			return map[string]any{
+				"status": "ok",
+				"checks": map[string]any{
+					"database":  "ok",
+					"storage":   "ok",
+					"dragonfly": "disabled",
+				},
+			}
+		},
+	}
+	
+	handler.Register(router)
+	
+	return router
+}