sonda/internal/storage/affinity_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

216 lines
9.1 KiB
Go

package storage
import (
"context"
"testing"
"time"
"github.com/uptrace/bun"
"git.kmalloc.org/squid/sonda/internal/affinity"
"git.kmalloc.org/squid/sonda/internal/library"
"git.kmalloc.org/squid/sonda/internal/listening"
"git.kmalloc.org/squid/sonda/internal/spotifyimport"
)
// affinitySongBy is affinitySong for a test that does not need the track.
func affinitySongBy(t *testing.T, db *bun.DB, lib int64, rel, title, artist string) {
t.Helper()
affinitySong(t, db, lib, rel, title, artist)
}
// affinitySong puts a song with one artist in the library and gives the id of its track.
func affinitySong(t *testing.T, db *bun.DB, lib int64, rel, title, artist string) int64 {
t.Helper()
f := library.ParsedFile{
FileInfo: library.FileInfo{RelPath: rel, Size: 100, MTimeUnix: 1},
Metadata: library.Metadata{
Tags: library.Tags{Title: title, Album: "Album of " + artist, AlbumArtist: artist, Artists: []string{artist}},
Properties: library.Properties{Format: "flac", DurationMs: 200_000, SampleRate: 44100, BitRate: 900},
},
}
if _, err := NewLibraryRepo(db).SaveFile(context.Background(), lib, f, 0); err != nil {
t.Fatal(err)
}
var id int64
if err := db.QueryRow("SELECT id FROM tracks WHERE title = ?", title).Scan(&id); err != nil {
t.Fatal(err)
}
return id
}
func TestTheAffinityRepoReadsThePlaysThatCountAndKeepsTheModel(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
ctx := context.Background()
u, err := NewUserRepo(db).CreateUser(ctx, "alice", "h", false)
if err != nil {
t.Fatal(err)
}
other, err := NewUserRepo(db).CreateUser(ctx, "bob", "h", false)
if err != nil {
t.Fatal(err)
}
lib, err := NewLibraryRepo(db).CreateLibrary(ctx, "music", "/music")
if err != nil {
t.Fatal(err)
}
pixies := affinitySong(t, db, lib.ID, "a.flac", "Debaser", "Pixies")
blur := affinitySong(t, db, lib.ID, "b.flac", "Song 2", "Blur")
minListen := 20 * time.Second
listens := NewListeningRepo(db)
ev := func(user, track int64, typ listening.EventType, ms int64, at int64, key string) listening.Event {
return listening.Event{UserID: user, TrackID: track, Type: typ, DurationPlayedMs: ms, OccurredAt: time.Unix(at, 0), IdempotencyKey: key}
}
for _, e := range []listening.Event{
ev(u.ID, pixies, listening.Complete, 1000, 1000, "p1"), // counts: complete
ev(u.ID, pixies, listening.Play, 30_000, 2000, "p2"), // counts: long enough
ev(u.ID, pixies, listening.Play, 5_000, 3000, "p3"), // too short
ev(u.ID, blur, listening.Skip, 1_000, 4000, "p4"), // a skip
ev(other.ID, blur, listening.Complete, 1000, 5000, "p5"),
} {
if _, err := listens.Record(ctx, e); err != nil {
t.Fatal(err)
}
}
outside := NewOutsidePlayRepo(db)
if _, err := outside.RecordOutside(ctx, u.ID, []spotifyimport.OutsidePlay{
{Key: "o1", Artist: "Giorgio Canali", PlayedAt: time.Unix(6000, 0)},
{Key: "p1", Artist: "Pixies", PlayedAt: time.Unix(1000, 0)}, // the same play as the event p1
}); err != nil {
t.Fatal(err)
}
repo := NewAffinityRepo(db)
plays, err := repo.Plays(ctx, u.ID, minListen)
if err != nil {
t.Fatal(err)
}
got := map[string]int{}
for _, p := range plays {
got[p.Name]++
if p.Key != SearchKey(p.Name) {
t.Errorf("key %q of %q, want its search key", p.Key, p.Name)
}
}
if len(plays) != 3 || got["Pixies"] != 2 || got["Giorgio Canali"] != 1 {
t.Errorf("plays = %v (%d), want Pixies twice and Canali once: the short one, the skip, the other person's and the duplicate are out", got, len(plays))
}
if n, err := repo.PlayCount(ctx, u.ID, minListen); err != nil || n != len(plays) {
t.Errorf("PlayCount = %d, %v, want %d", n, err, len(plays))
}
if _, ok, err := repo.Build(ctx, u.ID); err != nil || ok {
t.Errorf("Build before any = %v, %v, want none", ok, err)
}
at := time.Unix(9000, 0)
model := affinity.Model{
Plays: 3, Sessions: 2,
Artists: []affinity.Artist{
{Key: "pixies", Name: "Pixies", Plays: 2, Sessions: 2, Last: time.Unix(2000, 0), Weight: 1.5},
{Key: "blur", Name: "Blur", Plays: 1, Sessions: 1, Last: time.Unix(1000, 0), Weight: 0.5},
{Key: "giorgio canali", Name: "Giorgio Canali", Plays: 1, Sessions: 1, Last: time.Unix(6000, 0), Weight: 3},
},
Links: []affinity.Link{{A: "blur", B: "pixies", Score: 0.5}, {A: "giorgio canali", B: "pixies", Score: 0.25}},
}
if err := repo.Save(ctx, u.ID, at, model); err != nil {
t.Fatal(err)
}
b, ok, err := repo.Build(ctx, u.ID)
if err != nil || !ok || b.Plays != 3 || b.Sessions != 2 || b.Artists != 3 || b.Links != 2 || b.BuiltAt.Unix() != 9000 {
t.Errorf("Build = %+v, %v, %v", b, ok, err)
}
seeds, err := repo.Seeds(ctx, u.ID, 2)
if err != nil || len(seeds) != 2 || seeds[0].Key != "giorgio canali" || seeds[1].Key != "pixies" || seeds[1].Last.Unix() != 2000 {
t.Errorf("Seeds = %+v, %v, want the two heaviest, heaviest first", seeds, err)
}
arts, err := repo.Artists(ctx, u.ID, []string{"blur", "nobody"})
if err != nil || len(arts) != 1 || arts["blur"].Name != "Blur" {
t.Errorf("Artists = %+v, %v", arts, err)
}
links, err := repo.Neighbours(ctx, u.ID, []string{"blur"})
if err != nil || len(links) != 1 || links[0].A != "blur" || links[0].B != "pixies" || links[0].Score != 0.5 {
t.Errorf("Neighbours(blur) = %+v, %v", links, err)
}
if links, _ := repo.Neighbours(ctx, u.ID, []string{"pixies"}); len(links) != 2 {
t.Errorf("Neighbours(pixies) = %+v, want both links, from either end", links)
}
if links, _ := repo.Neighbours(ctx, other.ID, []string{"pixies"}); len(links) != 0 {
t.Errorf("another person's links = %+v, want none", links)
}
if links, err := repo.Neighbours(ctx, u.ID, nil); err != nil || links != nil {
t.Errorf("Neighbours of nobody = %v, %v", links, err)
}
// Building again replaces it, and drops the kept play that has an event now.
if err := repo.Save(ctx, u.ID, at.Add(time.Hour), affinity.Model{Plays: 1}); err != nil {
t.Fatal(err)
}
if b, _, _ := repo.Build(ctx, u.ID); b.Artists != 0 || b.Links != 0 || b.Plays != 1 {
t.Errorf("Build after a smaller model = %+v", b)
}
if seeds, _ := repo.Seeds(ctx, u.ID, 10); len(seeds) != 0 {
t.Errorf("Seeds = %+v, want none after it was replaced", seeds)
}
if got := count(t, db, "SELECT COUNT(*) FROM outside_plays WHERE user_id = ?", u.ID); got != 1 {
t.Errorf("%d kept plays left, want 1 (the one that is a listening event was dropped)", got)
}
})
}
func TestLibraryArtistsSayWhichHaveMusicAndWishlistFindsOrMakesThem(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
ctx := context.Background()
u, err := NewUserRepo(db).CreateUser(ctx, "alice", "h", false)
if err != nil {
t.Fatal(err)
}
lib, err := NewLibraryRepo(db).CreateLibrary(ctx, "music", "/music")
if err != nil {
t.Fatal(err)
}
affinitySong(t, db, lib.ID, "a.flac", "Debaser", "Pixies")
if _, err := db.ExecContext(ctx, "INSERT INTO artists (name, name_key, search_key, discovered) VALUES ('Björk', 'björk', ?, ?)", SearchKey("Björk"), true); err != nil {
t.Fatal(err)
}
repo := NewAffinityRepo(db)
got, err := repo.LibraryArtists(ctx, []string{SearchKey("Pixies"), SearchKey("Björk"), "nobody"})
if err != nil {
t.Fatal(err)
}
if len(got) != 2 || !got[SearchKey("Pixies")].Playable || got[SearchKey("Pixies")].Name != "Pixies" || got[SearchKey("Björk")].Playable || got[SearchKey("Björk")].ID == 0 {
t.Errorf("LibraryArtists = %+v, want Pixies with music, Björk without, nobody not there", got)
}
// The artist that has the name is the one on the wishlist (also written without the accent) and none is made.
id, err := repo.Wishlist(ctx, u.ID, "Bjork", time.Unix(100, 0))
if err != nil || id != got[SearchKey("Björk")].ID {
t.Errorf("Wishlist(Bjork) = %d, %v, want the artist that exists (%d)", id, err, got[SearchKey("Björk")].ID)
}
// A new name makes an artist that nothing names but the mark, with no MusicBrainz id.
id2, err := repo.Wishlist(ctx, u.ID, " Giorgio Canali ", time.Unix(200, 0))
if err != nil || id2 == 0 {
t.Fatalf("Wishlist(new) = %d, %v", id2, err)
}
var name string
var mbidNull, discovered bool
if err := db.QueryRow("SELECT name, mbid IS NULL, discovered FROM artists WHERE id = ?", id2).Scan(&name, &mbidNull, &discovered); err != nil || name != "Giorgio Canali" || !mbidNull || !discovered {
t.Errorf("made artist = %q, no mbid %v, discovered %v, %v", name, mbidNull, discovered, err)
}
again, err := repo.Wishlist(ctx, u.ID, "Giorgio Canali", time.Unix(300, 0))
if err != nil || again != id2 {
t.Errorf("wishing again = %d, %v, want the same artist %d", again, err, id2)
}
var at int64
if err := db.QueryRow("SELECT created_at FROM artist_feedback WHERE user_id = ? AND artist_id = ?", u.ID, id2).Scan(&at); err != nil || at != 200 {
t.Errorf("mark date = %d, %v, want the first date 200", at, err)
}
if got := count(t, db, "SELECT COUNT(*) FROM artists WHERE search_key = ?", SearchKey("Giorgio Canali")); got != 1 {
t.Errorf("%d artists named Canali, want 1", got)
}
if _, err := repo.Wishlist(ctx, 999999, "Whoever", time.Unix(1, 0)); err == nil {
t.Error("a wish of a person that does not exist was accepted")
}
})
}