sonda/internal/storage/smart_test.go
tgiachi a880b87a9e chore: move the module path to git.kmalloc.org/squid/sonda
Migrating hosting from Codeberg to git.kmalloc.org. Renames the
module path in go.mod, every internal import, and the OCI image
source label in the Dockerfile. Build and full test suite verified
green after the rename.
2026-11-15 17:30:29 +01:00

447 lines
17 KiB
Go

package storage
import (
"context"
"errors"
"slices"
"testing"
"time"
"github.com/uptrace/bun"
"git.kmalloc.org/squid/sonda/internal/smart"
)
// smartEnv is two users and a library of songs that differ in what the rules ask about.
type smartEnv struct {
t *testing.T
db *bun.DB
repo *SmartRepo
alice int64
bob int64
tracks map[string]int64
artist map[string]int64
album map[string]int64
now time.Time
}
type smartSong struct {
title, artist, album, format string
genres []string
bitrate int
mtime int64
seconds int64
}
func newSmartEnv(t *testing.T, db *bun.DB, songs []smartSong) *smartEnv {
t.Helper()
ctx := context.Background()
users := NewUserRepo(db)
a, err := users.CreateUser(ctx, "alice@example.org", "hash", false)
if err != nil {
t.Fatal(err)
}
b, err := users.CreateUser(ctx, "bob@example.org", "hash", false)
if err != nil {
t.Fatal(err)
}
lib := NewLibraryRepo(db)
l, err := lib.CreateLibrary(ctx, "m", "/lib/m")
if err != nil {
t.Fatal(err)
}
e := &smartEnv{t: t, db: db, repo: NewSmartRepo(db), alice: a.ID, bob: b.ID, now: time.Unix(1_700_000_000, 0),
tracks: map[string]int64{}, artist: map[string]int64{}, album: map[string]int64{}}
for i, s := range songs {
f := pf("x/"+s.title+"."+s.format, s.title, s.album, s.artist, i+1, 1, s.format, s.artist)
f.Tags.Genres = s.genres
f.BitRate = s.bitrate
f.MTimeUnix = s.mtime
if s.seconds > 0 {
f.DurationMs = s.seconds * 1000
}
if _, err := lib.SaveFile(ctx, l.ID, f, 0); err != nil {
t.Fatal(err)
}
var id int64
if err := db.QueryRow("SELECT id FROM tracks WHERE title = ?", s.title).Scan(&id); err != nil {
t.Fatal(err)
}
e.tracks[s.title] = id
}
for _, q := range []struct {
sql string
to map[string]int64
}{{"SELECT id, name FROM artists", e.artist}, {"SELECT id, title FROM albums", e.album}} {
rows, err := db.Query(q.sql)
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
var name string
if err := rows.Scan(&id, &name); err != nil {
t.Fatal(err)
}
q.to[name] = id
}
rows.Close()
}
return e
}
func (e *smartEnv) tick() time.Time { e.now = e.now.Add(time.Minute); return e.now }
func smartBackends(t *testing.T, songs []smartSong, fn func(t *testing.T, e *smartEnv)) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) { fn(t, newSmartEnv(t, db, songs)) })
}
var smartSongs = []smartSong{
{"a", "Queen", "News", "flac", []string{"rock", "classic rock"}, 1000, 1_000, 120},
{"b", "Queen", "News", "mpeg", []string{"rock"}, 320, 2_000, 200},
{"c", "Kiss", "Alive", "mpeg", []string{"rock", "hard rock"}, 192, 3_000, 240},
{"d", "Slayer", "Reign", "flac", []string{"metal"}, 800, 4_000, 180},
{"e", "Miles", "Blue", "flac", []string{"jazz+funk"}, 1100, 5_000, 300},
}
func names(e *smartEnv, cands []smart.Candidate) []string {
byID := map[int64]string{}
for k, v := range e.tracks {
byID[v] = k
}
out := make([]string, len(cands))
for i, c := range cands {
out[i] = byID[c.TrackID]
}
slices.Sort(out)
return out
}
func TestSmartRepoCandidatesNarrowByEveryList(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
for name, tc := range map[string]struct {
f smart.Filter
want []string
}{
"no filter: every playable song": {smart.Filter{}, []string{"a", "b", "c", "d", "e"}},
"a genre": {smart.Filter{Genres: []string{"rock"}}, []string{"a", "b", "c"}},
"one of two genres": {smart.Filter{Genres: []string{"metal", "jazz+funk"}}, []string{"d", "e"}},
"not a genre": {smart.Filter{NotGenres: []string{"hard rock", "metal"}}, []string{"a", "b", "e"}},
"a genre and not another": {smart.Filter{Genres: []string{"rock"}, NotGenres: []string{"hard rock"}}, []string{"a", "b"}},
"an artist": {smart.Filter{ArtistIDs: []int64{e.artist["Queen"]}}, []string{"a", "b"}},
"not an artist": {smart.Filter{NotArtistIDs: []int64{e.artist["Queen"], e.artist["Kiss"]}}, []string{"d", "e"}},
"an album": {smart.Filter{AlbumIDs: []int64{e.album["Alive"]}}, []string{"c"}},
"not an album": {smart.Filter{NotAlbumIDs: []int64{e.album["News"]}}, []string{"c", "d", "e"}},
"a format": {smart.Filter{Formats: []string{"mpeg"}}, []string{"b", "c"}},
"two formats": {smart.Filter{Formats: []string{"mpeg", "flac"}}, []string{"a", "b", "c", "d", "e"}},
"a bitrate": {smart.Filter{MinBitrateKbps: 900}, []string{"a", "e"}},
"a format and a bitrate": {smart.Filter{Formats: []string{"flac"}, MinBitrateKbps: 900}, []string{"a", "e"}},
"a format that nothing has": {smart.Filter{Formats: []string{"ogg"}}, []string{}},
"two lists must both hold": {smart.Filter{Genres: []string{"rock"}, Formats: []string{"flac"}}, []string{"a"}},
} {
t.Run(name, func(t *testing.T) {
got, err := e.repo.Candidates(ctx, tc.f)
if err != nil {
t.Fatal(err)
}
if g := names(e, got); !slices.Equal(g, tc.want) {
t.Errorf("got %v, want %v", g, tc.want)
}
})
}
})
}
func TestSmartRepoAFormatAndABitrateAreAboutTheSameFile(t *testing.T) {
songs := []smartSong{{"a", "Queen", "News", "flac", nil, 500, 1, 60}}
smartBackends(t, songs, func(t *testing.T, e *smartEnv) {
// A second file of the same song: an mp3 with a high bitrate. flac AND 900 holds for no file.
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix, bitrate)
SELECT track_id, library_id, 'x/a.mp3', 'mpeg', 1, 9000, 1000 FROM audio_files LIMIT 1`); err != nil {
t.Fatal(err)
}
got, err := e.repo.Candidates(context.Background(), smart.Filter{Formats: []string{"flac"}, MinBitrateKbps: 900})
if err != nil {
t.Fatal(err)
}
if len(got) != 0 {
t.Errorf("got %v: the format and the bitrate belong to one file", names(e, got))
}
got, _ = e.repo.Candidates(context.Background(), smart.Filter{Formats: []string{"mpeg"}, MinBitrateKbps: 900})
if len(got) != 1 {
t.Errorf("the mp3 file has both: got %v", names(e, got))
}
})
}
func TestSmartRepoCandidatesGiveWhatTheRulesNeedAndLeaveOutSongsWithNoFile(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id = ?", e.tracks["e"]); err != nil {
t.Fatal(err)
}
got, err := e.repo.Candidates(ctx, smart.Filter{})
if err != nil {
t.Fatal(err)
}
if g := names(e, got); !slices.Equal(g, []string{"a", "b", "c", "d"}) {
t.Errorf("got %v: a song whose files are gone is not offered", g)
}
for _, c := range got {
if c.TrackID != e.tracks["c"] {
continue
}
if c.ArtistID != e.artist["Kiss"] || c.DurationMs != 240_000 || c.Title != "c" || !c.AddedAt.Equal(time.Unix(3_000, 0)) {
t.Errorf("candidate = %+v", c)
}
}
// The date is the newest file that is not missing.
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix)
SELECT track_id, library_id, 'x/c2.mpeg', 'mpeg', 1, 7000 FROM audio_files WHERE track_id = ? LIMIT 1`, e.tracks["c"]); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix, missing_at)
SELECT track_id, library_id, 'x/c3.mpeg', 'mpeg', 1, 9000, 5 FROM audio_files WHERE track_id = ? LIMIT 1`, e.tracks["c"]); err != nil {
t.Fatal(err)
}
got, _ = e.repo.Candidates(ctx, smart.Filter{ArtistIDs: []int64{e.artist["Kiss"]}})
if len(got) != 1 || !got[0].AddedAt.Equal(time.Unix(7_000, 0)) {
t.Errorf("got %+v, want one song added at 7000", got)
}
})
}
func sample() smart.SmartPlaylist {
return smart.SmartPlaylist{
Name: "Fresh", Description: "new things", Sort: smart.SortRecentlyAdded, Limit: 30,
Rules: smart.Rules{Genres: []string{"rock"}, ArtistIDs: []int64{3, 4}, Formats: []string{"flac"}, MinBitrateKbps: 900, AddedWithinDays: 30, NeverPlayed: true, MinDurationSec: 60},
}
}
func TestSmartRepoKeepsAPlaylistAndItsRulesPerUser(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
p, err := e.repo.Create(ctx, e.alice, sample(), e.tick())
if err != nil {
t.Fatal(err)
}
want := sample()
want.ID, want.CreatedAt, want.UpdatedAt = p.ID, e.now, e.now
if p.ID == 0 || p.Name != want.Name || p.Description != want.Description || p.Sort != want.Sort || p.Limit != want.Limit ||
!slices.Equal(p.Rules.Genres, want.Rules.Genres) || !slices.Equal(p.Rules.ArtistIDs, want.Rules.ArtistIDs) ||
!slices.Equal(p.Rules.Formats, want.Rules.Formats) || p.Rules.MinBitrateKbps != 900 || p.Rules.AddedWithinDays != 30 ||
!p.Rules.NeverPlayed || p.Rules.MinDurationSec != 60 || !p.CreatedAt.Equal(e.now) || !p.UpdatedAt.Equal(e.now) {
t.Errorf("created = %+v, want %+v", p, want)
}
got, err := e.repo.Get(ctx, e.alice, p.ID)
if err != nil || got.Name != "Fresh" || !slices.Equal(got.Rules.Genres, []string{"rock"}) {
t.Errorf("get = %+v, %v", got, err)
}
// Somebody else's is as if it did not exist, whatever is done to it.
if _, err := e.repo.Get(ctx, e.bob, p.ID); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("get by another user: %v", err)
}
if _, err := e.repo.Update(ctx, e.bob, p.ID, sample(), e.tick()); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("update by another user: %v", err)
}
if err := e.repo.Delete(ctx, e.bob, p.ID); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("delete by another user: %v", err)
}
if got, _ := e.repo.Get(ctx, e.alice, p.ID); got.Name != "Fresh" {
t.Errorf("the playlist changed: %+v", got)
}
if _, err := e.repo.Get(ctx, e.alice, p.ID+100); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("get of nothing: %v", err)
}
})
}
func TestSmartRepoListsTheOneChangedLastFirstInPages(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
var ids []int64
for _, n := range []string{"one", "two", "three"} {
p := sample()
p.Name = n
made, err := e.repo.Create(ctx, e.alice, p, e.tick())
if err != nil {
t.Fatal(err)
}
ids = append(ids, made.ID)
}
other := sample()
other.Name = "bob's"
if _, err := e.repo.Create(ctx, e.bob, other, e.tick()); err != nil {
t.Fatal(err)
}
// Changing "one" brings it to the top.
upd := sample()
upd.Name = "one, again"
if _, err := e.repo.Update(ctx, e.alice, ids[0], upd, e.tick()); err != nil {
t.Fatal(err)
}
list, total, err := e.repo.List(ctx, e.alice, 2, 0)
if err != nil || total != 3 || len(list) != 2 || list[0].Name != "one, again" || list[1].Name != "three" {
t.Fatalf("page 1 = %+v, total %d, %v", list, total, err)
}
list, _, _ = e.repo.List(ctx, e.alice, 2, 2)
if len(list) != 1 || list[0].Name != "two" {
t.Errorf("page 2 = %+v", list)
}
if err := e.repo.Delete(ctx, e.alice, ids[1]); err != nil {
t.Fatal(err)
}
if _, total, _ := e.repo.List(ctx, e.alice, 10, 0); total != 2 {
t.Errorf("total after a delete = %d", total)
}
})
}
func TestSmartRepoStopsAtTheMostASmartPlaylistsAUserCanHave(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
for i := 0; i < smart.MaxPlaylists; i++ {
if _, err := e.repo.Create(ctx, e.alice, sample(), e.tick()); err != nil {
t.Fatalf("playlist %d: %v", i+1, err)
}
}
if _, err := e.repo.Create(ctx, e.alice, sample(), e.tick()); !errors.Is(err, smart.ErrTooMany) {
t.Errorf("err = %v, want ErrTooMany", err)
}
if _, err := e.repo.Create(ctx, e.bob, sample(), e.tick()); err != nil {
t.Errorf("another user is not held back: %v", err)
}
})
}
func TestSmartPlaylistsGoWhenTheirOwnerGoes(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
if _, err := e.repo.Create(ctx, e.bob, sample(), e.tick()); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec("DELETE FROM users WHERE id = ?", e.bob); err != nil {
t.Fatal(err)
}
var n int
if err := e.db.QueryRow("SELECT COUNT(*) FROM smart_playlists").Scan(&n); err != nil || n != 0 {
t.Errorf("%d smart playlists left, %v", n, err)
}
})
}
func TestSmartRepoCountsTheListensOfEachSongSinceAMoment(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
at := func(track string, user int64, kind string, played int64, when int64, key string) {
t.Helper()
if _, err := e.db.Exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (?, ?, ?, ?, ?, ?)`, user, e.tracks[track], kind, when, played, key); err != nil {
t.Fatal(err)
}
}
const day = 86_400
now := int64(1_700_000_000)
at("a", e.alice, "complete", 180_000, now-1*day, "k1") // counts
at("a", e.alice, "complete", 180_000, now-2*day, "k2") // counts
at("a", e.alice, "play", 30_000, now-3*day, "k3") // played long enough: counts
at("a", e.alice, "play", 5_000, now-3*day, "k4") // too short: not a listen
at("a", e.alice, "skip", 2_000, now-1*day, "k5") // a skip
at("a", e.alice, "complete", 180_000, now-60*day, "k6") // before the window
at("b", e.alice, "complete", 180_000, now-5*day, "k7")
at("a", e.bob, "complete", 180_000, now-1*day, "k8") // somebody else's
got, err := e.repo.Plays(ctx, e.alice, 20*time.Second, time.Unix(now-30*day, 0))
if err != nil {
t.Fatal(err)
}
if got[e.tracks["a"]] != 3 || got[e.tracks["b"]] != 1 || len(got) != 2 {
t.Errorf("last 30 days = %v, want a: 3, b: 1", got)
}
all, _ := e.repo.Plays(ctx, e.alice, 20*time.Second, time.Unix(0, 0))
if all[e.tracks["a"]] != 4 {
t.Errorf("all time = %v, want a: 4", all)
}
if none, _ := e.repo.Plays(ctx, e.alice, 20*time.Second, time.Unix(now+day, 0)); len(none) != 0 {
t.Errorf("a window in the future = %v", none)
}
})
}
func TestSmartRepoAlbumCoversFollowTheOrderOfTheSongsAndSkipWhatHasNoCover(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
cover := func(album string, status string) {
t.Helper()
if _, err := e.db.Exec("DELETE FROM images WHERE kind = 'album' AND owner_id = ?", e.album[album]); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec("INSERT INTO images (kind, owner_id, status, checked_at) VALUES ('album', ?, ?, 1)", e.album[album], status); err != nil {
t.Fatal(err)
}
}
// a and b share the album News, c has Alive, d has Reign, e has Blue.
cover("News", "ok")
cover("Alive", "none")
cover("Reign", "ok")
cover("Blue", "stale")
ids := func(names ...string) []int64 {
out := make([]int64, len(names))
for i, n := range names {
out[i] = e.tracks[n]
}
return out
}
got, err := e.repo.AlbumCovers(ctx, ids("d", "c", "b", "a", "e"), 4)
if err != nil {
t.Fatal(err)
}
if want := []int64{e.album["Reign"], e.album["News"]}; !slices.Equal(got, want) {
t.Errorf("covers = %v, want %v: in the order of the songs, News once, no cover and a stale one left out", got, want)
}
if got, _ := e.repo.AlbumCovers(ctx, ids("d", "a"), 1); !slices.Equal(got, []int64{e.album["Reign"]}) {
t.Errorf("limit 1 = %v", got)
}
if got, err := e.repo.AlbumCovers(ctx, nil, 4); err != nil || got == nil || len(got) != 0 {
t.Errorf("no songs = %#v, %v", got, err)
}
if got, _ := e.repo.AlbumCovers(ctx, ids("c", "e"), 4); len(got) != 0 {
t.Errorf("songs of albums with no cover = %v", got)
}
})
}
func TestSmartRepoCandidatesNarrowByYear(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
// a 1975, b 1985, c 1985, d 1995, e has no year.
for title, year := range map[string]int{"a": 1975, "b": 1985, "c": 1985, "d": 1995} {
if _, err := e.db.Exec("UPDATE tracks SET year = ? WHERE id = ?", year, e.tracks[title]); err != nil {
t.Fatal(err)
}
}
for name, tc := range map[string]struct {
f smart.Filter
want []string
}{
"from a year": {smart.Filter{MinYear: 1985}, []string{"b", "c", "d"}},
"up to a year": {smart.Filter{MaxYear: 1985}, []string{"a", "b", "c"}},
"between two years": {smart.Filter{MinYear: 1980, MaxYear: 1989}, []string{"b", "c"}},
"one year": {smart.Filter{MinYear: 1995, MaxYear: 1995}, []string{"d"}},
"a year and a genre": {smart.Filter{MinYear: 1980, Genres: []string{"rock"}}, []string{"b", "c"}},
"no year rule: a song with no year is still there": {smart.Filter{}, []string{"a", "b", "c", "d", "e"}},
} {
t.Run(name, func(t *testing.T) {
got, err := e.repo.Candidates(ctx, tc.f)
if err != nil {
t.Fatal(err)
}
if g := names(e, got); !slices.Equal(g, tc.want) {
t.Errorf("got %v, want %v", g, tc.want)
}
})
}
})
}