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

@@ -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")
 	})

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)
 	})

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")

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)

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)
 }
@@ -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)
 	})
 }

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)

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)
+			require.NoError(s.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{}
 			err = json.NewDecoder(resp.Body).Decode(&response)
-			require.NoError(t, err)
+			require.NoError(s.T(), err)
 
 			assert.Contains(t, response, "message")
 		})

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 {

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)
 	})

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)
+			err = json.NewDecoder(statusResp.Body).Decode(&status)
-			statusResp.Body.Close()
+			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

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)
 }

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")
 	})
 }

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)
 	})

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)
+	err = json.NewDecoder(resp.Body).Decode(&createResponse)
-	resp.Body.Close()
+	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)
 	})

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)
 

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"])

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)

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)
+		err = json.NewDecoder(resp.Body).Decode(&response)
-		resp.Body.Close()
+		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)
+		err = json.NewDecoder(resp.Body).Decode(&response)
-		resp.Body.Close()
+		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)
+		err = json.NewDecoder(getResp.Body).Decode(&getResponse)
-		getResp.Body.Close()
+		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)
+		err = json.NewDecoder(resp.Body).Decode(&response)
-		resp.Body.Close()
+		require.NoError(t, err)
+		_ = resp.Body.Close()
 
 		assert.Equal(t, false, response["auto_scan_enabled"])
 	})

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)
+	err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse)
-	createLibResp.Body.Close()
+	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)
+	err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse)
-	createLibResp.Body.Close()
+	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)
+	err = json.NewDecoder(scanResp.Body).Decode(&scanResponse)
-	scanResp.Body.Close()
+	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

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)
 }

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)
 	}
 

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")

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)
 

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")
 	}
 

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")
 	}
 

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)
 }

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")
 

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)
+	err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse)
-	createLibResp.Body.Close()
+	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)
+	err = json.NewDecoder(createLibResp.Body).Decode(&createLibResponse)
-	createLibResp.Body.Close()
+	require.NoError(t, err)
+	_ = createLibResp.Body.Close()
 
 	libraryID, ok := createLibResponse["id"].(string)
 	require.True(t, ok)