bvandeusen
79bab14b30
AppendTracks / RemoveTrack / Reorder run in single transactions and update the denormalized rollups (track_count, duration_sec). Reorder uses a +10000 offset to bump every row out of the position range before writing the new positions, sidestepping PK conflicts during rewrite. GenerateCollage composes a 600x600 JPEG from the first 4 album covers, with a slate-tinted fallback for missing cells. Synchronous, called inline after every mutating operation. SVG-rasterized fallback is a follow-up — slice 1 ships with a solid placeholder.
479 lines
15 KiB
Go
479 lines
15 KiB
Go
package playlists_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
|
|
"git.fabledsword.com/bvandeusen/minstrel/internal/playlists"
|
|
)
|
|
|
|
func TestCreate_HappyPath(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
dir := t.TempDir()
|
|
|
|
svc := playlists.NewService(pool, nil, dir)
|
|
row, err := svc.Create(context.Background(), user.ID, "Saturday morning", "Mellow", false)
|
|
if err != nil {
|
|
t.Fatalf("Create: %v", err)
|
|
}
|
|
if row.Name != "Saturday morning" {
|
|
t.Errorf("name = %q, want Saturday morning", row.Name)
|
|
}
|
|
if row.IsPublic {
|
|
t.Error("IsPublic = true, want false (default)")
|
|
}
|
|
if row.OwnerUsername != "test-alice" {
|
|
t.Errorf("OwnerUsername = %q, want test-alice", row.OwnerUsername)
|
|
}
|
|
if row.TrackCount != 0 || row.DurationSec != 0 {
|
|
t.Errorf("rollups should start at 0; got count=%d duration=%d", row.TrackCount, row.DurationSec)
|
|
}
|
|
}
|
|
|
|
func TestCreate_EmptyNameRejected(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
_, err := svc.Create(context.Background(), user.ID, "", "", false)
|
|
if !errors.Is(err, playlists.ErrInvalidInput) {
|
|
t.Errorf("err = %v, want ErrInvalidInput", err)
|
|
}
|
|
}
|
|
|
|
func TestGet_NotFound(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
_, err := svc.Get(context.Background(), user.ID, randomUUID())
|
|
if !errors.Is(err, playlists.ErrNotFound) {
|
|
t.Errorf("err = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestGet_Forbidden_PrivatePlaylistFromOtherUser(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Private", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
if _, err := svc.Get(context.Background(), bob.ID, pl.ID); !errors.Is(err, playlists.ErrForbidden) {
|
|
t.Errorf("err = %v, want ErrForbidden", err)
|
|
}
|
|
}
|
|
|
|
func TestGet_Public_VisibleToOtherUser(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Public mix", "", true)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
got, err := svc.Get(context.Background(), bob.ID, pl.ID)
|
|
if err != nil {
|
|
t.Fatalf("Get: %v", err)
|
|
}
|
|
if got.Name != "Public mix" {
|
|
t.Errorf("name = %q", got.Name)
|
|
}
|
|
if !got.IsPublic {
|
|
t.Error("IsPublic = false, want true")
|
|
}
|
|
if len(got.Tracks) != 0 {
|
|
t.Errorf("Tracks len = %d, want 0 for an empty playlist", len(got.Tracks))
|
|
}
|
|
}
|
|
|
|
func TestGet_Owner_SeesOwnPrivate(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Mine", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
got, err := svc.Get(context.Background(), alice.ID, pl.ID)
|
|
if err != nil {
|
|
t.Fatalf("Get: %v", err)
|
|
}
|
|
if got.Name != "Mine" {
|
|
t.Errorf("name = %q", got.Name)
|
|
}
|
|
}
|
|
|
|
func TestList_OwnAndPublic(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
if _, err := svc.Create(context.Background(), alice.ID, "Alice private", "", false); err != nil {
|
|
t.Fatalf("seed: %v", err)
|
|
}
|
|
if _, err := svc.Create(context.Background(), alice.ID, "Alice public", "", true); err != nil {
|
|
t.Fatalf("seed: %v", err)
|
|
}
|
|
if _, err := svc.Create(context.Background(), bob.ID, "Bob private", "", false); err != nil {
|
|
t.Fatalf("seed: %v", err)
|
|
}
|
|
if _, err := svc.Create(context.Background(), bob.ID, "Bob public", "", true); err != nil {
|
|
t.Fatalf("seed: %v", err)
|
|
}
|
|
|
|
rows, err := svc.List(context.Background(), alice.ID)
|
|
if err != nil {
|
|
t.Fatalf("List: %v", err)
|
|
}
|
|
if len(rows) != 3 {
|
|
t.Errorf("alice's list = %d rows, want 3 (her 2 + bob's public)", len(rows))
|
|
}
|
|
for _, r := range rows {
|
|
if r.Name == "Bob private" {
|
|
t.Errorf("alice's list leaked bob's private playlist")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUpdate_OwnerOnly(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Mine", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
rename := "Renamed"
|
|
if _, err := svc.Update(context.Background(), bob.ID, pl.ID, playlists.UpdateInput{Name: &rename}); !errors.Is(err, playlists.ErrForbidden) {
|
|
t.Errorf("err = %v, want ErrForbidden", err)
|
|
}
|
|
|
|
updated, err := svc.Update(context.Background(), alice.ID, pl.ID, playlists.UpdateInput{Name: &rename})
|
|
if err != nil {
|
|
t.Fatalf("owner Update: %v", err)
|
|
}
|
|
if updated.Name != "Renamed" {
|
|
t.Errorf("name = %q, want Renamed", updated.Name)
|
|
}
|
|
}
|
|
|
|
func TestUpdate_PartialFieldsLeaveOthersAlone(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Original", "Long description", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
// Touch only IsPublic — name and description must survive.
|
|
pub := true
|
|
updated, err := svc.Update(context.Background(), alice.ID, pl.ID, playlists.UpdateInput{IsPublic: &pub})
|
|
if err != nil {
|
|
t.Fatalf("Update: %v", err)
|
|
}
|
|
if updated.Name != "Original" {
|
|
t.Errorf("name = %q, want unchanged Original", updated.Name)
|
|
}
|
|
if updated.Description != "Long description" {
|
|
t.Errorf("description = %q, want unchanged", updated.Description)
|
|
}
|
|
if !updated.IsPublic {
|
|
t.Error("IsPublic = false, want true after toggle")
|
|
}
|
|
}
|
|
|
|
func TestUpdate_EmptyNameRejected(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Original", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
empty := ""
|
|
if _, err := svc.Update(context.Background(), alice.ID, pl.ID, playlists.UpdateInput{Name: &empty}); !errors.Is(err, playlists.ErrInvalidInput) {
|
|
t.Errorf("err = %v, want ErrInvalidInput", err)
|
|
}
|
|
}
|
|
|
|
func TestUpdate_NotFound(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
rename := "Renamed"
|
|
if _, err := svc.Update(context.Background(), alice.ID, randomUUID(), playlists.UpdateInput{Name: &rename}); !errors.Is(err, playlists.ErrNotFound) {
|
|
t.Errorf("err = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestDelete_OwnerOnly(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, err := svc.Create(context.Background(), alice.ID, "Mine", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
if err := svc.Delete(context.Background(), bob.ID, pl.ID); !errors.Is(err, playlists.ErrForbidden) {
|
|
t.Errorf("non-owner err = %v, want ErrForbidden", err)
|
|
}
|
|
if err := svc.Delete(context.Background(), alice.ID, pl.ID); err != nil {
|
|
t.Fatalf("owner Delete: %v", err)
|
|
}
|
|
// Idempotency: a second delete reports NotFound rather than silently succeeding.
|
|
if err := svc.Delete(context.Background(), alice.ID, pl.ID); !errors.Is(err, playlists.ErrNotFound) {
|
|
t.Errorf("repeat Delete err = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestDelete_NotFound(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
if err := svc.Delete(context.Background(), alice.ID, randomUUID()); !errors.Is(err, playlists.ErrNotFound) {
|
|
t.Errorf("err = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestDelete_RemovesCoverFile(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
dir := t.TempDir()
|
|
svc := playlists.NewService(pool, nil, dir)
|
|
|
|
pl, err := svc.Create(context.Background(), user.ID, "Will be deleted", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
|
|
// Simulate the collage generator having stashed a file at the
|
|
// path stored on the row. The Delete path should clean it up.
|
|
coverDir := filepath.Join(dir, "playlist_covers")
|
|
if err := os.MkdirAll(coverDir, 0o755); err != nil {
|
|
t.Fatalf("mkdir cover dir: %v", err)
|
|
}
|
|
relPath := filepath.Join("playlist_covers", uuidString(pl.ID)+".jpg")
|
|
full := filepath.Join(dir, relPath)
|
|
if err := os.WriteFile(full, []byte("jpeg-bytes"), 0o644); err != nil {
|
|
t.Fatalf("seed cover file: %v", err)
|
|
}
|
|
if _, err := pool.Exec(context.Background(),
|
|
`UPDATE playlists SET cover_path = $1 WHERE id = $2`, relPath, pl.ID); err != nil {
|
|
t.Fatalf("set cover_path: %v", err)
|
|
}
|
|
|
|
if err := svc.Delete(context.Background(), user.ID, pl.ID); err != nil {
|
|
t.Fatalf("Delete: %v", err)
|
|
}
|
|
if _, statErr := os.Stat(full); !errors.Is(statErr, os.ErrNotExist) {
|
|
t.Errorf("cover file still on disk after delete: stat err=%v", statErr)
|
|
}
|
|
}
|
|
|
|
func TestDelete_MissingCoverFileTolerated(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
dir := t.TempDir()
|
|
svc := playlists.NewService(pool, nil, dir)
|
|
|
|
pl, err := svc.Create(context.Background(), user.ID, "No cover on disk", "", false)
|
|
if err != nil {
|
|
t.Fatalf("seed Create: %v", err)
|
|
}
|
|
// Set cover_path to a file that doesn't exist — Delete must not
|
|
// error on a missing cached file; it's just cleanup.
|
|
relPath := filepath.Join("playlist_covers", uuidString(pl.ID)+".jpg")
|
|
if _, err := pool.Exec(context.Background(),
|
|
`UPDATE playlists SET cover_path = $1 WHERE id = $2`, relPath, pl.ID); err != nil {
|
|
t.Fatalf("set cover_path: %v", err)
|
|
}
|
|
|
|
if err := svc.Delete(context.Background(), user.ID, pl.ID); err != nil {
|
|
t.Fatalf("Delete with missing cover file: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAppendTracks_Snapshot(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
track := seedTrack(t, pool, "Roygbiv", "Boards of Canada")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
if err := svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{track.ID}); err != nil {
|
|
t.Fatalf("AppendTracks: %v", err)
|
|
}
|
|
|
|
got, _ := svc.Get(context.Background(), user.ID, pl.ID)
|
|
if len(got.Tracks) != 1 {
|
|
t.Fatalf("Tracks length = %d, want 1", len(got.Tracks))
|
|
}
|
|
if got.Tracks[0].Title != "Roygbiv" {
|
|
t.Errorf("Title snapshot = %q, want Roygbiv", got.Tracks[0].Title)
|
|
}
|
|
if got.Tracks[0].ArtistName != "Boards of Canada" {
|
|
t.Errorf("ArtistName snapshot = %q, want Boards of Canada", got.Tracks[0].ArtistName)
|
|
}
|
|
if got.TrackCount != 1 {
|
|
t.Errorf("rollup TrackCount = %d, want 1", got.TrackCount)
|
|
}
|
|
}
|
|
|
|
func TestAppendTracks_OwnerOnly(t *testing.T) {
|
|
pool := newPool(t)
|
|
alice := seedUser(t, pool, "alice")
|
|
bob := seedUser(t, pool, "bob")
|
|
track := seedTrack(t, pool, "T", "A")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), alice.ID, "Mine", "", true)
|
|
err := svc.AppendTracks(context.Background(), bob.ID, pl.ID, []pgtype.UUID{track.ID})
|
|
if !errors.Is(err, playlists.ErrForbidden) {
|
|
t.Errorf("err = %v, want ErrForbidden", err)
|
|
}
|
|
}
|
|
|
|
func TestAppendTracks_NonExistentTrack(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
err := svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{randomUUID()})
|
|
if !errors.Is(err, playlists.ErrTrackNotFound) {
|
|
t.Errorf("err = %v, want ErrTrackNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestRemoveTrack_RenumbersPositions(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
t1 := seedTrack(t, pool, "Track 1", "Artist")
|
|
t2 := seedTrack(t, pool, "Track 2", "Artist")
|
|
t3 := seedTrack(t, pool, "Track 3", "Artist")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
_ = svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{t1.ID, t2.ID, t3.ID})
|
|
|
|
// Remove the middle one (position 1).
|
|
if err := svc.RemoveTrack(context.Background(), user.ID, pl.ID, 1); err != nil {
|
|
t.Fatalf("RemoveTrack: %v", err)
|
|
}
|
|
|
|
got, _ := svc.Get(context.Background(), user.ID, pl.ID)
|
|
if len(got.Tracks) != 2 {
|
|
t.Fatalf("Tracks length = %d, want 2", len(got.Tracks))
|
|
}
|
|
if got.Tracks[0].Title != "Track 1" {
|
|
t.Errorf("position 0 = %q, want Track 1", got.Tracks[0].Title)
|
|
}
|
|
if got.Tracks[1].Title != "Track 3" {
|
|
t.Errorf("position 1 = %q, want Track 3 (renumbered from 2)", got.Tracks[1].Title)
|
|
}
|
|
}
|
|
|
|
func TestReorder_Permutation(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
t1 := seedTrack(t, pool, "A", "Artist")
|
|
t2 := seedTrack(t, pool, "B", "Artist")
|
|
t3 := seedTrack(t, pool, "C", "Artist")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
_ = svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{t1.ID, t2.ID, t3.ID})
|
|
|
|
// Reverse order: send [2, 1, 0].
|
|
if err := svc.Reorder(context.Background(), user.ID, pl.ID, []int32{2, 1, 0}); err != nil {
|
|
t.Fatalf("Reorder: %v", err)
|
|
}
|
|
|
|
got, _ := svc.Get(context.Background(), user.ID, pl.ID)
|
|
wantOrder := []string{"C", "B", "A"}
|
|
for i, pt := range got.Tracks {
|
|
if pt.Title != wantOrder[i] {
|
|
t.Errorf("position %d = %q, want %q", i, pt.Title, wantOrder[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReorder_RejectsNonPermutation(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
tk := seedTrack(t, pool, "T", "A")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
_ = svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{tk.ID})
|
|
|
|
// 2 positions for a 1-track playlist — invalid.
|
|
err := svc.Reorder(context.Background(), user.ID, pl.ID, []int32{0, 1})
|
|
if !errors.Is(err, playlists.ErrInvalidInput) {
|
|
t.Errorf("err = %v, want ErrInvalidInput (length mismatch)", err)
|
|
}
|
|
|
|
pl2, _ := svc.Create(context.Background(), user.ID, "Two", "", false)
|
|
t2 := seedTrack(t, pool, "T2", "A")
|
|
_ = svc.AppendTracks(context.Background(), user.ID, pl2.ID, []pgtype.UUID{tk.ID, t2.ID})
|
|
err = svc.Reorder(context.Background(), user.ID, pl2.ID, []int32{0, 0})
|
|
if !errors.Is(err, playlists.ErrInvalidInput) {
|
|
t.Errorf("err = %v, want ErrInvalidInput (duplicate)", err)
|
|
}
|
|
}
|
|
|
|
func TestSnapshotPersistsAfterUpstreamTrackDelete(t *testing.T) {
|
|
pool := newPool(t)
|
|
user := seedUser(t, pool, "alice")
|
|
tk := seedTrack(t, pool, "Doomed track", "Artist")
|
|
svc := playlists.NewService(pool, nil, t.TempDir())
|
|
|
|
pl, _ := svc.Create(context.Background(), user.ID, "Test", "", false)
|
|
_ = svc.AppendTracks(context.Background(), user.ID, pl.ID, []pgtype.UUID{tk.ID})
|
|
|
|
// Delete the track row directly (simulating Lidarr re-import / file removal).
|
|
if _, err := pool.Exec(context.Background(), `DELETE FROM tracks WHERE id = $1`, tk.ID); err != nil {
|
|
t.Fatalf("delete track: %v", err)
|
|
}
|
|
|
|
got, _ := svc.Get(context.Background(), user.ID, pl.ID)
|
|
if len(got.Tracks) != 1 {
|
|
t.Fatalf("Tracks length = %d, want 1 (soft-mark not silent-cascade)", len(got.Tracks))
|
|
}
|
|
row := got.Tracks[0]
|
|
if row.TrackID != nil {
|
|
t.Error("TrackID should be nil after upstream delete")
|
|
}
|
|
if row.Title != "Doomed track" {
|
|
t.Errorf("Snapshot Title = %q, want Doomed track", row.Title)
|
|
}
|
|
}
|