test: add comprehensive test coverage for API endpoints and services

2026-02-01 13:21:34 -05:00
parent 9b1282cd08
commit 351c68b0b8
11 changed files with 4275 additions and 0 deletions
@@ -0,0 +1,457 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestConflictsBulkOperations tests bulk conflict resolution operations
+func TestConflictsBulkOperations(t *testing.T) {
+	t.Run("BulkResolveConflicts_WithoutAuth", func(t *testing.T) {
+		ts, _, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String()},
+			"strategy":     "most_recent",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+
+	t.Run("BulkResolveConflicts_EmptyConflictIDs", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{},
+			"strategy":     "most_recent",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+
+	t.Run("BulkResolveConflicts_InvalidConflictID", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{"invalid-uuid"},
+			"strategy":     "most_recent",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+		assert.Contains(t, result, "total")
+		assert.Contains(t, result, "success")
+		assert.Contains(t, result, "failed")
+
+		results := result["results"].([]interface{})
+		firstResult := results[0].(map[string]interface{})
+		assert.Equal(t, "error", firstResult["status"])
+	})
+
+	t.Run("BulkResolveConflicts_InvalidStrategy", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String()},
+			"strategy":     "invalid_strategy",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+
+	t.Run("BulkResolveConflicts_MostRecentStrategy", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String(), uuid.New().String()},
+			"strategy":     "most_recent",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+		assert.Equal(t, 2, result["total"])
+	})
+
+	t.Run("BulkResolveConflicts_HighestProgressStrategy", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String(), uuid.New().String()},
+			"strategy":     "highest_progress",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+		assert.Equal(t, 2, result["total"])
+	})
+
+	t.Run("BulkResolveConflicts_ManualStrategy_WithoutWinner", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String()},
+			"strategy":     "manual",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+	})
+
+	t.Run("BulkResolveConflicts_ManualStrategy_WithWinner", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids":   []string{uuid.New().String()},
+			"strategy":       "manual",
+			"winning_source": "device",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+	})
+
+	t.Run("BulkResolveConflicts_InvalidRequestBody", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		// Send invalid JSON
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer([]byte("invalid json")))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+}
+
+// TestConflictsBulkDismiss tests bulk dismiss operations
+func TestConflictsBulkDismiss(t *testing.T) {
+	t.Run("BulkDismissConflicts_WithoutAuth", func(t *testing.T) {
+		ts, _, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{uuid.New().String()},
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+
+	t.Run("BulkDismissConflicts_EmptyConflictIDs", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{},
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+
+	t.Run("BulkDismissConflicts_InvalidConflictID", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{"invalid-uuid", uuid.New().String()},
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+		assert.Contains(t, result, "total")
+		assert.Contains(t, result, "success")
+		assert.Contains(t, result, "failed")
+
+		results := result["results"].([]interface{})
+		firstResult := results[0].(map[string]interface{})
+		assert.Equal(t, "error", firstResult["status"])
+	})
+
+	t.Run("BulkDismissConflicts_MultipleConflicts", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{
+				uuid.New().String(),
+				uuid.New().String(),
+				uuid.New().String(),
+			},
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		assert.Contains(t, result, "results")
+		assert.Equal(t, 3, result["total"])
+	})
+
+	t.Run("BulkDismissConflicts_InvalidRequestBody", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		// Send invalid JSON
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer([]byte("invalid json")))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+	})
+}
+
+// TestConflictsBulkEdgeCases tests edge cases for bulk operations
+func TestConflictsBulkEdgeCases(t *testing.T) {
+	t.Run("BulkResolve_NonExistentConflicts", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{
+				uuid.New().String(),
+				uuid.New().String(),
+				uuid.New().String(),
+			},
+			"strategy": "most_recent",
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		// All should fail since conflicts don't exist
+		assert.Equal(t, float64(0), result["success"])
+		assert.Equal(t, float64(3), result["failed"])
+	})
+
+	t.Run("BulkDismiss_MixedValidInvalid", func(t *testing.T) {
+		ts, db, _, _ := setupTestServer(t)
+		defer ts.Close()
+
+		token := loginTestUser(t, ts, db)
+
+		req := map[string]interface{}{
+			"conflict_ids": []string{
+				"invalid-uuid-1",
+				"invalid-uuid-2",
+				uuid.New().String(),
+			},
+		}
+		body, _ := json.Marshal(req)
+
+		httpReq, _ := http.NewRequest("POST", ts.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
+		httpReq.Header.Set("Content-Type", "application/json")
+		httpReq.Header.Set("Authorization", "Bearer "+token)
+
+		client := &http.Client{}
+		resp, err := client.Do(httpReq)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&result)
+
+		results := result["results"].([]interface{})
+		assert.Equal(t, 3, len(results))
+	})
+}