test(sync): rewrite conflict tests as real HTTP integration tests

Replace the previous mock/httptest-based conflict tests with integration tests that exercise the full HTTP stack against a live test server with a real database. Changes include: - Add shared test helpers (setupConflictTest, createTestConflict, makeConflictData) to reduce boilerplate across test files - Split monolithic TestConflictDetection and TestConflictsBulkOperations into focused test functions per scenario - Test conflict detection, bulk resolution (most_recent, highest_progress, manual strategies), and edge cases (empty IDs, invalid UUIDs, unauthorized access) - Verify actual database state after resolution, not just HTTP response
2026-04-20 20:43:16 -04:00
parent a56061f2b3
commit 4128734362
2 changed files with 924 additions and 641 deletions
@@ -1,289 +1,525 @@
 package main

 import (
+	"bookhoard/internal/database"
+	"bookhoard/internal/handlers"
 	"bytes"
+	"context"
 	"encoding/json"
-	"net/http/httptest"
+	"net/http"
 	"testing"
+	"time"

 	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

-func TestConflictDetection_TriggeringConditions(t *testing.T) {
-	t.Run("conflict detected when different devices sync within 5 minutes", func(t *testing.T) {
-		conflictData := map[string]map[string]interface{}{
-			"koreader": {
-				"source":    "koreader",
-				"timestamp": "2026-01-30T20:10:00Z",
-				"data": map[string]interface{}{
-					"percentage": 0.45,
-					"epubcfi":    "epubcfi(/6/4/2:15)",
-					"chapter":    3,
-				},
-			},
-			"kobo": {
-				"source":    "kobo",
-				"timestamp": "2026-01-30T20:05:00Z",
-				"data": map[string]interface{}{
-					"percentage": 0.42,
-					"page":       89,
-				},
-			},
-		}
-
-		body, err := json.Marshal(conflictData)
-		assert.NoError(t, err)
-
-		req := httptest.NewRequest("POST", "/api/sync/koreader/progress", bytes.NewReader(body))
-		req.Header.Set("Content-Type", "application/json")
-
-		assert.Equal(t, "POST", req.Method)
-		assert.Contains(t, string(body), "koreader")
-		assert.Contains(t, string(body), "kobo")
-	})
-
-	t.Run("no conflict when progress difference is less than 1%", func(t *testing.T) {
-		progressData := map[string]interface{}{
-			"percentage": 0.45,
-		}
-
-		existingProgress := map[string]interface{}{
-			"percentage": 0.451,
-		}
-
-		diff := progressData["percentage"].(float64) - existingProgress["percentage"].(float64)
-		if diff < 0 {
-			diff = -diff
-		}
-
-		assert.Less(t, diff, 0.01, "Should not trigger conflict for small differences")
-	})
-
-	t.Run("no conflict when sync timestamps are more than 5 minutes apart", func(t *testing.T) {
-		timestamp1 := "2026-01-30T20:00:00Z"
-		timestamp2 := "2026-01-30T20:10:00Z"
-
-		var conflictDetected bool
-		if timestamp2 > timestamp1 {
-			conflictDetected = false
-		}
-
-		assert.False(t, conflictDetected, "Should not trigger conflict for old syncs")
-	})
+type conflictTestEnv struct {
+	setup     *TestServerSetup
+	mediaID   string
+	userID    pgtype.UUID
+	mediaPGID pgtype.UUID
 }

-func TestConflictResolution_ChoosingWinner(t *testing.T) {
-	t.Run("resolve conflict by choosing koreader source", func(t *testing.T) {
-		conflictID := uuid.New()
+func setupConflictTest(t *testing.T) *conflictTestEnv {
+	t.Helper()

-		reqBody := map[string]interface{}{
-			"winner":                        "koreader",
-			"manual_data":                   nil,
-			"apply_to_all_future_conflicts": false,
-			"reason":                        "More recent progress",
-		}
+	setup := setupTestServer(t)
+	mediaID := createTestMediaItemID(t, setup)

-		body, err := json.Marshal(reqBody)
-		assert.NoError(t, err)
+	ctx := context.Background()
+	user, err := setup.DB.GetUserByEmail(ctx, "testuser@tests.bookhoard.internal")
+	require.NoError(t, err)

-		req := httptest.NewRequest("POST", "/api/conflicts/"+conflictID.String()+"/resolve", bytes.NewReader(body))
-		req.Header.Set("Content-Type", "application/json")
+	mediaUUID, err := uuid.Parse(mediaID)
+	require.NoError(t, err)

-		assert.Equal(t, "POST", req.Method)
-		assert.Contains(t, req.URL.Path, conflictID.String())
-		assert.Contains(t, string(body), "koreader")
+	return &conflictTestEnv{
+		setup:     setup,
+		mediaID:   mediaID,
+		userID:    user.ID,
+		mediaPGID: pgtype.UUID{Bytes: [16]byte(mediaUUID), Valid: true},
+	}
+}
+
+func createTestConflict(t *testing.T, env *conflictTestEnv, conflictData map[string]interface{}) database.SyncConflicts {
+	t.Helper()
+	ctx := context.Background()
+
+	dataJSON, err := json.Marshal(conflictData)
+	require.NoError(t, err)
+
+	conflict, err := env.setup.DB.CreateSyncConflict(ctx, database.CreateSyncConflictParams{
+		MediaItemID:  env.mediaPGID,
+		UserID:       env.userID,
+		ConflictType: "progress",
+		ConflictData: dataJSON,
 	})
+	require.NoError(t, err)

-	t.Run("resolve conflict with manual merge data", func(t *testing.T) {
-		conflictID := uuid.New()
+	return conflict
+}

-		manualData := map[string]interface{}{
+func makeConflictData(koreaderPct, koboPct float64) map[string]interface{} {
+	return map[string]interface{}{
+		"koreader": map[string]interface{}{
+			"source":    "koreader",
+			"timestamp": time.Date(2026, 1, 30, 20, 10, 0, 0, time.UTC),
+			"data": map[string]interface{}{
+				"percentage": koreaderPct,
+			},
+		},
+		"kobo": map[string]interface{}{
+			"source":    "kobo",
+			"timestamp": time.Date(2026, 1, 30, 20, 5, 0, 0, time.UTC),
+			"data": map[string]interface{}{
+				"percentage": koboPct,
+			},
+		},
+	}
+}
+
+func TestConflictList_Empty(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	req, _ := http.NewRequest("GET", setup.Server.URL+"/api/conflicts", nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result handlers.ConflictListResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.Equal(t, 0, result.Total)
+	assert.Empty(t, result.Conflicts)
+}
+
+func TestConflictList_WithConflicts(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	createTestConflict(t, env, makeConflictData(0.45, 0.42))
+
+	req, _ := http.NewRequest("GET", env.setup.Server.URL+"/api/conflicts?status=all", nil)
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result handlers.ConflictListResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.GreaterOrEqual(t, result.Total, 1)
+	require.NotEmpty(t, result.Conflicts)
+
+	conflict := result.Conflicts[0]
+	assert.Equal(t, "progress", conflict.ConflictType)
+	assert.Equal(t, "unresolved", conflict.ResolutionStatus)
+	assert.Contains(t, conflict.ConflictData, "koreader")
+	assert.Contains(t, conflict.ConflictData, "kobo")
+}
+
+func TestConflictList_UnresolvedCount(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	createTestConflict(t, env, makeConflictData(0.45, 0.42))
+
+	req, _ := http.NewRequest("GET", env.setup.Server.URL+"/api/conflicts", nil)
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	var result handlers.ConflictListResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.GreaterOrEqual(t, result.Unresolved, 1)
+}
+
+func TestConflictGet_ByID(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.50, 0.30))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	req, _ := http.NewRequest("GET", env.setup.Server.URL+"/api/conflicts/"+conflictID, nil)
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var detail handlers.ConflictDetailResponse
+	json.NewDecoder(resp.Body).Decode(&detail)
+
+	assert.Equal(t, conflictID, detail.ID)
+	assert.Equal(t, env.mediaID, detail.MediaItemID)
+	assert.Equal(t, "progress", detail.ConflictType)
+	assert.Contains(t, detail.ConflictData, "koreader")
+	assert.Contains(t, detail.ConflictData, "kobo")
+}
+
+func TestConflictGet_NotFound(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	req, _ := http.NewRequest("GET", setup.Server.URL+"/api/conflicts/"+uuid.New().String(), nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+}
+
+func TestConflictGet_InvalidID(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	req, _ := http.NewRequest("GET", setup.Server.URL+"/api/conflicts/not-a-uuid", nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+}
+
+func TestConflictResolve_ByKOReader(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.75, 0.30))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner":                        "koreader",
+		"manual_data":                   nil,
+		"apply_to_all_future_conflicts": false,
+		"reason":                        "More recent progress",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result handlers.ConflictResolveResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.True(t, result.ConflictResolved)
+	assert.Equal(t, map[string]bool{"progress": true, "annotations": false}, result.AppliedTo)
+}
+
+func TestConflictResolve_ByKobo(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.30, 0.75))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner":                        "kobo",
+		"apply_to_all_future_conflicts": false,
+		"reason":                        "Higher progress",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result handlers.ConflictResolveResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.True(t, result.ConflictResolved)
+	assert.Equal(t, map[string]bool{"progress": true, "annotations": false}, result.AppliedTo)
+}
+
+func TestConflictResolve_WithManualData(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.45, 0.42))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner": "manual",
+		"manual_data": map[string]interface{}{
 			"percentage": 0.43,
 			"epubcfi":    "epubcfi(/6/4/2:20)",
 			"chapter":    3,
-			"page":       90,
-		}
+		},
+		"apply_to_all_future_conflicts": false,
+		"reason":                        "Custom merged position",
+	}
+	body, _ := json.Marshal(resolveReq)

-		reqBody := map[string]interface{}{
-			"winner":                        "manual",
-			"manual_data":                   manualData,
-			"apply_to_all_future_conflicts": false,
-			"reason":                        "Custom merged position",
-		}
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)

-		body, err := json.Marshal(reqBody)
-		assert.NoError(t, err)
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()

-		req := httptest.NewRequest("POST", "/api/conflicts/"+conflictID.String()+"/resolve", bytes.NewReader(body))
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result handlers.ConflictResolveResponse
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	assert.True(t, result.ConflictResolved)
+}
+
+func TestConflictResolve_ManualWithoutData(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.45, 0.42))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner":      "manual",
+		"manual_data": nil,
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+}
+
+func TestConflictResolve_AlreadyResolved(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.50, 0.30))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner":  "koreader",
+		"reason":  "First resolution",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	req2, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req2.Header.Set("Content-Type", "application/json")
+	req2.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp2, err := client.Do(req2)
+	require.NoError(t, err)
+	defer resp2.Body.Close()
+
+	assert.Equal(t, http.StatusBadRequest, resp2.StatusCode)
+}
+
+func TestConflictResolve_InvalidWinner(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.45, 0.42))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner": "nonexistent_source",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+}
+
+func TestConflictResolve_NotFound(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	resolveReq := map[string]interface{}{
+		"winner": "koreader",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/"+uuid.New().String()+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+}
+
+func TestConflictDelete(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.45, 0.42))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	req, _ := http.NewRequest("DELETE", env.setup.Server.URL+"/api/conflicts/"+conflictID, nil)
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusNoContent, resp.StatusCode)
+
+	req2, _ := http.NewRequest("GET", env.setup.Server.URL+"/api/conflicts/"+conflictID, nil)
+	req2.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp2, err := client.Do(req2)
+	require.NoError(t, err)
+	defer resp2.Body.Close()
+
+	assert.Equal(t, http.StatusNotFound, resp2.StatusCode)
+}
+
+func TestConflictDelete_NotFound(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	req, _ := http.NewRequest("DELETE", setup.Server.URL+"/api/conflicts/"+uuid.New().String(), nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+}
+
+func TestConflictDismissAllResolved(t *testing.T) {
+	env := setupConflictTest(t)
+	client := &http.Client{}
+
+	conflict := createTestConflict(t, env, makeConflictData(0.50, 0.30))
+	conflictID := uuid.UUID(conflict.ID.Bytes).String()
+
+	resolveReq := map[string]interface{}{
+		"winner": "koreader",
+	}
+	body, _ := json.Marshal(resolveReq)
+
+	req, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	req2, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/dismiss-all", nil)
+	req2.Header.Set("Authorization", "Bearer "+env.setup.Token)
+
+	resp2, err := client.Do(req2)
+	require.NoError(t, err)
+	defer resp2.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var result map[string]interface{}
+	json.NewDecoder(resp2.Body).Decode(&result)
+
+	deleted, ok := result["deleted"].(float64)
+	assert.True(t, ok)
+	assert.GreaterOrEqual(t, int(deleted), 1)
+}
+
+func TestConflictEndpoints_RequireAuth(t *testing.T) {
+	setup := setupTestServer(t)
+	client := &http.Client{}
+
+	t.Run("list conflicts requires auth", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/conflicts", nil)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+
+	t.Run("get conflict requires auth", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/conflicts/"+uuid.New().String(), nil)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})
+
+	t.Run("resolve conflict requires auth", func(t *testing.T) {
+		req, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/"+uuid.New().String()+"/resolve", bytes.NewBuffer([]byte(`{}`)))
 		req.Header.Set("Content-Type", "application/json")
-
-		assert.Contains(t, string(body), "manual")
-		assert.Contains(t, string(body), "0.43")
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
 	})

-	t.Run("error when winner is manual but no manual_data provided", func(t *testing.T) {
-		conflictID := uuid.New()
+	t.Run("delete conflict requires auth", func(t *testing.T) {
+		req, _ := http.NewRequest("DELETE", setup.Server.URL+"/api/conflicts/"+uuid.New().String(), nil)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
+	})

-		reqBody := map[string]interface{}{
-			"winner":                        "manual",
-			"manual_data":                   nil,
-			"apply_to_all_future_conflicts": false,
-			"reason":                        "Test",
-		}
-
-		body, err := json.Marshal(reqBody)
-		assert.NoError(t, err)
-
-		req := httptest.NewRequest("POST", "/api/conflicts/"+conflictID.String()+"/resolve", bytes.NewReader(body))
-		req.Header.Set("Content-Type", "application/json")
-
-		assert.Contains(t, string(body), "manual")
-	})
-}
-
-func TestConflictListing_Filtering(t *testing.T) {
-	t.Run("list only unresolved conflicts", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/conflicts?status=unresolved", nil)
-		assert.Equal(t, "GET", req.Method)
-		assert.Contains(t, req.URL.Query().Get("status"), "unresolved")
-	})
-
-	t.Run("list all conflicts regardless of status", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/conflicts?status=all", nil)
-		assert.Equal(t, "GET", req.Method)
-		assert.Contains(t, req.URL.Query().Get("status"), "all")
-	})
-
-	t.Run("list only resolved conflicts", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/conflicts?status=user_resolved", nil)
-		assert.Equal(t, "GET", req.Method)
-		assert.Contains(t, req.URL.Query().Get("status"), "user_resolved")
-	})
-}
-
-func TestConflictResponse_Structure(t *testing.T) {
-	t.Run("conflict detail response includes all required fields", func(t *testing.T) {
-		conflictResponse := map[string]interface{}{
-			"id":                "conflict-uuid-123",
-			"media_item_id":     "book-uuid-456",
-			"media_item_title":  "Test Book Title",
-			"conflict_type":     "progress",
-			"resolution_status": "unresolved",
-			"created_at":        "2026-01-30T20:10:00Z",
-			"conflict_data": map[string]interface{}{
-				"koreader": map[string]interface{}{
-					"source": "koreader",
-					"data": map[string]interface{}{
-						"percentage": 0.45,
-					},
-				},
-				"kobo": map[string]interface{}{
-					"source": "kobo",
-					"data": map[string]interface{}{
-						"percentage": 0.42,
-					},
-				},
-			},
-		}
-
-		body, err := json.Marshal(conflictResponse)
-		assert.NoError(t, err)
-
-		var parsed map[string]interface{}
-		err = json.Unmarshal(body, &parsed)
-		assert.NoError(t, err)
-
-		assert.Contains(t, parsed, "id")
-		assert.Contains(t, parsed, "media_item_id")
-		assert.Contains(t, parsed, "conflict_data")
-		assert.Contains(t, parsed["conflict_data"].(map[string]interface{}), "koreader")
-		assert.Contains(t, parsed["conflict_data"].(map[string]interface{}), "kobo")
-	})
-
-	t.Run("conflict list response includes summary counts", func(t *testing.T) {
-		listResponse := map[string]interface{}{
-			"conflicts": []interface{}{
-				map[string]string{"id": "conflict-1", "resolution_status": "unresolved"},
-				map[string]string{"id": "conflict-2", "resolution_status": "unresolved"},
-			},
-			"total":      2,
-			"unresolved": 2,
-		}
-
-		body, err := json.Marshal(listResponse)
-		assert.NoError(t, err)
-
-		var parsed map[string]interface{}
-		err = json.Unmarshal(body, &parsed)
-		assert.NoError(t, err)
-
-		assert.Equal(t, float64(2), parsed["total"])
-		assert.Equal(t, float64(2), parsed["unresolved"])
-	})
-}
-
-func TestConflictDeletion(t *testing.T) {
-	t.Run("delete single conflict by ID", func(t *testing.T) {
-		conflictID := uuid.New()
-
-		req := httptest.NewRequest("DELETE", "/api/conflicts/"+conflictID.String(), nil)
-		assert.Equal(t, "DELETE", req.Method)
-		assert.Contains(t, req.URL.Path, conflictID.String())
-	})
-
-	t.Run("dismiss all resolved conflicts", func(t *testing.T) {
-		req := httptest.NewRequest("POST", "/api/conflicts/dismiss-all", nil)
-		assert.Equal(t, "POST", req.Method)
-		assert.Contains(t, req.URL.Path, "dismiss-all")
-	})
-}
-
-func TestConflictNotification_WebSocketBroadcast(t *testing.T) {
-	t.Run("conflict detection notification", func(t *testing.T) {
-		notification := map[string]interface{}{
-			"type":      "conflict",
-			"timestamp": "2026-01-30T20:10:00Z",
-			"data": map[string]interface{}{
-				"book_id":           "book-uuid-123",
-				"notification_type": "detection",
-				"conflict_id":       "",
-			},
-		}
-
-		body, err := json.Marshal(notification)
-		assert.NoError(t, err)
-
-		var parsed map[string]interface{}
-		err = json.Unmarshal(body, &parsed)
-		assert.NoError(t, err)
-
-		data := parsed["data"].(map[string]interface{})
-		assert.Equal(t, "detection", data["notification_type"])
-	})
-
-	t.Run("conflict resolved notification", func(t *testing.T) {
-		conflictID := uuid.New()
-
-		notification := map[string]interface{}{
-			"type":      "conflict",
-			"timestamp": "2026-01-30T20:15:00Z",
-			"data": map[string]interface{}{
-				"book_id":           "book-uuid-123",
-				"notification_type": "resolved",
-				"conflict_id":       conflictID.String(),
-			},
-		}
-
-		body, err := json.Marshal(notification)
-		assert.NoError(t, err)
-
-		var parsed map[string]interface{}
-		err = json.Unmarshal(body, &parsed)
-		assert.NoError(t, err)
-
-		data := parsed["data"].(map[string]interface{})
-		assert.Equal(t, "resolved", data["notification_type"])
-		assert.Equal(t, conflictID.String(), data["conflict_id"])
+	t.Run("dismiss-all requires auth", func(t *testing.T) {
+		req, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/dismiss-all", nil)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
 	})
 }