From a6700f73e0c91a2a993f42640ebebb25d1b7ffae Mon Sep 17 00:00:00 2001 From: John O'Keefe Date: Tue, 21 Apr 2026 20:33:05 -0400 Subject: [PATCH] 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. --- cmd/server/tests/book_matching_test.go | 142 +++++++++++++----- cmd/server/tests/collections_bulk_test.go | 98 ++++++++---- cmd/server/tests/collections_preview_test.go | 27 ++-- .../tests/comic_metadata_display_test.go | 96 +++++++++--- cmd/server/tests/conflict_test.go | 125 ++++++++++----- cmd/server/tests/conflicts_bulk_test.go | 102 +++++++++---- .../tests/dashboard_integration_test.go | 41 +++-- cmd/server/tests/device_cap_test.go | 62 +++++--- cmd/server/tests/filters_test.go | 92 ++++++++---- cmd/server/tests/fsnotify_integration_test.go | 35 +++-- cmd/server/tests/jobs_test.go | 35 +++-- cmd/server/tests/kobo_test.go | 30 +++- cmd/server/tests/media_bulk_test.go | 67 ++++++--- cmd/server/tests/media_item_isbn_test.go | 81 +++++++--- cmd/server/tests/opds_test.go | 92 +++++++++--- cmd/server/tests/processing_issues_test.go | 6 +- cmd/server/tests/refresh_token_test.go | 82 +++++++--- .../tests/scan_settings_integration_test.go | 20 ++- cmd/server/tests/scanner_integration_test.go | 29 ++-- cmd/server/tests/search_test.go | 21 ++- cmd/server/tests/search_unified_test.go | 7 +- cmd/server/tests/setup_integration_test.go | 67 ++++++--- cmd/server/tests/seven_day_session_test.go | 32 ++-- cmd/server/tests/tags_filter_test.go | 7 +- cmd/server/tests/test_helpers_db_test.go | 12 +- cmd/server/tests/test_helpers_test.go | 37 +++-- cmd/server/tests/websocket_test.go | 22 ++- cmd/server/tests/worker_test.go | 12 +- 28 files changed, 1065 insertions(+), 414 deletions(-) diff --git a/cmd/server/tests/book_matching_test.go b/cmd/server/tests/book_matching_test.go index f90b04f..dc04a39 100644 --- a/cmd/server/tests/book_matching_test.go +++ b/cmd/server/tests/book_matching_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "testing" @@ -27,7 +28,9 @@ func TestBookMatchingQueryBooks(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -47,12 +50,15 @@ func TestBookMatchingQueryBooks(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "matches") assert.Contains(t, result, "action") @@ -67,7 +73,9 @@ func TestBookMatchingQueryBooks(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -85,12 +93,15 @@ func TestBookMatchingQueryBooks(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) var matches []interface{} if matchesIf, ok := result["matches"]; ok && matchesIf != nil { @@ -124,7 +135,9 @@ func TestBookMatchingBulkLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -142,12 +155,15 @@ func TestBookMatchingBulkLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 0.0, result["total"]) assert.Equal(t, 0.0, result["successful"]) @@ -175,12 +191,15 @@ func TestBookMatchingBulkLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -221,12 +240,15 @@ func TestBookMatchingBulkLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 3.0, result["total"]) results := result["results"].([]interface{}) @@ -251,7 +273,9 @@ func TestBookMatchingAutoLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -267,12 +291,15 @@ func TestBookMatchingAutoLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "auto_linked") assert.Contains(t, result, "results") @@ -292,12 +319,15 @@ func TestBookMatchingAutoLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "auto_linked") }) @@ -315,12 +345,15 @@ func TestBookMatchingAutoLink(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) // Should succeed even with no books to link assert.Contains(t, result, "auto_linked") @@ -338,7 +371,9 @@ func TestBookMatchingSuggestions(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -350,7 +385,9 @@ func TestBookMatchingSuggestions(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -363,7 +400,9 @@ func TestBookMatchingSuggestions(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNotFound, resp.StatusCode) }) @@ -378,7 +417,9 @@ func TestBookMatchingSuggestions(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Even when book not found, we expect 404 assert.Equal(t, http.StatusNotFound, resp.StatusCode) @@ -396,7 +437,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -409,12 +452,15 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "device_id") assert.Contains(t, result, "aliases") @@ -439,7 +485,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -462,7 +510,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -485,7 +535,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -505,7 +557,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -519,7 +573,9 @@ func TestBookMatchingDeviceFileAliases(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -535,7 +591,9 @@ func TestBookMatchingGetBookMatches(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -547,12 +605,15 @@ func TestBookMatchingGetBookMatches(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "matches") assert.Contains(t, result, "action") @@ -565,7 +626,9 @@ func TestBookMatchingGetBookMatches(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -577,12 +640,15 @@ func TestBookMatchingGetBookMatches(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "matches") }) diff --git a/cmd/server/tests/collections_bulk_test.go b/cmd/server/tests/collections_bulk_test.go index d30d529..4f2a881 100644 --- a/cmd/server/tests/collections_bulk_test.go +++ b/cmd/server/tests/collections_bulk_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "testing" @@ -44,7 +45,9 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -61,7 +64,9 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -85,12 +90,15 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -122,10 +130,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult) + err = json.NewDecoder(resp.Body).Decode(&collectionResult) + require.NoError(t, err) collectionID := collectionResult["id"].(string) // Now try to add invalid book IDs @@ -145,12 +156,15 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(addHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) results := result["results"].([]interface{}) firstResult := results[0].(map[string]interface{}) @@ -171,10 +185,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult) + err = json.NewDecoder(resp.Body).Decode(&collectionResult) + require.NoError(t, err) collectionID := collectionResult["id"].(string) // Create a book @@ -197,12 +214,15 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(addHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -228,10 +248,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult) + err = json.NewDecoder(resp.Body).Decode(&collectionResult) + require.NoError(t, err) collectionID := collectionResult["id"].(string) // Create multiple books @@ -256,12 +279,15 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(addHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 3.0, result["total"]) assert.True(t, result["added"].(float64) > 0) @@ -281,10 +307,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult1 map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult1) + err = json.NewDecoder(resp.Body).Decode(&collectionResult1) + require.NoError(t, err) collectionID1 := collectionResult1["id"].(string) collectionReq2 := map[string]interface{}{ @@ -299,10 +328,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(collectionHTTP2) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult2 map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult2) + err = json.NewDecoder(resp.Body).Decode(&collectionResult2) + require.NoError(t, err) collectionID2 := collectionResult2["id"].(string) // Create books @@ -330,12 +362,15 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(addHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Equal(t, 3.0, result["total"]) @@ -355,10 +390,13 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var collectionResult map[string]interface{} - json.NewDecoder(resp.Body).Decode(&collectionResult) + err = json.NewDecoder(resp.Body).Decode(&collectionResult) + require.NoError(t, err) collectionID := collectionResult["id"].(string) // Create a book @@ -381,7 +419,9 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err = client.Do(addHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Try to add same book again - create new request with fresh body addBody2, _ := json.Marshal(addReq) @@ -391,7 +431,9 @@ func TestCollectionsBulkOperations(t *testing.T) { resp2, err := client.Do(addHTTP2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) // Should handle duplicate gracefully (either succeed or return error) assert.Equal(t, http.StatusOK, resp2.StatusCode) @@ -405,7 +447,9 @@ func TestCollectionsBulkOperations(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) diff --git a/cmd/server/tests/collections_preview_test.go b/cmd/server/tests/collections_preview_test.go index 0ef7d07..86db240 100644 --- a/cmd/server/tests/collections_preview_test.go +++ b/cmd/server/tests/collections_preview_test.go @@ -112,7 +112,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 0, len(items), "Empty rules should return no matched items") @@ -139,7 +140,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 2, len(items), "Should return exactly 2 manually selected books") @@ -171,7 +173,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Greater(t, len(items), 0, "Should return books matching the genre rule") @@ -203,7 +206,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Greater(t, len(items), 0, "Should return books from rules and manual selection") @@ -233,7 +237,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.LessOrEqual(t, len(items), 2, "Should respect limit parameter") @@ -259,7 +264,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 1, len(items), "Should still return items when limit exceeds max") @@ -285,7 +291,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 1, len(items), "Limit 0 should default to 20 and still return matched items") @@ -312,7 +319,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 1, len(items), "Invalid book IDs should be skipped, valid ones included") @@ -340,7 +348,8 @@ func TestPreviewCollection(t *testing.T) { assert.Equal(t, http.StatusOK, rec.Code) var result map[string]interface{} - json.NewDecoder(rec.Body).Decode(&result) + err := json.NewDecoder(rec.Body).Decode(&result) + require.NoError(t, err) items := result["items"].([]interface{}) assert.Equal(t, 1, len(items), "Duplicate book IDs should result in unique items") diff --git a/cmd/server/tests/comic_metadata_display_test.go b/cmd/server/tests/comic_metadata_display_test.go index 73cbae0..3c5161e 100644 --- a/cmd/server/tests/comic_metadata_display_test.go +++ b/cmd/server/tests/comic_metadata_display_test.go @@ -132,7 +132,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -152,7 +154,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -169,7 +173,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -190,7 +196,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -210,7 +218,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -227,7 +237,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -244,7 +256,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -262,7 +276,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -280,7 +296,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -298,7 +316,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -316,7 +336,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -334,7 +356,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -353,7 +377,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -371,7 +397,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -389,7 +417,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -439,7 +469,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -469,7 +501,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -500,7 +534,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -526,7 +562,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -567,7 +605,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -594,7 +634,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req, _ := http.NewRequest("GET", setup.Server.URL+"/media/"+mediaUUID, nil) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode, "Should require authentication") }) @@ -610,7 +652,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.RegularToken) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -629,7 +673,9 @@ func TestComicMetadataDisplay_ComicDetailPage(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) @@ -719,7 +765,9 @@ func TestComicMetadataDisplay_AllFieldsTogether(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.Token) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) body := readBody(resp) diff --git a/cmd/server/tests/conflict_test.go b/cmd/server/tests/conflict_test.go index 6965bf5..5a2c552 100644 --- a/cmd/server/tests/conflict_test.go +++ b/cmd/server/tests/conflict_test.go @@ -6,6 +6,7 @@ import ( "bytes" "context" "encoding/json" + "io" "net/http" "testing" "time" @@ -90,12 +91,15 @@ func TestConflictList_Empty(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.ConflictListResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 0, result.Total) assert.Empty(t, result.Conflicts) @@ -112,12 +116,15 @@ func TestConflictList_WithConflicts(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.ConflictListResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.GreaterOrEqual(t, result.Total, 1) require.NotEmpty(t, result.Conflicts) @@ -140,10 +147,13 @@ func TestConflictList_UnresolvedCount(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var result handlers.ConflictListResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.GreaterOrEqual(t, result.Unresolved, 1) } @@ -160,12 +170,15 @@ func TestConflictGet_ByID(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var detail handlers.ConflictDetailResponse - json.NewDecoder(resp.Body).Decode(&detail) + err = json.NewDecoder(resp.Body).Decode(&detail) + require.NoError(t, err) assert.Equal(t, conflictID, detail.ID) assert.Equal(t, env.mediaID, detail.MediaItemID) @@ -183,7 +196,9 @@ func TestConflictGet_NotFound(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNotFound, resp.StatusCode) } @@ -197,7 +212,9 @@ func TestConflictGet_InvalidID(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -223,12 +240,15 @@ func TestConflictResolve_ByKOReader(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.ConflictResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.True(t, result.ConflictResolved) assert.Equal(t, map[string]bool{"progress": true, "annotations": false}, result.AppliedTo) @@ -254,12 +274,15 @@ func TestConflictResolve_ByKobo(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.ConflictResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.True(t, result.ConflictResolved) assert.Equal(t, map[string]bool{"progress": true, "annotations": false}, result.AppliedTo) @@ -290,12 +313,15 @@ func TestConflictResolve_WithManualData(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.ConflictResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.True(t, result.ConflictResolved) } @@ -319,7 +345,9 @@ func TestConflictResolve_ManualWithoutData(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -332,8 +360,8 @@ func TestConflictResolve_AlreadyResolved(t *testing.T) { conflictID := uuid.UUID(conflict.ID.Bytes).String() resolveReq := map[string]interface{}{ - "winner": "koreader", - "reason": "First resolution", + "winner": "koreader", + "reason": "First resolution", } body, _ := json.Marshal(resolveReq) @@ -343,7 +371,9 @@ func TestConflictResolve_AlreadyResolved(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) req2, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/"+conflictID+"/resolve", bytes.NewBuffer(body)) @@ -352,7 +382,9 @@ func TestConflictResolve_AlreadyResolved(t *testing.T) { resp2, err := client.Do(req2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) assert.Equal(t, http.StatusBadRequest, resp2.StatusCode) } @@ -375,7 +407,9 @@ func TestConflictResolve_InvalidWinner(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -395,7 +429,9 @@ func TestConflictResolve_NotFound(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNotFound, resp.StatusCode) } @@ -412,7 +448,9 @@ func TestConflictDelete(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNoContent, resp.StatusCode) @@ -421,7 +459,9 @@ func TestConflictDelete(t *testing.T) { resp2, err := client.Do(req2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) assert.Equal(t, http.StatusNotFound, resp2.StatusCode) } @@ -435,7 +475,9 @@ func TestConflictDelete_NotFound(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNotFound, resp.StatusCode) } @@ -458,7 +500,9 @@ func TestConflictDismissAllResolved(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) req2, _ := http.NewRequest("POST", env.setup.Server.URL+"/api/conflicts/dismiss-all", nil) @@ -466,12 +510,15 @@ func TestConflictDismissAllResolved(t *testing.T) { resp2, err := client.Do(req2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp2.Body).Decode(&result) + err = json.NewDecoder(resp2.Body).Decode(&result) + require.NoError(t, err) deleted, ok := result["deleted"].(float64) assert.True(t, ok) @@ -486,7 +533,9 @@ func TestConflictEndpoints_RequireAuth(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() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -494,7 +543,9 @@ func TestConflictEndpoints_RequireAuth(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() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -503,7 +554,9 @@ func TestConflictEndpoints_RequireAuth(t *testing.T) { req.Header.Set("Content-Type", "application/json") resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -511,7 +564,9 @@ func TestConflictEndpoints_RequireAuth(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() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -519,7 +574,9 @@ func TestConflictEndpoints_RequireAuth(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() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) } diff --git a/cmd/server/tests/conflicts_bulk_test.go b/cmd/server/tests/conflicts_bulk_test.go index 64088a5..1f79ff7 100644 --- a/cmd/server/tests/conflicts_bulk_test.go +++ b/cmd/server/tests/conflicts_bulk_test.go @@ -4,6 +4,7 @@ import ( "bookhoard/internal/handlers" "bytes" "encoding/json" + "io" "net/http" "testing" @@ -34,12 +35,15 @@ func TestBulkResolve_MostRecentStrategy(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 2, result.Total) assert.Equal(t, 2, result.Success) @@ -73,12 +77,15 @@ func TestBulkResolve_HighestProgressStrategy(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 1, result.Total) assert.Equal(t, 1, result.Success) @@ -106,12 +113,15 @@ func TestBulkResolve_ManualStrategy(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 1, result.Total) assert.Equal(t, 1, result.Success) @@ -137,12 +147,15 @@ func TestBulkResolve_ManualStrategy_WithoutWinner(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + 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) @@ -169,12 +182,15 @@ func TestBulkResolve_ManualStrategy_InvalidWinner(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + 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") @@ -196,12 +212,15 @@ func TestBulkResolve_ConflictNotFound(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 1, result.Total) assert.Equal(t, 0, result.Success) @@ -225,7 +244,9 @@ func TestBulkResolve_EmptyConflictIDs(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -246,12 +267,15 @@ func TestBulkResolve_InvalidConflictID(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + 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") @@ -267,7 +291,9 @@ func TestBulkResolve_InvalidRequestBody(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -287,7 +313,9 @@ func TestBulkResolve_RequiresAuth(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) } @@ -313,12 +341,15 @@ func TestBulkDismiss_RealConflicts(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + 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"]) @@ -347,12 +378,15 @@ func TestBulkDismiss_NotFoundConflict(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + 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"]) @@ -374,12 +408,15 @@ func TestBulkDismiss_InvalidConflictID(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + 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"]) @@ -401,7 +438,9 @@ func TestBulkDismiss_EmptyConflictIDs(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -416,7 +455,9 @@ func TestBulkDismiss_InvalidRequestBody(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -435,7 +476,9 @@ func TestBulkDismiss_RequiresAuth(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) } @@ -459,12 +502,15 @@ func TestBulkResolve_MixedSuccessAndFailure(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result handlers.BulkResolveResponse - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, 2, result.Total) assert.Equal(t, 1, result.Success) diff --git a/cmd/server/tests/dashboard_integration_test.go b/cmd/server/tests/dashboard_integration_test.go index a4ec9de..b47d338 100644 --- a/cmd/server/tests/dashboard_integration_test.go +++ b/cmd/server/tests/dashboard_integration_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "io" "net/http" "testing" @@ -40,7 +41,9 @@ func (s *DashboardIntegrationTestSuite) TestGetSections_EndToEndFlow() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusOK, resp.StatusCode) @@ -87,7 +90,9 @@ func (s *DashboardIntegrationTestSuite) TestGetSections_MissingLibraryID() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusBadRequest, resp.StatusCode) } @@ -101,7 +106,9 @@ func (s *DashboardIntegrationTestSuite) TestGetSections_InvalidLibraryID() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusBadRequest, resp.StatusCode) } @@ -112,7 +119,9 @@ func (s *DashboardIntegrationTestSuite) TestGetSections_Unauthorized() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusUnauthorized, resp.StatusCode) } @@ -136,7 +145,9 @@ func (s *DashboardIntegrationTestSuite) TestUpdatePreferences_Success() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusOK, resp.StatusCode) @@ -164,7 +175,9 @@ func (s *DashboardIntegrationTestSuite) TestUpdatePreferences_Unauthorized() { client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusUnauthorized, resp.StatusCode) } @@ -184,7 +197,9 @@ func (s *DashboardIntegrationTestSuite) TestRestoreSystemCollection_InvalidName( client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusBadRequest, resp.StatusCode) } @@ -201,7 +216,9 @@ func (s *DashboardIntegrationTestSuite) TestRestoreSystemCollection_Unauthorized client := &http.Client{} resp, err := client.Do(req) require.NoError(s.T(), err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(s.T(), http.StatusUnauthorized, resp.StatusCode) } @@ -224,14 +241,16 @@ func (s *DashboardIntegrationTestSuite) TestRestoreSystemCollection_ValidNames() client := &http.Client{} resp, err := client.Do(req) - require.NoError(t, err) - defer resp.Body.Close() + require.NoError(s.T(), err) + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} err = json.NewDecoder(resp.Body).Decode(&response) - require.NoError(t, err) + require.NoError(s.T(), err) assert.Contains(t, response, "message") }) diff --git a/cmd/server/tests/device_cap_test.go b/cmd/server/tests/device_cap_test.go index 77ff629..957a6c4 100644 --- a/cmd/server/tests/device_cap_test.go +++ b/cmd/server/tests/device_cap_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/base64" "encoding/json" + "io" "net/http" "net/http/httptest" "strings" @@ -68,7 +69,9 @@ func TestUpdateUserMaxDevices(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, tt.expectedStatus, resp.StatusCode, "expected status code") @@ -134,7 +137,9 @@ func TestUpdateUserMaxDevicesValidation(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, tt.expectedStatus, resp.StatusCode, "expected validation error") }) @@ -166,7 +171,9 @@ func TestUpdateUserMaxDevicesAuth(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -190,7 +197,9 @@ func TestUpdateUserMaxDevicesAuth(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusForbidden, resp.StatusCode) }) @@ -221,7 +230,9 @@ func TestUpdateUserMaxDevicesNonExistentUser(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 500 or 404 depending on implementation assert.True(t, resp.StatusCode == http.StatusInternalServerError || resp.StatusCode == http.StatusNotFound) @@ -250,7 +261,9 @@ func TestUpdateUserMaxDevicesMissingUserID(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -271,12 +284,15 @@ func TestListUsersIncludesMaxDevices(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var users []map[string]interface{} - json.NewDecoder(resp.Body).Decode(&users) + err = json.NewDecoder(resp.Body).Decode(&users) + require.NoError(t, err) // Verify max_devices and device_count fields are present in response if len(users) > 0 { @@ -306,7 +322,7 @@ func createAdminUser(t *testing.T, ts *httptest.Server, token string) { client := &http.Client{} resp, _ := client.Do(req) - resp.Body.Close() + _ = resp.Body.Close() } // Helper function to create test user for max devices tests @@ -327,7 +343,9 @@ func createTestUserForMaxDevices(t *testing.T, ts *httptest.Server, adminToken s client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Check if user creation succeeded or already exists (409 Conflict) if resp.StatusCode == http.StatusConflict { @@ -343,10 +361,13 @@ func createTestUserForMaxDevices(t *testing.T, ts *httptest.Server, adminToken s loginResp, err := client.Do(loginReq) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) // Extract user_id from JWT or response // The access_token contains the user ID in the JWT claims @@ -392,7 +413,8 @@ func createTestUserForMaxDevices(t *testing.T, ts *httptest.Server, adminToken s } var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) // Check if user creation was successful if result["user"] == nil { @@ -422,10 +444,13 @@ func getAdminToken(t *testing.T, ts *httptest.Server, userID uuid.UUID) string { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) // Safe type assertion with check if accessToken, ok := result["access_token"].(string); ok { @@ -450,10 +475,13 @@ func loginTestUserByCredentials(t *testing.T, ts *httptest.Server, email, passwo client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) // Safe type assertion with check if accessToken, ok := result["access_token"].(string); ok { diff --git a/cmd/server/tests/filters_test.go b/cmd/server/tests/filters_test.go index e326096..a874907 100644 --- a/cmd/server/tests/filters_test.go +++ b/cmd/server/tests/filters_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "testing" @@ -19,7 +20,9 @@ func TestSavedFilters(t *testing.T) { httpReq, _ := http.NewRequest("GET", setup.Server.URL+"/api/saved-filters?resource_type=media-items", nil) resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -30,12 +33,15 @@ func TestSavedFilters(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var filters []map[string]interface{} - json.NewDecoder(resp.Body).Decode(&filters) + err = json.NewDecoder(resp.Body).Decode(&filters) + require.NoError(t, err) assert.Equal(t, 0, len(filters)) }) @@ -56,12 +62,15 @@ func TestSavedFilters(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusCreated, resp.StatusCode) var filter map[string]interface{} - json.NewDecoder(resp.Body).Decode(&filter) + err = json.NewDecoder(resp.Body).Decode(&filter) + require.NoError(t, err) assert.Equal(t, "My Sci-Fi Books", filter["name"]) assert.Equal(t, "media-items", filter["resource_type"]) assert.NotEmpty(t, filter["id"]) @@ -84,7 +93,7 @@ func TestSavedFilters(t *testing.T) { resp1, err := client.Do(httpReq1) require.NoError(t, err) - resp1.Body.Close() + _ = resp1.Body.Close() assert.Equal(t, http.StatusCreated, resp1.StatusCode) @@ -96,7 +105,7 @@ func TestSavedFilters(t *testing.T) { resp2, err := client.Do(httpReq2) require.NoError(t, err) - resp2.Body.Close() + _ = resp2.Body.Close() assert.Equal(t, http.StatusConflict, resp2.StatusCode) }) @@ -116,12 +125,15 @@ func TestSavedFilters(t *testing.T) { createResp, err := client.Do(createHTTP) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) assert.Equal(t, http.StatusCreated, createResp.StatusCode) var createdFilter map[string]interface{} - json.NewDecoder(createResp.Body).Decode(&createdFilter) + err = json.NewDecoder(createResp.Body).Decode(&createdFilter) + require.NoError(t, err) filterID := createdFilter["id"].(string) // Update filter @@ -138,12 +150,15 @@ func TestSavedFilters(t *testing.T) { updateResp, err := client.Do(updateHTTP) require.NoError(t, err) - defer updateResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(updateResp.Body) assert.Equal(t, http.StatusOK, updateResp.StatusCode) var updatedFilter map[string]interface{} - json.NewDecoder(updateResp.Body).Decode(&updatedFilter) + err = json.NewDecoder(updateResp.Body).Decode(&updatedFilter) + require.NoError(t, err) assert.Equal(t, "Updated Name", updatedFilter["name"]) }) @@ -162,10 +177,13 @@ func TestSavedFilters(t *testing.T) { createResp, err := client.Do(createHTTP) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) var createdFilter map[string]interface{} - json.NewDecoder(createResp.Body).Decode(&createdFilter) + err = json.NewDecoder(createResp.Body).Decode(&createdFilter) + require.NoError(t, err) filterID := createdFilter["id"].(string) // Delete filter @@ -174,7 +192,7 @@ func TestSavedFilters(t *testing.T) { deleteResp, err := client.Do(deleteHTTP) require.NoError(t, err) - deleteResp.Body.Close() + _ = deleteResp.Body.Close() assert.Equal(t, http.StatusNoContent, deleteResp.StatusCode) }) @@ -198,10 +216,13 @@ func TestSavedFilters(t *testing.T) { createResp, err := client.Do(createHTTP) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) var createdFilter map[string]interface{} - json.NewDecoder(createResp.Body).Decode(&createdFilter) + err = json.NewDecoder(createResp.Body).Decode(&createdFilter) + require.NoError(t, err) filterID := createdFilter["id"].(string) // Admin user tries to delete regular user's filter @@ -210,7 +231,7 @@ func TestSavedFilters(t *testing.T) { deleteResp, err := client.Do(deleteHTTP) require.NoError(t, err) - deleteResp.Body.Close() + _ = deleteResp.Body.Close() assert.Equal(t, http.StatusNotFound, deleteResp.StatusCode) }) @@ -230,12 +251,15 @@ func TestSavedFilters(t *testing.T) { createResp, err := client.Do(createReq) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) assert.Equal(t, http.StatusCreated, createResp.StatusCode) var createdFilter map[string]interface{} - json.NewDecoder(createResp.Body).Decode(&createdFilter) + err = json.NewDecoder(createResp.Body).Decode(&createdFilter) + require.NoError(t, err) filterID := createdFilter["id"].(string) // Now retrieve the filter by ID @@ -244,12 +268,15 @@ func TestSavedFilters(t *testing.T) { getResp, err := client.Do(getReq) require.NoError(t, err) - defer getResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(getResp.Body) assert.Equal(t, http.StatusOK, getResp.StatusCode) var retrievedFilter map[string]interface{} - json.NewDecoder(getResp.Body).Decode(&retrievedFilter) + err = json.NewDecoder(getResp.Body).Decode(&retrievedFilter) + require.NoError(t, err) assert.Equal(t, "Test Filter", retrievedFilter["name"]) assert.Equal(t, "media-items", retrievedFilter["resource_type"]) assert.Equal(t, filterID, retrievedFilter["id"]) @@ -260,7 +287,9 @@ func TestSavedFilters(t *testing.T) { httpReq, _ := http.NewRequest("GET", setup.Server.URL+"/api/saved-filters/550e8400-e29b-41d4-a716-446655440000", nil) resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -271,7 +300,9 @@ func TestSavedFilters(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -283,7 +314,9 @@ func TestSavedFilters(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusNotFound, resp.StatusCode) }) @@ -301,16 +334,21 @@ func TestSavedFilters(t *testing.T) { createReq.Header.Set("Authorization", "Bearer "+setup.Token) createResp, err := client.Do(createReq) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) var createdFilter map[string]interface{} - json.NewDecoder(createResp.Body).Decode(&createdFilter) + err = json.NewDecoder(createResp.Body).Decode(&createdFilter) + require.NoError(t, err) filterID := createdFilter["id"].(string) // Try to access with regular user (setup.RegularToken) httpReq, _ := http.NewRequest("GET", setup.Server.URL+"/api/saved-filters/"+filterID, nil) httpReq.Header.Set("Authorization", "Bearer "+setup.RegularToken) getResp, err := client.Do(httpReq) require.NoError(t, err) - defer getResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(getResp.Body) // Should return 404 (not 403 - hide existence) assert.Equal(t, http.StatusNotFound, getResp.StatusCode) }) diff --git a/cmd/server/tests/fsnotify_integration_test.go b/cmd/server/tests/fsnotify_integration_test.go index 2ff54d4..f31b035 100644 --- a/cmd/server/tests/fsnotify_integration_test.go +++ b/cmd/server/tests/fsnotify_integration_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "io" "net/http" "os" "path/filepath" @@ -31,10 +32,13 @@ func TestFSNotify_BulkFileDetection(t *testing.T) { client := &http.Client{} libResp, err := client.Do(libReq) require.NoError(t, err) - defer libResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(libResp.Body) require.Equal(t, http.StatusCreated, libResp.StatusCode) var libResult map[string]interface{} - json.NewDecoder(libResp.Body).Decode(&libResult) + err = json.NewDecoder(libResp.Body).Decode(&libResult) + require.NoError(t, err) libraryID := libResult["id"].(string) // Add folder to library folderURL := fmt.Sprintf("%s/api/libraries/%s/folders", setup.Server.URL, libraryID) @@ -47,7 +51,9 @@ func TestFSNotify_BulkFileDetection(t *testing.T) { folderHTTPReq.Header.Set("Authorization", "Bearer "+token) folderResp, err := client.Do(folderHTTPReq) require.NoError(t, err) - defer folderResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(folderResp.Body) require.Equal(t, http.StatusCreated, folderResp.StatusCode, "Folder should be added to library") // Create 20 test files simultaneously for i := 0; i < 20; i++ { @@ -61,10 +67,13 @@ func TestFSNotify_BulkFileDetection(t *testing.T) { scanHTTPReq.Header.Set("Authorization", "Bearer "+token) scanResp, err := client.Do(scanHTTPReq) require.NoError(t, err) - defer scanResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(scanResp.Body) require.Equal(t, http.StatusAccepted, scanResp.StatusCode, "Scan should be accepted") var scanResponse map[string]interface{} - json.NewDecoder(scanResp.Body).Decode(&scanResponse) + err = json.NewDecoder(scanResp.Body).Decode(&scanResponse) + require.NoError(t, err) jobID, ok := scanResponse["job_id"].(string) require.True(t, ok, "job_id should be string") require.NotEmpty(t, jobID, "job_id should not be empty") @@ -81,16 +90,17 @@ func TestFSNotify_BulkFileDetection(t *testing.T) { require.NoError(t, err) if statusResp.StatusCode == http.StatusNotFound { - statusResp.Body.Close() + _ = statusResp.Body.Close() break // Job completed } var status map[string]interface{} - json.NewDecoder(statusResp.Body).Decode(&status) - statusResp.Body.Close() + err = json.NewDecoder(statusResp.Body).Decode(&status) + require.NoError(t, err) + _ = statusResp.Body.Close() if status["status"] == "completed" || status["status"] == "failed" { - statusResp.Body.Close() + _ = statusResp.Body.Close() break } } @@ -99,9 +109,12 @@ func TestFSNotify_BulkFileDetection(t *testing.T) { req.Header.Set("Authorization", "Bearer "+token) itemsResp, err := client.Do(req) require.NoError(t, err) - defer itemsResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(itemsResp.Body) var itemsResult map[string]interface{} - json.NewDecoder(itemsResp.Body).Decode(&itemsResult) + err = json.NewDecoder(itemsResp.Body).Decode(&itemsResult) + require.NoError(t, err) items, ok := itemsResult["data"].([]interface{}) if !ok || items == nil { items = []interface{}{} // Handle nil or wrong type diff --git a/cmd/server/tests/jobs_test.go b/cmd/server/tests/jobs_test.go index d65df5f..6f59066 100644 --- a/cmd/server/tests/jobs_test.go +++ b/cmd/server/tests/jobs_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "io" "net/http" "testing" "time" @@ -33,7 +34,9 @@ func TestJobsHandler_CreateJob(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusAccepted, resp.StatusCode) @@ -65,7 +68,9 @@ func TestJobsHandler_CreateJob_InvalidType(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusBadRequest, resp.StatusCode) } @@ -88,7 +93,9 @@ func TestJobsHandler_GetJobStatus(t *testing.T) { client := &http.Client{} createResp, err := client.Do(createReq) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) var createResponse map[string]interface{} err = json.NewDecoder(createResp.Body).Decode(&createResponse) @@ -103,7 +110,9 @@ func TestJobsHandler_GetJobStatus(t *testing.T) { getResp, err := client.Do(getReq) require.NoError(t, err) - defer getResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(getResp.Body) require.Equal(t, http.StatusOK, getResp.StatusCode) @@ -128,7 +137,9 @@ func TestJobsHandler_GetJobStatus_NotFound(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusNotFound, resp.StatusCode) } @@ -151,7 +162,9 @@ func TestJobsHandler_CreateAndTrackJob(t *testing.T) { client := &http.Client{} createResp, err := client.Do(createReq) require.NoError(t, err) - defer createResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(createResp.Body) var createResponse map[string]interface{} err = json.NewDecoder(createResp.Body).Decode(&createResponse) @@ -172,7 +185,7 @@ func TestJobsHandler_CreateAndTrackJob(t *testing.T) { var statusResponse map[string]interface{} err = json.NewDecoder(getResp.Body).Decode(&statusResponse) - getResp.Body.Close() + _ = getResp.Body.Close() require.NoError(t, err) if statusResponse["status"] != nil { @@ -202,7 +215,9 @@ func TestJobsHandler_CreateJob_Unauthorized(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusUnauthorized, resp.StatusCode) } @@ -218,7 +233,9 @@ func TestJobsHandler_GetJobStatus_Unauthorized(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusUnauthorized, resp.StatusCode) } diff --git a/cmd/server/tests/kobo_test.go b/cmd/server/tests/kobo_test.go index fed3f8e..39be11e 100644 --- a/cmd/server/tests/kobo_test.go +++ b/cmd/server/tests/kobo_test.go @@ -5,6 +5,7 @@ import ( "bytes" "encoding/json" "fmt" + "io" "log" "net/http" "net/http/httptest" @@ -37,7 +38,9 @@ func TestKoboInitialization(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) }) @@ -65,7 +68,9 @@ func TestKoboLibrarySync(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) }) @@ -129,11 +134,14 @@ func TestKoboMarkupSync(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "Status") }) } @@ -182,11 +190,14 @@ func TestKoboBookmarkSync(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "Status") }) } @@ -224,11 +235,14 @@ func TestKoboAnalyticsGettests(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "Status") }) } diff --git a/cmd/server/tests/media_bulk_test.go b/cmd/server/tests/media_bulk_test.go index 05fa3d7..3dbf3b8 100644 --- a/cmd/server/tests/media_bulk_test.go +++ b/cmd/server/tests/media_bulk_test.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "encoding/json" + "io" "net/http" "testing" @@ -31,7 +32,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) @@ -58,7 +61,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -76,12 +81,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -106,12 +114,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Equal(t, 3.0, result["total"]) @@ -130,7 +141,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -154,7 +167,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) }) @@ -179,7 +194,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -204,12 +221,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -246,12 +266,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Equal(t, 2.0, result["total"]) @@ -304,12 +327,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") assert.Contains(t, result, "total") @@ -352,12 +378,15 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Contains(t, result, "results") }) @@ -371,7 +400,9 @@ func TestMediaBulkOperations(t *testing.T) { client := &http.Client{} resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) diff --git a/cmd/server/tests/media_item_isbn_test.go b/cmd/server/tests/media_item_isbn_test.go index 290ce8a..70b3837 100644 --- a/cmd/server/tests/media_item_isbn_test.go +++ b/cmd/server/tests/media_item_isbn_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "io" "net/http" "net/http/httptest" "testing" @@ -31,12 +32,15 @@ func createTestLibrary(t *testing.T, ts *httptest.Server, token, name string) st client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) return result["id"].(string) } @@ -164,7 +168,9 @@ func TestMediaItemISBNNormalization(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Check if this is an invalid ISBN case that should return 422 if tc.expected == "" && (tc.input == "---" || tc.input == " ") { @@ -174,7 +180,8 @@ func TestMediaItemISBNNormalization(t *testing.T) { } var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) // For valid ISBN responses, verify normalization worked correctly if resp.StatusCode == http.StatusCreated { @@ -209,7 +216,9 @@ func TestMediaItemISBNEdgeCases(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusCreated, resp.StatusCode) }) @@ -232,10 +241,13 @@ func TestMediaItemISBNEdgeCases(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) assert.Equal(t, http.StatusCreated, resp.StatusCode) assert.Equal(t, "9780306406157", response["isbn"]) @@ -259,10 +271,13 @@ func TestMediaItemISBNEdgeCases(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) assert.Equal(t, http.StatusCreated, resp.StatusCode) assert.Equal(t, "9780596009652", response["isbn"]) @@ -296,7 +311,7 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - resp.Body.Close() + _ = resp.Body.Close() } // Small delay to allow database to commit before pagination queries @@ -309,12 +324,15 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) data := response["data"].([]interface{}) // Should get 2 items @@ -328,12 +346,15 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) data := response["data"].([]interface{}) // Should get 2 items starting from offset 2 @@ -347,7 +368,9 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 400 Bad Request or handle it gracefully assert.NotEqual(t, http.StatusOK, resp.StatusCode) @@ -360,7 +383,9 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 400 Bad Request or handle it gracefully assert.NotEqual(t, http.StatusOK, resp.StatusCode) @@ -373,7 +398,9 @@ func TestMediaItemsPagination(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should be capped at maximum or return error // The application uses maxPaginationLimit = 1000 @@ -404,7 +431,9 @@ func TestMediaItemLibraryRequirement(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should fail - library_id is required assert.NotEqual(t, http.StatusCreated, resp.StatusCode) @@ -431,12 +460,15 @@ func TestMediaItemLibraryRequirement(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusCreated, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) // VerifyISBN was normalized assert.Equal(t, "9780306406157", response["isbn"]) @@ -472,8 +504,9 @@ func TestUpdateMediaItemISBN(t *testing.T) { require.NoError(t, err) var createResponse map[string]interface{} - json.NewDecoder(resp.Body).Decode(&createResponse) - resp.Body.Close() + err = json.NewDecoder(resp.Body).Decode(&createResponse) + require.NoError(t, err) + _ = resp.Body.Close() mediaItemID := createResponse["id"].(string) @@ -491,7 +524,9 @@ func TestUpdateMediaItemISBN(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusUnprocessableEntity, resp.StatusCode) }) diff --git a/cmd/server/tests/opds_test.go b/cmd/server/tests/opds_test.go index 92f59dd..c6e9cb3 100644 --- a/cmd/server/tests/opds_test.go +++ b/cmd/server/tests/opds_test.go @@ -26,7 +26,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // OPDS endpoints require device authentication via devices.auth_token assert.Equal(t, http.StatusUnauthorized, resp.StatusCode) @@ -37,7 +39,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 400 for invalid UUID assert.Equal(t, http.StatusBadRequest, resp.StatusCode) @@ -53,7 +57,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 200 with catalog (even if empty) assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -69,7 +75,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 200 with catalog (even if empty) assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -80,7 +88,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -95,7 +105,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return 200 (even if empty results) assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -106,7 +118,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -120,7 +134,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return navigation or 404 assert.True(t, resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound) @@ -131,7 +147,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -142,7 +160,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -156,7 +176,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // May return 404 if device/book not linked, or 500 for file not found // Should not return 400 (invalid IDs) @@ -168,7 +190,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -178,7 +202,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -192,7 +218,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // May return 404 if no cover, but not 400 assert.NotEqual(t, http.StatusBadRequest, resp.StatusCode) @@ -204,7 +232,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -218,7 +248,9 @@ func TestOPDSEndpoints(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return formats list or 404 assert.True(t, resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound) @@ -245,7 +277,9 @@ func TestOPDSConversion(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should attempt conversion (may fail if file doesn't exist) // Important: Should not return 400 for invalid IDs @@ -262,7 +296,9 @@ func TestOPDSConversion(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should attempt to download original format assert.NotEqual(t, http.StatusBadRequest, resp.StatusCode) @@ -278,7 +314,9 @@ func TestOPDSConversion(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should handle gracefully (either 400 for unsupported format or 404/500) assert.True(t, resp.StatusCode >= 400 && resp.StatusCode < 600) @@ -300,7 +338,9 @@ func TestOPDSEdgeCases(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should return empty catalog, not error assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -316,7 +356,9 @@ func TestOPDSEdgeCases(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should handle special characters assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -331,7 +373,9 @@ func TestOPDSEdgeCases(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should handle empty query assert.True(t, resp.StatusCode >= 200 && resp.StatusCode < 500) @@ -371,7 +415,9 @@ func TestOPDSSearchAcrossLibraries(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) t.Logf("OPDS Search Status: %d", resp.StatusCode) diff --git a/cmd/server/tests/processing_issues_test.go b/cmd/server/tests/processing_issues_test.go index 19ecffd..03351c8 100644 --- a/cmd/server/tests/processing_issues_test.go +++ b/cmd/server/tests/processing_issues_test.go @@ -388,7 +388,8 @@ func TestProcessingIssuesCrossLibraryIsolation(t *testing.T) { setup.Server.Config.Handler.ServeHTTP(rec1, req1) var stats1 map[string]interface{} - json.NewDecoder(rec1.Body).Decode(&stats1) + err := json.NewDecoder(rec1.Body).Decode(&stats1) + require.NoError(t, err) // Get stats for library 2 req2 := httptest.NewRequest("GET", "/api/libraries/"+library2ID+"/issues/stats", nil) @@ -398,7 +399,8 @@ func TestProcessingIssuesCrossLibraryIsolation(t *testing.T) { setup.Server.Config.Handler.ServeHTTP(rec2, req2) var stats2 map[string]interface{} - json.NewDecoder(rec2.Body).Decode(&stats2) + err = json.NewDecoder(rec2.Body).Decode(&stats2) + require.NoError(t, err) // Both should have zero counts assert.Equal(t, float64(0), stats1["error_count"]) diff --git a/cmd/server/tests/refresh_token_test.go b/cmd/server/tests/refresh_token_test.go index f310cb7..59e7ae0 100644 --- a/cmd/server/tests/refresh_token_test.go +++ b/cmd/server/tests/refresh_token_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "testing" @@ -24,7 +25,9 @@ func TestRefreshTokenFlow(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -40,7 +43,9 @@ func TestRefreshTokenFlow(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -58,12 +63,15 @@ func TestRefreshTokenFlow(t *testing.T) { loginResp, err := client.Do(loginHTTP) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) require.Equal(t, http.StatusOK, loginResp.StatusCode) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) refreshToken, ok := loginResult["refresh_token"].(string) require.True(t, ok, "Should have refresh_token") @@ -79,12 +87,15 @@ func TestRefreshTokenFlow(t *testing.T) { refreshResp, err := client.Do(refreshHTTP) require.NoError(t, err) - defer refreshResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp.Body) assert.Equal(t, http.StatusOK, refreshResp.StatusCode) var refreshResult map[string]interface{} - json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + err = json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + require.NoError(t, err) assert.Contains(t, refreshResult, "access_token") assert.NotEmpty(t, refreshResult["access_token"], "New access token should not be empty") @@ -102,7 +113,9 @@ func TestRefreshTokenFlow(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -118,7 +131,9 @@ func TestRefreshTokenFlow(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Should still work or return appropriate error assert.True(t, resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusBadRequest || resp.StatusCode == http.StatusUnsupportedMediaType) @@ -143,12 +158,15 @@ func TestRefreshTokenSecurity(t *testing.T) { loginResp, err := client.Do(loginHTTP) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) require.Equal(t, http.StatusOK, loginResp.StatusCode) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) refreshToken := loginResult["refresh_token"].(string) @@ -163,7 +181,9 @@ func TestRefreshTokenSecurity(t *testing.T) { refreshResp1, err := client.Do(refreshHTTP1) require.NoError(t, err) - defer refreshResp1.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp1.Body) assert.Equal(t, http.StatusOK, refreshResp1.StatusCode) @@ -173,7 +193,9 @@ func TestRefreshTokenSecurity(t *testing.T) { refreshResp2, err := client.Do(refreshHTTP2) require.NoError(t, err) - defer refreshResp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp2.Body) // May return 401 if token reuse is detected, or 200 if not implemented // Either is acceptable depending on security requirements @@ -197,7 +219,9 @@ func TestRefreshTokenEdgeCases(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -213,7 +237,9 @@ func TestRefreshTokenEdgeCases(t *testing.T) { resp, err := client.Do(httpReq) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusBadRequest, resp.StatusCode) }) @@ -231,12 +257,15 @@ func TestRefreshTokenEdgeCases(t *testing.T) { loginResp, err := client.Do(loginHTTP) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) require.Equal(t, http.StatusOK, loginResp.StatusCode) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) refreshToken := loginResult["refresh_token"].(string) @@ -251,12 +280,15 @@ func TestRefreshTokenEdgeCases(t *testing.T) { refreshResp, err := client.Do(refreshHTTP) require.NoError(t, err) - defer refreshResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp.Body) require.Equal(t, http.StatusOK, refreshResp.StatusCode) var refreshResult map[string]interface{} - json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + err = json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + require.NoError(t, err) // Verify response structure assert.Contains(t, refreshResult, "access_token") @@ -279,12 +311,15 @@ func TestRefreshTokenEdgeCases(t *testing.T) { loginResp, err := client.Do(loginHTTP) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) require.Equal(t, http.StatusOK, loginResp.StatusCode) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) refreshToken := loginResult["refresh_token"].(string) @@ -299,12 +334,15 @@ func TestRefreshTokenEdgeCases(t *testing.T) { refreshResp, err := client.Do(refreshHTTP) require.NoError(t, err) - defer refreshResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp.Body) require.Equal(t, http.StatusOK, refreshResp.StatusCode) var refreshResult map[string]interface{} - json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + err = json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + require.NoError(t, err) // Verify access token is a string accessToken, ok := refreshResult["access_token"].(string) diff --git a/cmd/server/tests/scan_settings_integration_test.go b/cmd/server/tests/scan_settings_integration_test.go index a149e9c..4f90c89 100644 --- a/cmd/server/tests/scan_settings_integration_test.go +++ b/cmd/server/tests/scan_settings_integration_test.go @@ -25,8 +25,9 @@ func TestScanSettings_GetSettings(t *testing.T) { assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) - resp.Body.Close() + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) + _ = resp.Body.Close() assert.Contains(t, response, "scan_poll_interval_seconds") assert.Contains(t, response, "auto_scan_enabled") @@ -63,8 +64,9 @@ func TestScanSettings_UpdateSettings(t *testing.T) { assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) - resp.Body.Close() + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) + _ = resp.Body.Close() assert.Equal(t, float64(45), response["scan_poll_interval_seconds"]) assert.Equal(t, true, response["auto_scan_enabled"]) @@ -74,8 +76,9 @@ func TestScanSettings_UpdateSettings(t *testing.T) { getResp, _ := client.Do(getReq) var getResponse map[string]interface{} - json.NewDecoder(getResp.Body).Decode(&getResponse) - getResp.Body.Close() + err = json.NewDecoder(getResp.Body).Decode(&getResponse) + require.NoError(t, err) + _ = getResp.Body.Close() assert.Equal(t, float64(45), getResponse["scan_poll_interval_seconds"]) }) @@ -99,8 +102,9 @@ func TestScanSettings_UpdateSettings(t *testing.T) { assert.Equal(t, http.StatusOK, resp.StatusCode) var response map[string]interface{} - json.NewDecoder(resp.Body).Decode(&response) - resp.Body.Close() + err = json.NewDecoder(resp.Body).Decode(&response) + require.NoError(t, err) + _ = resp.Body.Close() assert.Equal(t, false, response["auto_scan_enabled"]) }) diff --git a/cmd/server/tests/scanner_integration_test.go b/cmd/server/tests/scanner_integration_test.go index 710eff1..8824770 100644 --- a/cmd/server/tests/scanner_integration_test.go +++ b/cmd/server/tests/scanner_integration_test.go @@ -46,8 +46,9 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_TracksStatistics() { require.Equal(s.T(), http.StatusCreated, createLibResp.StatusCode) var createLibResponse map[string]interface{} - json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) - createLibResp.Body.Close() + err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) + require.NoError(s.T(), err) + _ = createLibResp.Body.Close() libraryID, ok := createLibResponse["id"].(string) require.True(s.T(), ok, "library_id should be string") @@ -64,7 +65,7 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_TracksStatistics() { resp, err := client.Do(req) require.NoError(s.T(), err) - resp.Body.Close() + _ = resp.Body.Close() require.Equal(s.T(), http.StatusCreated, resp.StatusCode, "Folder creation should succeed") scanURL := fmt.Sprintf("%s/api/libraries/%s/scan", s.setup.Server.URL, libraryID) @@ -78,7 +79,7 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_TracksStatistics() { var scanResponse map[string]interface{} err = json.NewDecoder(scanResp.Body).Decode(&scanResponse) require.NoError(s.T(), err) - scanResp.Body.Close() + _ = scanResp.Body.Close() jobID, ok := scanResponse["job_id"].(string) require.True(s.T(), ok, "job_id should be string") @@ -104,7 +105,7 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_TracksStatistics() { require.NoError(s.T(), err) if statusResp.StatusCode == http.StatusNotFound { - statusResp.Body.Close() + _ = statusResp.Body.Close() if gotProgressUpdate { break } @@ -113,7 +114,7 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_TracksStatistics() { var status map[string]interface{} err = json.NewDecoder(statusResp.Body).Decode(&status) - statusResp.Body.Close() + _ = statusResp.Body.Close() require.NoError(s.T(), err) if _, hasError := status["error"]; hasError { @@ -180,8 +181,9 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_BatchingWorks() { require.NoError(s.T(), err) var createLibResponse map[string]interface{} - json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) - createLibResp.Body.Close() + err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) + require.NoError(s.T(), err) + _ = createLibResp.Body.Close() libraryID, ok := createLibResponse["id"].(string) require.True(s.T(), ok, "library_id should be string") @@ -198,7 +200,7 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_BatchingWorks() { resp, err := client.Do(req) require.NoError(s.T(), err) - resp.Body.Close() + _ = resp.Body.Close() scanURL := fmt.Sprintf("%s/api/libraries/%s/scan", s.setup.Server.URL, libraryID) scanReq, _ := http.NewRequest("POST", scanURL, nil) @@ -208,8 +210,9 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_BatchingWorks() { require.NoError(s.T(), err) var scanResponse map[string]interface{} - json.NewDecoder(scanResp.Body).Decode(&scanResponse) - scanResp.Body.Close() + err = json.NewDecoder(scanResp.Body).Decode(&scanResponse) + require.NoError(s.T(), err) + _ = scanResp.Body.Close() jobID, ok := scanResponse["job_id"].(string) require.True(s.T(), ok, "job_id should be string") @@ -231,14 +234,14 @@ func (s *ScannerIntegrationTestSuite) TestScanProgress_BatchingWorks() { require.NoError(s.T(), err) if statusResp.StatusCode == http.StatusNotFound { - statusResp.Body.Close() + _ = statusResp.Body.Close() break } var status map[string]interface{} err = json.NewDecoder(statusResp.Body).Decode(&status) require.NoError(s.T(), err) - statusResp.Body.Close() + _ = statusResp.Body.Close() if _, hasError := status["error"]; hasError { continue diff --git a/cmd/server/tests/search_test.go b/cmd/server/tests/search_test.go index 2aa38e2..ae9a1f0 100644 --- a/cmd/server/tests/search_test.go +++ b/cmd/server/tests/search_test.go @@ -431,7 +431,9 @@ func TestCollectionSearchLibraryFilter(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Log response for debugging if resp.StatusCode != http.StatusOK { @@ -440,7 +442,8 @@ func TestCollectionSearchLibraryFilter(t *testing.T) { } var result []map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) if tt.expectedCount > 0 { require.Equal(t, http.StatusOK, resp.StatusCode) @@ -483,11 +486,14 @@ func createLibrary(t *testing.T, client *http.Client, setup *TestServerSetup, na resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) return result } @@ -509,10 +515,13 @@ func createTestMediaItemIDInLibrary(t *testing.T, client *http.Client, setup *Te resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) return result["id"].(string) } diff --git a/cmd/server/tests/search_unified_test.go b/cmd/server/tests/search_unified_test.go index f47849b..61593d5 100644 --- a/cmd/server/tests/search_unified_test.go +++ b/cmd/server/tests/search_unified_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "net/http/httptest" "testing" @@ -30,7 +31,7 @@ func TestUnifiedSearch(t *testing.T) { folderHTTP.Header.Set("Authorization", "Bearer "+setup.UserToken) folderResp, err := client.Do(folderHTTP) require.NoError(t, err) - folderResp.Body.Close() + _ = folderResp.Body.Close() require.Equal(t, http.StatusCreated, folderResp.StatusCode) // Helper to create book with fields @@ -54,7 +55,9 @@ func TestUnifiedSearch(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.UserToken) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) } diff --git a/cmd/server/tests/setup_integration_test.go b/cmd/server/tests/setup_integration_test.go index f575788..12c84dc 100644 --- a/cmd/server/tests/setup_integration_test.go +++ b/cmd/server/tests/setup_integration_test.go @@ -12,6 +12,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const baseTestURL = "http://localhost:8765/api" @@ -36,12 +37,15 @@ func TestFullApplicationSetup(t *testing.T) { t.Logf("Cleanup: No existing test user to delete (server not available)") return } - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // If login succeeds, try to delete the user if resp.StatusCode == http.StatusOK { var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) if token, ok := result["access_token"].(string); ok && token != "" { // Delete the user using the token @@ -52,7 +56,9 @@ func TestFullApplicationSetup(t *testing.T) { client := &http.Client{} delResp, err := client.Do(req) if err == nil { - defer delResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(delResp.Body) if delResp.StatusCode == http.StatusNoContent { t.Logf("Cleanup: Deleted existing test user") } else { @@ -66,10 +72,13 @@ func TestFullApplicationSetup(t *testing.T) { listResp, err := client.Do(req) if err == nil { - defer listResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(listResp.Body) if listResp.StatusCode == http.StatusOK { var libsResult map[string]interface{} - json.NewDecoder(listResp.Body).Decode(&libsResult) + err = json.NewDecoder(listResp.Body).Decode(&libsResult) + require.NoError(t, err) if data, ok := libsResult["data"].([]interface{}); ok { for _, lib := range data { @@ -80,7 +89,7 @@ func TestFullApplicationSetup(t *testing.T) { req.Header.Set("Authorization", "Bearer "+token) delLibResp, _ := client.Do(req) if delLibResp != nil { - delLibResp.Body.Close() + _ = delLibResp.Body.Close() } } } @@ -108,7 +117,9 @@ func TestFullApplicationSetup(t *testing.T) { body, _ := json.Marshal(userReq) resp, err := http.Post(baseTestURL+"/auth/register", "application/json", bytes.NewBuffer(body)) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Accept 201 (Created) or 409 (Conflict if already exists from previous incomplete test run) if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusConflict { @@ -116,7 +127,8 @@ func TestFullApplicationSetup(t *testing.T) { } var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) // If we got 409, the user already exists, so we need to login to get the token if resp.StatusCode == http.StatusConflict { @@ -128,10 +140,13 @@ func TestFullApplicationSetup(t *testing.T) { body, _ := json.Marshal(loginReq) resp2, err := http.Post(baseTestURL+"/auth/login", "application/json", bytes.NewBuffer(body)) assert.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) assert.Equal(t, http.StatusOK, resp2.StatusCode) - json.NewDecoder(resp2.Body).Decode(&result) + err = json.NewDecoder(resp2.Body).Decode(&result) + require.NoError(t, err) } if result["user"] != nil { @@ -155,12 +170,15 @@ func TestFullApplicationSetup(t *testing.T) { body, _ := json.Marshal(loginReq) resp, err := http.Post(baseTestURL+"/auth/login", "application/json", bytes.NewBuffer(body)) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) token, ok := result["access_token"].(string) assert.True(t, ok, "Should have access_token") @@ -185,7 +203,9 @@ func TestFullApplicationSetup(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusCreated, resp.StatusCode) @@ -225,12 +245,15 @@ func TestFullApplicationSetup(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusCreated, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, getUploadPath(), result["folder_path"]) @@ -251,13 +274,16 @@ func TestFullApplicationSetup(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) // Accept 200 or 202 assert.Contains(t, []int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) assert.Equal(t, "success", result["status"]) @@ -276,12 +302,15 @@ func TestFullApplicationSetup(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) assert.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) data, ok := result["data"].([]interface{}) assert.True(t, ok, "Data field should exist") diff --git a/cmd/server/tests/seven_day_session_test.go b/cmd/server/tests/seven_day_session_test.go index 071cf0c..4663ecd 100644 --- a/cmd/server/tests/seven_day_session_test.go +++ b/cmd/server/tests/seven_day_session_test.go @@ -36,7 +36,9 @@ func TestSevenDaySession(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -81,12 +83,15 @@ func TestSevenDaySession(t *testing.T) { loginResp, err := http.DefaultClient.Do(loginHTTP) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) require.Equal(t, http.StatusOK, loginResp.StatusCode) var loginResult map[string]interface{} - json.NewDecoder(loginResp.Body).Decode(&loginResult) + err = json.NewDecoder(loginResp.Body).Decode(&loginResult) + require.NoError(t, err) refreshToken, ok := loginResult["refresh_token"].(string) require.True(t, ok, "Should have refresh_token") @@ -103,12 +108,15 @@ func TestSevenDaySession(t *testing.T) { refreshResp, err := http.DefaultClient.Do(refreshHTTP) require.NoError(t, err) - defer refreshResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(refreshResp.Body) assert.Equal(t, http.StatusOK, refreshResp.StatusCode) var refreshResult map[string]interface{} - json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + err = json.NewDecoder(refreshResp.Body).Decode(&refreshResult) + require.NoError(t, err) // Verify ExpiresIn is 7 days expiresIn, ok := refreshResult["expires_in"].(float64) @@ -134,7 +142,9 @@ func TestSevenDaySession(t *testing.T) { resp, err := http.DefaultClient.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) var authResponse struct { Token string `json:"access_token"` @@ -230,7 +240,7 @@ func TestNoClientSideCookies(t *testing.T) { resp, err := http.DefaultClient.Do(req) require.NoError(t, err) - resp.Body.Close() + _ = resp.Body.Close() // Accept both 201 (new user) and 409 (already exists from previous run) require.True(t, resp.StatusCode == http.StatusCreated || resp.StatusCode == http.StatusConflict, @@ -253,7 +263,9 @@ func TestNoClientSideCookies(t *testing.T) { resp2, err := http.DefaultClient.Do(req2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) body, err := io.ReadAll(resp2.Body) require.NoError(t, err) @@ -277,7 +289,9 @@ func TestNoClientSideCookies(t *testing.T) { loginResp, err := http.DefaultClient.Do(loginReq) require.NoError(t, err) - defer loginResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(loginResp.Body) assert.Equal(t, http.StatusOK, loginResp.StatusCode) diff --git a/cmd/server/tests/tags_filter_test.go b/cmd/server/tests/tags_filter_test.go index 784d5f1..e647303 100644 --- a/cmd/server/tests/tags_filter_test.go +++ b/cmd/server/tests/tags_filter_test.go @@ -3,6 +3,7 @@ package main import ( "bytes" "encoding/json" + "io" "net/http" "net/http/httptest" "testing" @@ -30,7 +31,7 @@ func TestTagsFilter(t *testing.T) { folderHTTP.Header.Set("Authorization", "Bearer "+setup.UserToken) folderResp, err := client.Do(folderHTTP) require.NoError(t, err) - folderResp.Body.Close() + _ = folderResp.Body.Close() require.Equal(t, http.StatusCreated, folderResp.StatusCode, "Should add folder to library") // Helper to create book with tags @@ -50,7 +51,9 @@ func TestTagsFilter(t *testing.T) { req.Header.Set("Authorization", "Bearer "+setup.UserToken) resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode, "Should create book") } diff --git a/cmd/server/tests/test_helpers_db_test.go b/cmd/server/tests/test_helpers_db_test.go index e5be512..584695d 100644 --- a/cmd/server/tests/test_helpers_db_test.go +++ b/cmd/server/tests/test_helpers_db_test.go @@ -6,6 +6,7 @@ import ( "context" "encoding/json" "fmt" + "io" "net/http" "net/http/httptest" "sync" @@ -98,11 +99,14 @@ func createTestLibraryWithFolder(t *testing.T, ts *httptest.Server, token, name client := &http.Client{} resp, err := client.Do(libHTTP) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode, "Library creation should succeed") var libResponse map[string]interface{} - json.NewDecoder(resp.Body).Decode(&libResponse) + err = json.NewDecoder(resp.Body).Decode(&libResponse) + require.NoError(t, err) libraryID := libResponse["id"].(string) if withFolder { @@ -117,7 +121,9 @@ func createTestLibraryWithFolder(t *testing.T, ts *httptest.Server, token, name folderResp, err := client.Do(folderHTTP) require.NoError(t, err) - defer folderResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(folderResp.Body) require.Equal(t, http.StatusCreated, folderResp.StatusCode, "Folder creation should succeed") } diff --git a/cmd/server/tests/test_helpers_test.go b/cmd/server/tests/test_helpers_test.go index a73621d..2f93ae7 100644 --- a/cmd/server/tests/test_helpers_test.go +++ b/cmd/server/tests/test_helpers_test.go @@ -13,6 +13,7 @@ import ( "context" "encoding/json" "fmt" + "io" "net" "net/http" "net/http/httptest" @@ -315,12 +316,15 @@ func loginUserWithCredentials(t *testing.T, ts *httptest.Server, email, password client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err, "Failed to login") - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusOK, resp.StatusCode, "Login should succeed") var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) token, ok := result["access_token"].(string) require.True(t, ok, "Should have access_token") @@ -648,12 +652,15 @@ func loginWithCredentials(t *testing.T, ts *httptest.Server, email, password str client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err, "Failed to login") - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusOK, resp.StatusCode, "Login should succeed") var result map[string]interface{} - json.NewDecoder(resp.Body).Decode(&result) + err = json.NewDecoder(resp.Body).Decode(&result) + require.NoError(t, err) token, ok := result["access_token"].(string) require.True(t, ok, "Should have access_token") @@ -698,12 +705,15 @@ func createTestMediaItemID(t *testing.T, setup *TestServerSetup) string { resp, err := httpClient.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) var libResult map[string]interface{} - json.NewDecoder(resp.Body).Decode(&libResult) + err = json.NewDecoder(resp.Body).Decode(&libResult) + require.NoError(t, err) libData := libResult["id"].(string) @@ -718,7 +728,9 @@ func createTestMediaItemID(t *testing.T, setup *TestServerSetup) string { folderResp, err := httpClient.Do(folderReqHTTP) require.NoError(t, err) - defer folderResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(folderResp.Body) require.Equal(t, http.StatusCreated, folderResp.StatusCode, "Library folder creation is required before adding media items") mediaItemReq := map[string]interface{}{ @@ -737,12 +749,15 @@ func createTestMediaItemID(t *testing.T, setup *TestServerSetup) string { resp2, err := httpClient.Do(req2) require.NoError(t, err) - defer resp2.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp2.Body) require.Equal(t, http.StatusCreated, resp2.StatusCode) var mediaItemResult map[string]interface{} - json.NewDecoder(resp2.Body).Decode(&mediaItemResult) + err = json.NewDecoder(resp2.Body).Decode(&mediaItemResult) + require.NoError(t, err) mediaItemID := mediaItemResult["id"].(string) @@ -771,6 +786,8 @@ func addFolderToLibrary(t *testing.T, setup *TestServerSetup, libraryID string, client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusCreated, resp.StatusCode) } diff --git a/cmd/server/tests/websocket_test.go b/cmd/server/tests/websocket_test.go index 6038725..1281e03 100644 --- a/cmd/server/tests/websocket_test.go +++ b/cmd/server/tests/websocket_test.go @@ -6,6 +6,7 @@ import ( "context" "encoding/json" "fmt" + "io" "net/http" "strings" "testing" @@ -83,7 +84,9 @@ func TestWebSocketDeviceAuth(t *testing.T) { require.NoError(t, err, "WebSocket connection with device token should succeed") defer ws.Close() if resp != nil { - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode, "Should upgrade to WebSocket") } // Read initial state message @@ -135,7 +138,9 @@ func TestWebSocketProgressBroadcast(t *testing.T) { client := &http.Client{} resp, err := client.Do(req) require.NoError(t, err) - defer resp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(resp.Body) assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -253,11 +258,14 @@ func TestWebSocketUserScopedBroadcast(t *testing.T) { collectionResp, err := client.Do(collectionHTTP) require.NoError(t, err) - defer collectionResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(collectionResp.Body) require.Equal(t, http.StatusCreated, collectionResp.StatusCode) var collectionResult map[string]interface{} - json.NewDecoder(collectionResp.Body).Decode(&collectionResult) + err = json.NewDecoder(collectionResp.Body).Decode(&collectionResult) + require.NoError(t, err) collectionID := collectionResult["id"].(string) // Create a test book via API @@ -289,7 +297,9 @@ func TestWebSocketUserScopedBroadcast(t *testing.T) { addResp, err := client.Do(addHTTP) require.NoError(t, err) - defer addResp.Body.Close() + defer func(Body io.ReadCloser) { + _ = Body.Close() + }(addResp.Body) require.Equal(t, http.StatusNoContent, addResp.StatusCode) // Admin should receive collection_updated message @@ -313,7 +323,7 @@ func connectWebSocketToServer(t *testing.T, serverURL string, token string) *web ws, resp, err := websocket.DefaultDialer.Dial(wsURL, nil) require.NoError(t, err, "WebSocket connection should succeed") if resp != nil { - resp.Body.Close() + _ = resp.Body.Close() } require.NotNil(t, ws, "WebSocket connection should be established") diff --git a/cmd/server/tests/worker_test.go b/cmd/server/tests/worker_test.go index b13da65..a955139 100644 --- a/cmd/server/tests/worker_test.go +++ b/cmd/server/tests/worker_test.go @@ -41,8 +41,9 @@ func TestWorker_DirectoryScanJob(t *testing.T) { require.Equal(t, http.StatusCreated, createLibResp.StatusCode) var createLibResponse map[string]interface{} - json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) - createLibResp.Body.Close() + err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) + require.NoError(t, err) + _ = createLibResp.Body.Close() libraryID, ok := createLibResponse["id"].(string) require.True(t, ok) @@ -62,7 +63,7 @@ func TestWorker_DirectoryScanJob(t *testing.T) { resp, err := client.Do(req) require.NoError(t, err) - resp.Body.Close() + _ = resp.Body.Close() require.Equal(t, http.StatusCreated, resp.StatusCode) // Create test files in the directory @@ -141,8 +142,9 @@ func TestWorker_SetFoldersJob(t *testing.T) { require.Equal(t, http.StatusCreated, createLibResp.StatusCode) var createLibResponse map[string]interface{} - json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) - createLibResp.Body.Close() + err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse) + require.NoError(t, err) + _ = createLibResp.Body.Close() libraryID, ok := createLibResponse["id"].(string) require.True(t, ok)