182 lines
6.1 KiB
Go
182 lines
6.1 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
|
|
)
|
|
|
|
// newHistoryRouter mounts ONLY /api/me/history, injecting the user directly
|
|
// into context (bypassing RequireUser), mirroring the pattern used by peer
|
|
// tests such as library_albums_test.go and quarantine_test.go.
|
|
func newHistoryRouter(h *handlers) chi.Router {
|
|
r := chi.NewRouter()
|
|
r.Get("/api/me/history", h.handleGetMyHistory)
|
|
return r
|
|
}
|
|
|
|
func doGetHistory(h *handlers, _ *pgxpool.Pool, user dbq.User, query string) *httptest.ResponseRecorder {
|
|
url := "/api/me/history"
|
|
if query != "" {
|
|
url += "?" + query
|
|
}
|
|
req := httptest.NewRequest(http.MethodGet, url, nil)
|
|
req = withUser(req, user)
|
|
w := httptest.NewRecorder()
|
|
newHistoryRouter(h).ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
func seedPlayEvent(t *testing.T, pool *pgxpool.Pool, userID, trackID, sessionID pgtype.UUID, startedAt time.Time, skipped bool) {
|
|
t.Helper()
|
|
_, err := pool.Exec(context.Background(),
|
|
`INSERT INTO play_events (user_id, track_id, session_id, started_at, was_skipped)
|
|
VALUES ($1, $2, $3, $4, $5)`,
|
|
userID, trackID, sessionID, startedAt, skipped,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("seedPlayEvent: %v", err)
|
|
}
|
|
}
|
|
|
|
func seedPlaySession(t *testing.T, pool *pgxpool.Pool, userID pgtype.UUID, startedAt time.Time) pgtype.UUID {
|
|
t.Helper()
|
|
var id pgtype.UUID
|
|
err := pool.QueryRow(context.Background(),
|
|
`INSERT INTO play_sessions (user_id, started_at, last_event_at)
|
|
VALUES ($1, $2, $2) RETURNING id`,
|
|
userID, startedAt,
|
|
).Scan(&id)
|
|
if err != nil {
|
|
t.Fatalf("seedPlaySession: %v", err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func quarantineTrack(t *testing.T, pool *pgxpool.Pool, userID, trackID pgtype.UUID) {
|
|
t.Helper()
|
|
_, err := pool.Exec(context.Background(),
|
|
`INSERT INTO lidarr_quarantine (user_id, track_id, reason) VALUES ($1, $2, 'bad_rip')`,
|
|
userID, trackID,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("quarantineTrack: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHistory_FilteringAndPagination(t *testing.T) {
|
|
h, pool := testHandlers(t)
|
|
truncateLibrary(t, pool)
|
|
|
|
userA := seedUser(t, pool, "alice", "pw", false)
|
|
userB := seedUser(t, pool, "bob", "pw", false)
|
|
|
|
artist := seedArtist(t, pool, "Artist 1")
|
|
album := seedAlbum(t, pool, artist.ID, "Album 1", 2024)
|
|
t1 := seedTrack(t, pool, album.ID, artist.ID, "Track 1", 1, 180000)
|
|
t2 := seedTrack(t, pool, album.ID, artist.ID, "Track 2", 2, 180000)
|
|
t3 := seedTrack(t, pool, album.ID, artist.ID, "Track 3", 3, 180000)
|
|
t4 := seedTrack(t, pool, album.ID, artist.ID, "Track 4", 4, 180000)
|
|
tSkipped := seedTrack(t, pool, album.ID, artist.ID, "Skipped Track", 5, 60000)
|
|
tQuar := seedTrack(t, pool, album.ID, artist.ID, "Quarantined Track", 6, 120000)
|
|
tB := seedTrack(t, pool, album.ID, artist.ID, "Bob Only Track", 7, 200000)
|
|
|
|
quarantineTrack(t, pool, userA.ID, tQuar.ID)
|
|
|
|
now := time.Now().UTC()
|
|
sessA := seedPlaySession(t, pool, userA.ID, now.Add(-5*time.Hour))
|
|
sessB := seedPlaySession(t, pool, userB.ID, now.Add(-1*time.Hour))
|
|
|
|
seedPlayEvent(t, pool, userA.ID, t1.ID, sessA, now.Add(-4*time.Hour), false)
|
|
seedPlayEvent(t, pool, userA.ID, t2.ID, sessA, now.Add(-3*time.Hour), false)
|
|
seedPlayEvent(t, pool, userA.ID, t3.ID, sessA, now.Add(-2*time.Hour), false)
|
|
seedPlayEvent(t, pool, userA.ID, t4.ID, sessA, now.Add(-1*time.Hour), false)
|
|
seedPlayEvent(t, pool, userA.ID, tSkipped.ID, sessA, now.Add(-30*time.Minute), true)
|
|
seedPlayEvent(t, pool, userA.ID, tQuar.ID, sessA, now.Add(-15*time.Minute), false)
|
|
seedPlayEvent(t, pool, userB.ID, tB.ID, sessB, now.Add(-10*time.Minute), false)
|
|
|
|
t.Run("filters skipped + quarantined, returns DESC", func(t *testing.T) {
|
|
w := doGetHistory(h, pool, userA, "")
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status: got %d, want 200; body=%s", w.Code, w.Body.String())
|
|
}
|
|
var resp HistoryResponse
|
|
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
if len(resp.Events) != 4 {
|
|
t.Fatalf("len: got %d, want 4 (skipped + quarantined excluded); body=%s",
|
|
len(resp.Events), w.Body.String())
|
|
}
|
|
// Newest first: t4, t3, t2, t1.
|
|
want := []pgtype.UUID{t4.ID, t3.ID, t2.ID, t1.ID}
|
|
for i, e := range resp.Events {
|
|
if e.Track.ID != uuidToString(want[i]) {
|
|
t.Errorf("event[%d].track.id: got %s, want %s",
|
|
i, e.Track.ID, uuidToString(want[i]))
|
|
}
|
|
}
|
|
if resp.HasMore {
|
|
t.Errorf("has_more: got true, want false (4 events < limit 50)")
|
|
}
|
|
})
|
|
|
|
t.Run("pagination via offset/limit", func(t *testing.T) {
|
|
w := doGetHistory(h, pool, userA, "offset=2&limit=2")
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status: got %d", w.Code)
|
|
}
|
|
var resp HistoryResponse
|
|
_ = json.NewDecoder(w.Body).Decode(&resp)
|
|
if len(resp.Events) != 2 {
|
|
t.Fatalf("len: got %d, want 2", len(resp.Events))
|
|
}
|
|
if resp.Events[0].Track.ID != uuidToString(t2.ID) || resp.Events[1].Track.ID != uuidToString(t1.ID) {
|
|
t.Errorf("page-2 ids: got %s,%s; want %s,%s",
|
|
resp.Events[0].Track.ID, resp.Events[1].Track.ID,
|
|
uuidToString(t2.ID), uuidToString(t1.ID))
|
|
}
|
|
})
|
|
|
|
t.Run("has_more=true when len(rows) == limit", func(t *testing.T) {
|
|
w := doGetHistory(h, pool, userA, "limit=1")
|
|
var resp HistoryResponse
|
|
_ = json.NewDecoder(w.Body).Decode(&resp)
|
|
if !resp.HasMore {
|
|
t.Errorf("has_more: got false, want true (4 events, limit 1)")
|
|
}
|
|
})
|
|
|
|
t.Run("user B sees only their own play", func(t *testing.T) {
|
|
w := doGetHistory(h, pool, userB, "")
|
|
var resp HistoryResponse
|
|
_ = json.NewDecoder(w.Body).Decode(&resp)
|
|
if len(resp.Events) != 1 {
|
|
t.Fatalf("len: got %d, want 1", len(resp.Events))
|
|
}
|
|
if resp.Events[0].Track.ID != uuidToString(tB.ID) {
|
|
t.Errorf("user B's event: got track %s, want %s",
|
|
resp.Events[0].Track.ID, uuidToString(tB.ID))
|
|
}
|
|
})
|
|
|
|
t.Run("unauthenticated returns 401", func(t *testing.T) {
|
|
// No withUser wrapper — exercises the handler's own auth guard.
|
|
req := httptest.NewRequest(http.MethodGet, "/api/me/history", nil)
|
|
w := httptest.NewRecorder()
|
|
newHistoryRouter(h).ServeHTTP(w, req)
|
|
if w.Code != http.StatusUnauthorized {
|
|
t.Errorf("unauth: got %d, want 401", w.Code)
|
|
}
|
|
})
|
|
}
|