sonda/internal/affinity/service_test.go
tgiachi 7c961028bb feat(discover): suggestions learned from my own listening
A new model (internal/affinity) splits my listening into sittings (plays less
than 30 minutes apart) and links the artists that are often played in the same
sitting. It is built from my listening events and from the plays of artists I
have no music of that an import kept, on my server, with no provider, and is
built again when plays are added (migration 0032 keeps it as a cache).

GET /me/suggestions gives two lists, each artist with the artists it goes
with: the ones I have and did not play for two months, and the ones I played
at least three times and have no music of. It needs discover_from_listening.
POST /me/suggestions/wishlist puts an artist I played on my wishlist by name.
Discover has a "From your listening" tab for both lists.
2026-11-15 11:09:19 +01:00

302 lines
9.4 KiB
Go

package affinity
import (
"context"
"errors"
"sort"
"testing"
"time"
"codeberg.org/squidd/sonda/internal/feedback"
"codeberg.org/squidd/sonda/internal/usersettings"
)
var now = time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)
// memStore keeps the model in memory and counts how often it is built.
type memStore struct {
plays []Play
model Model
built Built
has bool
reads int
}
func (m *memStore) Plays(context.Context, int64, time.Duration) ([]Play, error) {
m.reads++
return m.plays, nil
}
func (m *memStore) PlayCount(context.Context, int64, time.Duration) (int, error) {
return len(m.plays), nil
}
func (m *memStore) Save(_ context.Context, _ int64, at time.Time, model Model) error {
m.model, m.has = model, true
m.built = Built{BuiltAt: at, Plays: model.Plays, Sessions: model.Sessions, Artists: len(model.Artists), Links: len(model.Links)}
return nil
}
func (m *memStore) Build(context.Context, int64) (Built, bool, error) { return m.built, m.has, nil }
func (m *memStore) Seeds(_ context.Context, _ int64, limit int) ([]Artist, error) {
out := append([]Artist(nil), m.model.Artists...)
sort.Slice(out, func(i, j int) bool {
if out[i].Weight != out[j].Weight {
return out[i].Weight > out[j].Weight
}
return out[i].Key < out[j].Key
})
return out[:min(limit, len(out))], nil
}
func (m *memStore) Artists(_ context.Context, _ int64, keys []string) (map[string]Artist, error) {
out := map[string]Artist{}
for _, a := range m.model.Artists {
for _, k := range keys {
if a.Key == k {
out[k] = a
}
}
}
return out, nil
}
func (m *memStore) Neighbours(_ context.Context, _ int64, keys []string) ([]Link, error) {
var out []Link
for _, l := range m.model.Links {
for _, k := range keys {
if l.A == k || l.B == k {
out = append(out, l)
break
}
}
}
return out, nil
}
type fakeLibrary map[string]LibraryArtist
func (f fakeLibrary) LibraryArtists(_ context.Context, keys []string) (map[string]LibraryArtist, error) {
out := map[string]LibraryArtist{}
for _, k := range keys {
if a, ok := f[k]; ok {
out[k] = a
}
}
return out, nil
}
type fakeMarks map[int64]feedback.Kind
func (f fakeMarks) Marks(context.Context, int64) (map[int64]feedback.Kind, error) { return f, nil }
type fakeWishes struct {
names []string
id int64
}
func (f *fakeWishes) Wishlist(_ context.Context, _ int64, name string, _ time.Time) (int64, error) {
f.names = append(f.names, name)
return f.id, nil
}
type fakeSettings struct{ on bool }
func (f fakeSettings) Get(context.Context, int64) (usersettings.Settings, error) {
return usersettings.Settings{DiscoverFromListening: f.on}, nil
}
// ago is a moment this many days before now, and the sitting of artists played one after the other from there.
func ago(days int, artists ...string) []Play {
var out []Play
for i, a := range artists {
out = append(out, Play{Key: a, Name: a, At: now.AddDate(0, 0, -days).Add(time.Duration(i) * time.Minute)})
}
return out
}
type rig struct {
svc *Service
store *memStore
wishes *fakeWishes
marks fakeMarks
}
// newRig plays out this history: three old sittings of radiohead, pixies and canali; two recent ones of radiohead and
// placebo; one play of an artist met once. pixies and placebo are in the library, canali and oneoff are not.
func newRig(on bool) rig {
var plays []Play
for _, d := range []int{200, 199, 198} {
plays = append(plays, ago(d, "radiohead", "pixies", "canali")...)
}
for _, d := range []int{10, 9} {
plays = append(plays, ago(d, "radiohead", "placebo")...)
}
plays = append(plays, ago(150, "oneoff")...)
store := &memStore{plays: plays}
lib := fakeLibrary{
"radiohead": {ID: 1, Name: "Radiohead", Playable: true},
"pixies": {ID: 2, Name: "Pixies", Playable: true},
"placebo": {ID: 3, Name: "Placebo", Playable: true},
}
wishes := &fakeWishes{id: 77}
marks := fakeMarks{}
svc := NewService(store, lib, marks, wishes, fakeSettings{on}, 20*time.Second)
svc.now = func() time.Time { return now }
return rig{svc, store, wishes, marks}
}
func names(in []Suggestion) []string {
out := []string{}
for _, s := range in {
out = append(out, s.Name)
}
return out
}
func equal(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
func TestSuggestionsNeedTheListenerToAllowListening(t *testing.T) {
r := newRig(false)
if _, err := r.svc.Suggest(context.Background(), 1, 0); !errors.Is(err, ErrNotAllowed) {
t.Fatalf("err = %v, want ErrNotAllowed", err)
}
if r.store.reads != 0 {
t.Error("a refused request read the plays")
}
if _, err := r.svc.AddToWishlist(context.Background(), 1, "canali"); !errors.Is(err, ErrNotAllowed) {
t.Errorf("wishlist err = %v, want ErrNotAllowed", err)
}
}
func TestTheLibraryListHasTheArtistsThatGoWithWhatIsPlayedAndWereNotPlayedLately(t *testing.T) {
r := newRig(true)
got, err := r.svc.Suggest(context.Background(), 1, 0)
if err != nil {
t.Fatal(err)
}
// placebo goes with radiohead too, but it was played ten days ago; radiohead itself was too.
if !equal(names(got.Library), []string{"Pixies"}) {
t.Fatalf("library = %v, want only Pixies", names(got.Library))
}
p := got.Library[0]
if p.ArtistID != 2 || p.Score != 1 || p.Plays != 3 || !p.LastPlayed.Equal(now.AddDate(0, 0, -198).Add(time.Minute)) {
t.Errorf("Pixies = %+v", p)
}
if len(p.Because) == 0 || p.Because[0].Name == "Pixies" {
t.Errorf("because = %+v, want the artists it goes with", p.Because)
}
}
func TestTheMissingListHasTheArtistsPlayedThatAreNotInTheLibrary(t *testing.T) {
r := newRig(true)
got, err := r.svc.Suggest(context.Background(), 1, 0)
if err != nil {
t.Fatal(err)
}
// oneoff was played once: not worth getting. Radiohead, Pixies and Placebo are in the library.
if !equal(names(got.Missing), []string{"canali"}) {
t.Fatalf("missing = %v, want only canali", names(got.Missing))
}
c := got.Missing[0]
if c.ArtistID != 0 || c.Wishlisted || c.Plays != 3 || c.Score <= 0 || c.Score > 1 {
t.Errorf("canali = %+v", c)
}
}
func TestAMissingArtistThatIsOnTheWishlistSaysSoAndOneNotWantedIsLeftOut(t *testing.T) {
r := newRig(true)
lib := fakeLibrary{
"radiohead": {ID: 1, Name: "Radiohead", Playable: true},
"pixies": {ID: 2, Name: "Pixies", Playable: true},
"canali": {ID: 9, Name: "Giorgio Canali", Playable: false}, // a row without music
}
r.svc.library = lib
r.marks[9] = feedback.Wishlist
got, _ := r.svc.Suggest(context.Background(), 1, 0)
if len(got.Missing) != 1 || got.Missing[0].ArtistID != 9 || !got.Missing[0].Wishlisted || got.Missing[0].Name != "Giorgio Canali" {
t.Fatalf("missing = %+v, want the row 9 on the wishlist", got.Missing)
}
r.marks[9] = feedback.Dismissed
r.marks[2] = feedback.Dismissed
got, _ = r.svc.Suggest(context.Background(), 1, 0)
if len(got.Missing) != 0 || len(got.Library) != 0 {
t.Errorf("after dismissing: library %v, missing %v, want nothing", names(got.Library), names(got.Missing))
}
}
func TestTheModelIsBuiltOnceAndAgainWhenPlaysAreAdded(t *testing.T) {
r := newRig(true)
ctx := context.Background()
for i := 0; i < 3; i++ {
if _, err := r.svc.Suggest(ctx, 1, 0); err != nil {
t.Fatal(err)
}
}
if r.store.reads != 1 {
t.Fatalf("plays read %d times for three requests, want 1", r.store.reads)
}
// A few plays, soon after: the model is left alone.
r.store.plays = append(r.store.plays, ago(0, "radiohead")...)
r.svc.now = func() time.Time { return now.Add(time.Minute) }
_, _ = r.svc.Suggest(ctx, 1, 0)
if r.store.reads != 1 {
t.Errorf("read %d times after one new play a minute later, want 1", r.store.reads)
}
// The same, but the model is old now.
r.svc.now = func() time.Time { return now.Add(time.Hour) }
_, _ = r.svc.Suggest(ctx, 1, 0)
if r.store.reads != 2 {
t.Errorf("read %d times after an hour, want 2", r.store.reads)
}
// An import adds many at once: at once.
for i := 0; i < bigChange; i++ {
r.store.plays = append(r.store.plays, ago(300+i, "radiohead", "pixies")...)
}
_, _ = r.svc.Suggest(ctx, 1, 0)
if r.store.reads != 3 {
t.Errorf("read %d times after a big import, want 3", r.store.reads)
}
}
func TestTheLimitIsAppliedAndBadOnesRefused(t *testing.T) {
r := newRig(true)
if _, err := r.svc.Suggest(context.Background(), 1, -1); !errors.Is(err, ErrInvalidLimit) {
t.Errorf("err = %v, want ErrInvalidLimit", err)
}
got, err := r.svc.Suggest(context.Background(), 1, 1)
if err != nil || len(got.Library) > 1 || len(got.Missing) > 1 {
t.Errorf("limit 1 = %v, %v", got, err)
}
}
func TestNoPlaysGiveEmptyListsAndNotNull(t *testing.T) {
r := newRig(true)
r.store.plays = nil
got, err := r.svc.Suggest(context.Background(), 1, 0)
if err != nil || got.Library == nil || got.Missing == nil || len(got.Library)+len(got.Missing) != 0 {
t.Errorf("got %+v, %v, want two empty lists", got, err)
}
}
func TestOnlyAnArtistThatWasPlayedGoesOnTheWishlist(t *testing.T) {
r := newRig(true)
ctx := context.Background()
// The model is built by the wish itself when no request for suggestions did it.
if _, err := r.svc.AddToWishlist(ctx, 1, "nobody I played"); !errors.Is(err, ErrUnknownArtist) {
t.Errorf("err = %v, want ErrUnknownArtist", err)
}
if _, err := r.svc.AddToWishlist(ctx, 1, " "); !errors.Is(err, ErrUnknownArtist) {
t.Errorf("a blank name: %v, want ErrUnknownArtist", err)
}
id, err := r.svc.AddToWishlist(ctx, 1, "canali")
if err != nil || id != 77 || len(r.wishes.names) != 1 || r.wishes.names[0] != "canali" {
t.Errorf("AddToWishlist = %d, %v, names %v", id, err, r.wishes.names)
}
}