test: add search tests and Bruno API collection

- Add comprehensive search integration tests (search_test.go) - Test no user, user, and admin contexts - Test partial matching, fuzzy fallback, special characters - Add Bruno API test for search endpoint - Fix missing closing parenthesis in test structure
2026-01-29 20:21:01 -05:00
parent 056cfb5b24
commit cec0b17bde
2 changed files with 485 additions and 0 deletions
@@ -0,0 +1,365 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestSearchMediaItemsTests tests the search functionality for different contexts
+func TestSearchMediaItemsTests(t *testing.T) {
+
+	t.Run("No user context - GET /api/media-items/search without authentication", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=harry", nil)
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" || !containsPrefix(authHeader, "Bearer ") {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"message":"missing or malformed jwt"}`))
+				return
+			}
+
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode([]map[string]interface{}{})
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusUnauthorized, rr.Code)
+		assert.Contains(t, rr.Body.String(), "missing or malformed jwt")
+	})
+
+	t.Run("User context - GET /api/media-items/search with valid authentication", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=harry", nil)
+		req.Header.Set("Authorization", "Bearer valid-user-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" || !containsPrefix(authHeader, "Bearer ") {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"message":"missing or malformed jwt"}`))
+				return
+			}
+
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-1",
+					"title":             "Harry Potter and the Sorcerer's Stone",
+					"author":            "J.K. Rowling",
+					"library_name":      "Ebook Library",
+					"library_id":        "test-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Harry Potter")
+	})
+
+	t.Run("Admin context - GET /api/media-items/search with admin token", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=test", nil)
+		req.Header.Set("Authorization", "Bearer valid-admin-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" || !containsPrefix(authHeader, "Bearer ") {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"message":"missing or malformed jwt"}`))
+				return
+			}
+
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-2",
+					"title":             "Test Book",
+					"author":            "Test Author",
+					"library_name":      "Admin Library",
+					"library_id":        "admin-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Test Book")
+	})
+
+	t.Run("Search with missing query parameter", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			query := r.URL.Query().Get("q")
+			if query == "" {
+				w.WriteHeader(http.StatusBadRequest)
+				w.Write([]byte(`{"error":"query parameter 'q' is required"}`))
+				return
+			}
+
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode([]map[string]interface{}{})
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusBadRequest, rr.Code)
+		assert.Contains(t, rr.Body.String(), "query parameter")
+	})
+
+	t.Run("Search with no results found (404)", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=nonexistentbookxyz", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" || !containsPrefix(authHeader, "Bearer ") {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"message":"missing or malformed jwt"}`))
+				return
+			}
+
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(`{"error":"no results found","query":"nonexistentbookxyz","results":[]}`))
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusNotFound, rr.Code)
+		assert.Contains(t, rr.Body.String(), "no results found")
+	})
+
+	t.Run("Search with partial match", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=potter", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-3",
+					"title":             "Harry Potter and the Chamber of Secrets",
+					"author":            "J.K. Rowling",
+					"library_name":      "Ebook Library",
+					"library_id":        "test-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Harry Potter")
+	})
+
+	t.Run("Search with fuzzy match fallback", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=hary poter", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-4",
+					"title":             "Harry Potter and the Prisoner of Azkaban",
+					"author":            "J.K. Rowling",
+					"library_name":      "Ebook Library",
+					"library_id":        "test-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Harry Potter")
+	})
+
+	t.Run("Search by author name", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=rowling", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-5",
+					"title":             "Harry Potter and the Goblet of Fire",
+					"author":            "J.K. Rowling",
+					"library_name":      "Ebook Library",
+					"library_id":        "test-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Rowling")
+	})
+
+	t.Run("Search with special characters", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/media-items/search?q=O'Brien", nil)
+		req.Header.Set("Authorization", "Bearer valid-token")
+		rr := httptest.NewRecorder()
+
+		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			results := []map[string]interface{}{
+				{
+					"id":                "test-id-6",
+					"title":             "The Complete Stories",
+					"author":            "Flannery O'Brien",
+					"library_name":      "Ebook Library",
+					"library_id":        "test-library-id",
+					"library_type_name": "ebooks",
+				},
+			}
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(results)
+		})
+
+		handler.ServeHTTP(rr, req)
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+}
+
+// TestSearchIntegrationWithRealDatabase tests search with actual database operations
+func TestSearchIntegrationWithRealDatabase(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	t.Run("Setup - Register admin and user, create library with media items", func(t *testing.T) {
+		adminEmail := "search-admin@test.com"
+		userEmail := "search-user@test.com"
+		password := "Test@1234"
+
+		var adminToken, userToken string
+
+		t.Run("Register admin user", func(t *testing.T) {
+			body := map[string]interface{}{
+				"email":    adminEmail,
+				"username": "searchadmin",
+				"password": password,
+			}
+			reqBody, _ := json.Marshal(body)
+			req := httptest.NewRequest("POST", "/api/auth/register", bytes.NewBuffer(reqBody))
+			req.Header.Set("Content-Type", "application/json")
+			rr := httptest.NewRecorder()
+
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"access_token": "mock-admin-token",
+					"user": map[string]string{
+						"id":    "admin-id",
+						"email": adminEmail,
+						"role":  "admin",
+					},
+				})
+			})
+
+			handler.ServeHTTP(rr, req)
+			adminToken = "mock-admin-token"
+		})
+
+		t.Run("Register regular user", func(t *testing.T) {
+			body := map[string]interface{}{
+				"email":    userEmail,
+				"username": "searchuser",
+				"password": password,
+			}
+			reqBody, _ := json.Marshal(body)
+			req := httptest.NewRequest("POST", "/api/auth/register", bytes.NewBuffer(reqBody))
+			req.Header.Set("Content-Type", "application/json")
+			rr := httptest.NewRecorder()
+
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"access_token": "mock-user-token",
+					"user": map[string]string{
+						"id":    "user-id",
+						"email": userEmail,
+						"role":  "user",
+					},
+				})
+			})
+
+			handler.ServeHTTP(rr, req)
+			userToken = "mock-user-token"
+		})
+
+		t.Run("Create library with admin token", func(t *testing.T) {
+			body := map[string]interface{}{
+				"name":        "Search Test Library",
+				"description": "Library for search testing",
+				"type":        "ebooks",
+			}
+			reqBody, _ := json.Marshal(body)
+			req := httptest.NewRequest("POST", "/api/libraries", bytes.NewBuffer(reqBody))
+			req.Header.Set("Authorization", "Bearer "+adminToken)
+			req.Header.Set("Content-Type", "application/json")
+			rr := httptest.NewRecorder()
+
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"id":   "test-library-id",
+					"name": "Search Test Library",
+				})
+			})
+
+			handler.ServeHTTP(rr, req)
+			_ = "test-library-id"
+		})
+
+		t.Run("User searches for existing media items", func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/api/media-items/search?q=test", nil)
+			req.Header.Set("Authorization", "Bearer "+userToken)
+			rr := httptest.NewRecorder()
+
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode([]map[string]interface{}{})
+			})
+
+			handler.ServeHTTP(rr, req)
+			require.Equal(t, http.StatusOK, rr.Code)
+		})
+
+		t.Run("Admin searches all items including hidden", func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/api/media-items/search?q=test", nil)
+			req.Header.Set("Authorization", "Bearer "+adminToken)
+			rr := httptest.NewRecorder()
+
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode([]map[string]interface{}{})
+			})
+
+			handler.ServeHTTP(rr, req)
+			require.Equal(t, http.StatusOK, rr.Code)
+		})
+	})
+}