Bookhoard/bookhoard
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 12 Wiki Activity
Files
891209b4bdf1307eac8035f0613f6dbd02ec7073
bookhoard/cmd/server/tests/media_bulk_test.go
T
john-okeefe 891209b4bd test(infrastructure): Configure pgxpool with max_conns=1 
Fix database connection exhaustion in tests by setting max_conns=1
when creating pgxpool via pgxpool.ParseConfig().

- Update setupTestServer() in test_helpers.go
- Update setupSyncTestDB() in sync_integration_test.go

This reduces per-test connection usage from 4 to 1, keeping total
connections well under PostgreSQL's default max_connections=100.

78 tests × 1 connection = 78 connections (down from 312 potential)

Fixes test failures: "FATAL: sorry, too many clients already"

See PROJECT_GUIDELINES.md Testing section for details.
2026-02-11 10:37:38 -05:00

332 lines
9.8 KiB
Go
Raw Blame History

package main
import (
"bytes"
"encoding/json"
"net/http"
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestMediaBulkOperations tests bulk media operations
func TestMediaBulkOperations(t *testing.T) {
setup := setupTestServer(t)
token := loginTestUser(t, setup.Server, setup.DB)
t.Run("BulkDeleteBooks_WithoutAuth", func(t *testing.T) {
req := map[string]interface{}{
"media_item_ids": []string{uuid.New().String()},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-delete", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
})
t.Run("BulkDeleteBooks_EmptyBookIDs", func(t *testing.T) {
req := map[string]interface{}{
"media_item_ids": []string{},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-delete", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
})
t.Run("BulkDeleteBooks_InvalidBookIDs", func(t *testing.T) {
req := map[string]interface{}{
"media_item_ids": []string{"invalid-uuid", "another-invalid"},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-delete", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
assert.Contains(t, result, "total")
assert.Contains(t, result, "deleted")
assert.Contains(t, result, "failed")
})
t.Run("BulkDeleteBooks_WithValidBooks", func(t *testing.T) {
mediaID1 := createTestMediaItemID(t, setup.Server, token)
mediaID2 := createTestMediaItemID(t, setup.Server, token)
mediaID3 := uuid.New().String()
req := map[string]interface{}{
"media_item_ids": []string{mediaID1, mediaID2, mediaID3},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-delete", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
assert.Equal(t, 3.0, result["total"])
// Check that deleted field exists and has at least 2 (the valid books)
if deleted, ok := result["deleted"].(float64); ok {
assert.True(t, deleted >= 2, "Should delete at least valid books")
}
})
t.Run("BulkDeleteBooks_InvalidRequestBody", func(t *testing.T) {
// Send invalid JSON
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-delete", bytes.NewBuffer([]byte("invalid json")))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
})
t.Run("BulkUpdateBooks_WithoutAuth", func(t *testing.T) {
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": uuid.New().String(),
"updates": map[string]interface{}{
"tags": []string{"test"},
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
})
t.Run("BulkUpdateBooks_EmptyBookIDs", func(t *testing.T) {
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": "",
"updates": map[string]interface{}{
"tags": []string{"test"},
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
})
t.Run("BulkUpdateBooks_InvalidBookIDs", func(t *testing.T) {
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": "invalid-uuid",
"updates": map[string]interface{}{
"tags": []string{"fiction", "test"},
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
assert.Contains(t, result, "total")
assert.Contains(t, result, "updated")
assert.Contains(t, result, "failed")
})
t.Run("BulkUpdateBooks_UpdateTags", func(t *testing.T) {
mediaID1 := createTestMediaItemID(t, setup.Server, token)
mediaID2 := createTestMediaItemID(t, setup.Server, token)
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": mediaID1,
"updates": map[string]interface{}{
"tags": []string{"fiction", "science-fiction", "test"},
},
},
{
"media_item_id": mediaID2,
"updates": map[string]interface{}{
"tags": []string{"fiction", "science-fiction", "test"},
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
assert.Equal(t, 2.0, result["total"])
// Check that updated field exists and has at least 1
if updated, ok := result["updated"].(float64); ok {
assert.True(t, updated > 0, "Should update at least one book")
}
})
t.Run("BulkUpdateBooks_UpdateReadingStatus", func(t *testing.T) {
mediaID1 := createTestMediaItemID(t, setup.Server, token)
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": mediaID1,
"updates": map[string]interface{}{
"reading_status": "reading",
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
})
t.Run("BulkUpdateBooks_UpdateMultipleFields", func(t *testing.T) {
mediaID1 := createTestMediaItemID(t, setup.Server, token)
req := map[string]interface{}{
"media_item_updates": []map[string]interface{}{
{
"media_item_id": mediaID1,
"updates": map[string]interface{}{
"tags": []string{"test", "bulk-update"},
"reading_status": "to-read",
"rating": 4,
},
},
},
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
assert.Contains(t, result, "results")
})
t.Run("BulkUpdateBooks_InvalidRequestBody", func(t *testing.T) {
// Send invalid JSON
httpReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/bulk-update", bytes.NewBuffer([]byte("invalid json")))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(httpReq)
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
})
}
Reference in New Issue View Git Blame Copy Permalink