sonda/internal/storage/mixes_test.go
tgiachi ca5cbbf088 feat: favourites teach Sonda my taste
A heart adds to what the listening says of an artist: a favourite artist counts
as much as three complete listens, a favourite album 1.5 for its album artist and
a favourite song 1 for each of its main artists, at most 6 for one artist, without
fading with time. An artist hearted but never played is liked, with no listens.
That feeds Discover, the mixes and the smart playlists that use the taste, and
GET /me/taste.

In the mixes of what the listener likes (genre mixes, Your favourites,
Rediscover) a hearted song is wanted 1.5 times as much and a song on a hearted
album 1.25 times. New to you is not changed.
2026-11-16 11:08:20 +01:00

385 lines
13 KiB
Go

package storage
import (
"context"
"slices"
"testing"
"time"
"github.com/uptrace/bun"
"git.kmalloc.org/squid/sonda/internal/favorites"
"git.kmalloc.org/squid/sonda/internal/listening"
"git.kmalloc.org/squid/sonda/internal/mixes"
)
// mixEnv is a library with songs of known genres and artists, and a user.
type mixEnv struct {
t *testing.T
db *bun.DB
repo *MixRepo
user int64
tracks map[string]int64
artist map[string]int64
}
// mixSong is one file: its title, artists, genres.
type mixSong struct {
title, artist string
genres []string
}
func newMixEnv(t *testing.T, db *bun.DB, songs []mixSong) *mixEnv {
t.Helper()
ctx := context.Background()
u, err := NewUserRepo(db).CreateUser(ctx, "a@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 := &mixEnv{t: t, db: db, repo: NewMixRepo(db), user: u.ID, tracks: map[string]int64{}, artist: map[string]int64{}}
for i, s := range songs {
f := pf("x/"+s.title+".flac", s.title, "Album "+s.artist, s.artist, i+1, 1, "flac", s.artist)
f.Tags.Genres = s.genres
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
}
rows, err := db.Query("SELECT id, name FROM artists")
if err != nil {
t.Fatal(err)
}
defer rows.Close()
for rows.Next() {
var id int64
var name string
if err := rows.Scan(&id, &name); err != nil {
t.Fatal(err)
}
e.artist[name] = id
}
return e
}
func mixBackends(t *testing.T, songs []mixSong, fn func(t *testing.T, e *mixEnv)) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) { fn(t, newMixEnv(t, db, songs)) })
}
var mixSongs = []mixSong{
{"r1", "Queen", []string{"rock", "classic rock"}},
{"r2", "Queen", []string{"rock"}},
{"r3", "Kiss", []string{"rock"}},
{"m1", "Slayer", []string{"metal"}},
{"m2", "Slayer", []string{"metal"}},
{"j1", "Miles", []string{"jazz+funk"}},
{"n1", "Nobody", nil},
}
func TestMixRepoGenresCountSongsAndArtistsOfThePlayableOnes(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
got, err := e.repo.Genres(context.Background())
if err != nil {
t.Fatal(err)
}
by := map[string]mixes.Genre{}
for _, g := range got {
by[g.Name] = g
}
if g := by["rock"]; g.Tracks != 3 || g.Artists != 2 {
t.Errorf("rock = %+v, want 3 songs by 2 artists", g)
}
if g := by["metal"]; g.Tracks != 2 || g.Artists != 1 {
t.Errorf("metal = %+v", g)
}
if _, ok := by["jazz+funk"]; !ok {
t.Error("the spelling of the file is kept")
}
// A song whose files are gone is not counted.
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id = ?", e.tracks["r3"]); err != nil {
t.Fatal(err)
}
got, _ = e.repo.Genres(context.Background())
for _, g := range got {
if g.Name == "rock" && (g.Tracks != 2 || g.Artists != 1) {
t.Errorf("rock after a song went = %+v", g)
}
}
})
}
func TestMixRepoPoolByGenreOrByArtistGivesPlayableSongsWithTheirArtist(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
ctx := context.Background()
ids := func(refs []mixes.TrackRef) []int64 {
out := make([]int64, len(refs))
for i, r := range refs {
out[i] = r.TrackID
}
slices.Sort(out)
return out
}
rock, err := e.repo.Pool(ctx, mixes.Filter{Genres: []string{"rock"}})
if err != nil {
t.Fatal(err)
}
want := []int64{e.tracks["r1"], e.tracks["r2"], e.tracks["r3"]}
slices.Sort(want)
if !slices.Equal(ids(rock), want) {
t.Errorf("rock pool = %v, want %v", ids(rock), want)
}
for _, r := range rock {
if r.TrackID == e.tracks["r3"] && r.ArtistID != e.artist["Kiss"] {
t.Errorf("artist of r3 = %d, want Kiss", r.ArtistID)
}
}
both, _ := e.repo.Pool(ctx, mixes.Filter{Genres: []string{"metal"}, ArtistIDs: []int64{e.artist["Miles"]}})
if len(both) != 3 {
t.Errorf("metal or Miles = %d songs, want 3", len(both))
}
if none, _ := e.repo.Pool(ctx, mixes.Filter{}); len(none) != 0 {
t.Errorf("an empty filter gave %d songs", len(none))
}
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id = ?", e.tracks["r1"]); err != nil {
t.Fatal(err)
}
if again, _ := e.repo.Pool(ctx, mixes.Filter{Genres: []string{"rock"}}); len(again) != 2 {
t.Errorf("a song with no file is in the pool: %d songs", len(again))
}
})
}
func TestMixRepoGenreArtistsAreTheOnesWithMostSongs(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
got, err := e.repo.GenreArtists(context.Background(), []string{"rock", "metal"}, 2)
if err != nil || len(got) != 2 {
t.Fatalf("artists = %v err %v", got, err)
}
if got[0] != "Queen" && got[0] != "Slayer" { // both have two songs
t.Errorf("first = %q", got[0])
}
all, _ := e.repo.GenreArtists(context.Background(), []string{"rock"}, 10)
if !slices.Equal(all, []string{"Queen", "Kiss"}) {
t.Errorf("rock artists = %v, want Queen (2 songs) then Kiss", all)
}
})
}
func TestMixRepoGenreArtistsLeaveOutPlaceholderNames(t *testing.T) {
songs := append([]mixSong{}, mixSongs...)
songs = append(songs, mixSong{"u1", "Unknown Artist", []string{"rock"}}, mixSong{"u2", "Unknown Artist", []string{"rock"}},
mixSong{"u3", "Unknown Artist", []string{"rock"}}, mixSong{"v1", "Various Artists", []string{"rock"}})
mixBackends(t, songs, func(t *testing.T, e *mixEnv) {
got, err := e.repo.GenreArtists(context.Background(), []string{"rock"}, 10)
if err != nil || !slices.Equal(got, []string{"Queen", "Kiss"}) {
t.Errorf("rock artists = %v err %v: the names that stand for nobody are not artists to show", got, err)
}
})
}
func TestMixRepoArtistGenresCountTheSongsOfEachGenre(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
got, err := e.repo.ArtistGenres(context.Background(), []int64{e.artist["Queen"], e.artist["Miles"]})
if err != nil {
t.Fatal(err)
}
if g := got[e.artist["Queen"]]; g["rock"] != 2 || g["classic rock"] != 1 {
t.Errorf("Queen = %v", g)
}
if g := got[e.artist["Miles"]]; g["jazz+funk"] != 1 {
t.Errorf("Miles = %v", g)
}
})
}
func TestMixRepoHistoryCountsListensAndSkipsLikeTheTasteModel(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
ctx := context.Background()
rec := listening.NewService(NewListeningRepo(e.db), 20*time.Second)
t0 := time.Now().Add(-48 * time.Hour).Truncate(time.Second)
ev := func(title string, typ listening.EventType, playedMs int64, at time.Time, key string) {
t.Helper()
if _, err := rec.Record(ctx, listening.Event{UserID: e.user, TrackID: e.tracks[title], Type: typ, DurationPlayedMs: playedMs, OccurredAt: at, IdempotencyKey: key}); err != nil {
t.Fatalf("record %s: %v", key, err)
}
}
ev("r1", listening.Complete, 59000, t0, "a")
ev("r1", listening.Play, 30000, t0.Add(time.Hour), "b") // 30 s: a listen
ev("r1", listening.Play, 5000, t0.Add(2*time.Hour), "c") // 5 s: nothing
ev("r2", listening.Skip, 4000, t0, "d") // skipped before enough: a skip
ev("r3", listening.Skip, 40000, t0, "e") // skipped after 40 s: a listen, not a dislike
h, err := e.repo.History(ctx, e.user, 20*time.Second)
if err != nil {
t.Fatal(err)
}
r1 := h[e.tracks["r1"]]
if r1.Plays != 2 || !r1.LastPlayed.Equal(t0.Add(time.Hour)) || !r1.SkippedAt.IsZero() {
t.Errorf("r1 = %+v", r1)
}
if r2 := h[e.tracks["r2"]]; r2.Plays != 0 || !r2.SkippedAt.Equal(t0) {
t.Errorf("r2 = %+v", r2)
}
if r3 := h[e.tracks["r3"]]; r3.Plays != 1 || !r3.SkippedAt.IsZero() {
t.Errorf("r3 = %+v", r3)
}
if _, ok := h[e.tracks["m1"]]; ok {
t.Error("a song with no event is in the history")
}
if other, _ := e.repo.History(ctx, e.user+99, 20*time.Second); len(other) != 0 {
t.Errorf("another user has history: %v", other)
}
})
}
func TestMixRepoTracksComeInTheOrderAskedWithoutTheOnesThatCannotBePlayed(t *testing.T) {
mixBackends(t, mixSongs, func(t *testing.T, e *mixEnv) {
ctx := context.Background()
ask := []int64{e.tracks["m2"], e.tracks["r1"], 999999, e.tracks["j1"], e.tracks["r1"]}
got, err := e.repo.Tracks(ctx, ask)
if err != nil {
t.Fatal(err)
}
var titles []string
for _, tr := range got {
titles = append(titles, tr.Title)
}
if !slices.Equal(titles, []string{"m2", "r1", "j1", "r1"}) {
t.Errorf("titles = %v: the order asked, the unknown one left out, a repeat kept", titles)
}
if got[0].Album == nil || len(got[0].Artists) != 1 || got[0].Format != "flac" {
t.Errorf("details = %+v", got[0])
}
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id = ?", e.tracks["m2"]); err != nil {
t.Fatal(err)
}
got, _ = e.repo.Tracks(ctx, ask)
if len(got) != 3 || got[0].Title != "r1" {
t.Errorf("a song with no file was not left out: %d songs", len(got))
}
if none, err := e.repo.Tracks(ctx, nil); err != nil || len(none) != 0 {
t.Errorf("nothing asked: %v %v", none, err)
}
})
}
// cover gives an album a cover record with the status.
func (e *mixEnv) cover(album int64, status string) {
e.t.Helper()
if _, err := e.db.Exec("DELETE FROM images WHERE kind = 'album' AND owner_id = ?", album); err != nil { // the scan may have made one
e.t.Fatal(err)
}
if _, err := e.db.Exec("INSERT INTO images (kind, owner_id, status, checked_at) VALUES ('album', ?, ?, 1)", album, status); err != nil {
e.t.Fatal(err)
}
}
func (e *mixEnv) albumOf(title string) int64 {
e.t.Helper()
var id int64
if err := e.db.QueryRow("SELECT album_id FROM tracks WHERE id = ?", e.tracks[title]).Scan(&id); err != nil {
e.t.Fatal(err)
}
return id
}
func TestMixRepoCoversAreAlbumsWithACoverByDifferentArtistsWithMostSongsFirst(t *testing.T) {
songs := []mixSong{
{"r1", "Queen", []string{"rock"}}, {"r2", "Queen", []string{"rock"}}, {"r3", "Queen", []string{"rock"}},
{"k1", "Kiss", []string{"rock"}}, {"k2", "Kiss", []string{"rock"}},
{"a1", "ABBA", []string{"rock"}},
{"m1", "Slayer", []string{"metal"}}, {"m2", "Slayer", []string{"metal"}},
{"p1", "Pooh", []string{"pop"}},
}
mixBackends(t, songs, func(t *testing.T, e *mixEnv) {
ctx := context.Background()
queen, kiss, abba, slayer := e.albumOf("r1"), e.albumOf("k1"), e.albumOf("a1"), e.albumOf("m1")
// A second album of Queen, with one song, and a cover too: the artist is not shown twice.
var second int64
if err := e.db.QueryRow("INSERT INTO albums (title, artist_id, title_key, search_key) SELECT 'Second', artist_id, 'second', 'second' FROM albums WHERE id = ? RETURNING id", queen).Scan(&second); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec("UPDATE tracks SET album_id = ? WHERE id = ?", second, e.tracks["r3"]); err != nil {
t.Fatal(err)
}
e.cover(queen, "ok")
e.cover(second, "ok")
e.cover(kiss, "ok")
e.cover(abba, "none") // no cover
e.cover(slayer, "ok") // another genre
got, err := e.repo.Covers(ctx, mixes.Filter{Genres: []string{"rock"}}, 4)
if err != nil {
t.Fatal(err)
}
if want := []int64{queen, kiss}; !slices.Equal(got, want) {
t.Errorf("rock = %v, want %v: Queen once (the album with most songs), Kiss, and not the album with no cover", got, want)
}
if got, _ := e.repo.Covers(ctx, mixes.Filter{Genres: []string{"rock"}}, 1); !slices.Equal(got, []int64{queen}) {
t.Errorf("limit 1 = %v", got)
}
// By artist, and by genre or artist together.
got, _ = e.repo.Covers(ctx, mixes.Filter{ArtistIDs: []int64{e.artist["Slayer"]}}, 4)
if !slices.Equal(got, []int64{slayer}) {
t.Errorf("artist = %v", got)
}
got, _ = e.repo.Covers(ctx, mixes.Filter{Genres: []string{"metal"}, ArtistIDs: []int64{e.artist["Kiss"]}}, 4)
if len(got) != 2 {
t.Errorf("metal or Kiss = %v, want two albums", got)
}
// Nothing asked for, nothing given.
if got, _ := e.repo.Covers(ctx, mixes.Filter{}, 4); len(got) != 0 {
t.Errorf("no filter = %v", got)
}
// An album whose songs are all gone is not offered.
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id IN (?, ?)", e.tracks["k1"], e.tracks["k2"]); err != nil {
t.Fatal(err)
}
got, _ = e.repo.Covers(ctx, mixes.Filter{Genres: []string{"rock"}}, 4)
if !slices.Equal(got, []int64{queen}) {
t.Errorf("after Kiss's files went = %v", got)
}
})
}
func TestHeartsAreTheSongsHeartedAndTheSongsOfHeartedAlbums(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
ctx := context.Background()
s := seedCatalog(t, db)
fav := NewFavoritesRepo(db)
uid, other := seedUser(t, db, "a@example.org"), seedUser(t, db, "b@example.org")
var ok int64
if err := db.QueryRowContext(ctx, "SELECT id FROM albums WHERE title = 'OK Computer'").Scan(&ok); err != nil {
t.Fatal(err)
}
at := time.Unix(1_700_000_000, 0)
_ = fav.Add(ctx, uid, favorites.Track, s.track["Airbag"], at)
_ = fav.Add(ctx, uid, favorites.Track, s.track["Army of Me"], at)
_ = fav.Add(ctx, uid, favorites.Album, ok, at)
_ = fav.Add(ctx, other, favorites.Track, s.track["So What"], at)
got, err := NewMixRepo(db).Hearts(ctx, uid)
if err != nil {
t.Fatal(err)
}
if h := got[s.track["Airbag"]]; !h.Track || !h.Album { // hearted, and on a hearted album
t.Errorf("Airbag = %+v", h)
}
if h := got[s.track["Karma Police"]]; h.Track || !h.Album {
t.Errorf("Karma Police = %+v", h)
}
if h := got[s.track["Army of Me"]]; !h.Track || h.Album {
t.Errorf("Army of Me = %+v", h)
}
if _, ok := got[s.track["So What"]]; ok {
t.Error("another person's heart counted")
}
})
}