Bookhoard/bookhoard
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 12 Wiki Activity
Files
6fcd7f4400fa1296e825fcaed66eb0352a69caf2
bookhoard/cmd/server/tests/conflicts_bulk_test.go
T
john-okeefe a6700f73e0 fix(tests): handle all Close() and Decode() errors across integration tests 
Replace all unhandled resp.Body.Close() calls throughout the test suite:

- Deferred calls: replace 'defer VAR.Body.Close()' with a closure that explicitly
  discards the error via 'defer func(Body io.ReadCloser) { _ = Body.Close() }(VAR.Body)'
- Immediate calls: replace 'VAR.Body.Close()' with '_ = VAR.Body.Close()'

Replace all unhandled json.NewDecoder(VAR.Body).Decode(&x) calls with error capture
and require.NoError assertion. Files using httptest.ResponseRecorder (collections_preview,
processing_issues) use 'err :=' declaration; suite-style tests (scanner_integration,
dashboard_integration) use s.T() instead of t.
2026-04-21 20:33:05 -04:00

519 lines
15 KiB
Go
Raw Blame History

package main
import (
"bookhoard/internal/handlers"
"bytes"
"encoding/json"
"io"
"net/http"
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestBulkResolve_MostRecentStrategy(t *testing.T) {
env := setupConflictTest(t)
client := &http.Client{}
conflict1 := createTestConflict(t, env, makeConflictData(0.45, 0.42))
conflict2 := createTestConflict(t, env, makeConflictData(0.60, 0.55))
id1 := uuid.UUID(conflict1.ID.Bytes).String()
id2 := uuid.UUID(conflict2.ID.Bytes).String()
req := handlers.BulkResolveRequest{
ConflictIDs: []string{id1, id2},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 2, result.Total)
assert.Equal(t, 2, result.Success)
assert.Equal(t, 0, result.Failed)
require.Len(t, result.Results, 2)
for _, r := range result.Results {
assert.Equal(t, "success", r.Status)
assert.Equal(t, "koreader", r.Winner)
}
}
func TestBulkResolve_HighestProgressStrategy(t *testing.T) {
env := setupConflictTest(t)
client := &http.Client{}
conflictDataHighKobo := makeConflictData(0.30, 0.90)
conflict := createTestConflict(t, env, conflictDataHighKobo)
conflictID := uuid.UUID(conflict.ID.Bytes).String()
req := handlers.BulkResolveRequest{
ConflictIDs: []string{conflictID},
Strategy: "highest_progress",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Total)
assert.Equal(t, 1, result.Success)
assert.Equal(t, 0, result.Failed)
assert.Equal(t, "kobo", result.Results[0].Winner)
}
func TestBulkResolve_ManualStrategy(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 := handlers.BulkResolveRequest{
ConflictIDs: []string{conflictID},
Strategy: "manual",
WinningSource: "koreader",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Total)
assert.Equal(t, 1, result.Success)
assert.Equal(t, "koreader", result.Results[0].Winner)
}
func TestBulkResolve_ManualStrategy_WithoutWinner(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 := handlers.BulkResolveRequest{
ConflictIDs: []string{conflictID},
Strategy: "manual",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Failed)
assert.Equal(t, "error", result.Results[0].Status)
assert.Contains(t, result.Results[0].Error, "winning_source")
}
func TestBulkResolve_ManualStrategy_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()
req := handlers.BulkResolveRequest{
ConflictIDs: []string{conflictID},
Strategy: "manual",
WinningSource: "nonexistent_device",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Failed)
assert.Contains(t, result.Results[0].Error, "invalid winning source")
}
func TestBulkResolve_ConflictNotFound(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := handlers.BulkResolveRequest{
ConflictIDs: []string{uuid.New().String()},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Total)
assert.Equal(t, 0, result.Success)
assert.Equal(t, 1, result.Failed)
assert.Contains(t, result.Results[0].Error, "conflict not found")
}
func TestBulkResolve_EmptyConflictIDs(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := handlers.BulkResolveRequest{
ConflictIDs: []string{},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
}
func TestBulkResolve_InvalidConflictID(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := handlers.BulkResolveRequest{
ConflictIDs: []string{"not-a-uuid"},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 1, result.Failed)
assert.Contains(t, result.Results[0].Error, "invalid conflict ID")
}
func TestBulkResolve_InvalidRequestBody(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer([]byte("invalid json")))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
}
func TestBulkResolve_RequiresAuth(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := handlers.BulkResolveRequest{
ConflictIDs: []string{uuid.New().String()},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
}
func TestBulkDismiss_RealConflicts(t *testing.T) {
env := setupConflictTest(t)
client := &http.Client{}
conflict1 := createTestConflict(t, env, makeConflictData(0.45, 0.42))
conflict2 := createTestConflict(t, env, makeConflictData(0.60, 0.55))
id1 := uuid.UUID(conflict1.ID.Bytes).String()
id2 := uuid.UUID(conflict2.ID.Bytes).String()
req := map[string]interface{}{
"conflict_ids": []string{id1, id2},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, float64(2), result["total"])
assert.Equal(t, float64(2), result["success"])
assert.Equal(t, float64(0), result["failed"])
results := result["results"].([]interface{})
require.Len(t, results, 2)
for _, r := range results {
entry := r.(map[string]interface{})
assert.Equal(t, "success", entry["status"])
}
}
func TestBulkDismiss_NotFoundConflict(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := map[string]interface{}{
"conflict_ids": []string{uuid.New().String()},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, float64(1), result["total"])
assert.Equal(t, float64(0), result["success"])
assert.Equal(t, float64(1), result["failed"])
}
func TestBulkDismiss_InvalidConflictID(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := map[string]interface{}{
"conflict_ids": []string{"invalid-uuid"},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, float64(1), result["total"])
assert.Equal(t, float64(1), result["failed"])
assert.Contains(t, result["results"].([]interface{})[0].(map[string]interface{})["error"], "invalid conflict ID")
}
func TestBulkDismiss_EmptyConflictIDs(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := map[string]interface{}{
"conflict_ids": []string{},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
}
func TestBulkDismiss_InvalidRequestBody(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer([]byte("invalid json")))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
}
func TestBulkDismiss_RequiresAuth(t *testing.T) {
setup := setupTestServer(t)
client := &http.Client{}
req := map[string]interface{}{
"conflict_ids": []string{uuid.New().String()},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/conflicts/bulk-dismiss", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
}
func TestBulkResolve_MixedSuccessAndFailure(t *testing.T) {
env := setupConflictTest(t)
client := &http.Client{}
conflict := createTestConflict(t, env, makeConflictData(0.45, 0.42))
realID := uuid.UUID(conflict.ID.Bytes).String()
req := handlers.BulkResolveRequest{
ConflictIDs: []string{realID, uuid.New().String()},
Strategy: "most_recent",
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/bulk-resolve", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+env.setup.Token)
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer func(Body io.ReadCloser) {
_ = Body.Close()
}(resp.Body)
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result handlers.BulkResolveResponse
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 2, result.Total)
assert.Equal(t, 1, result.Success)
assert.Equal(t, 1, result.Failed)
}
Reference in New Issue View Git Blame Copy Permalink