sonda/internal/discover/service_test.go
tgiachi a6dbf60ac8 feat(feedback): a wishlist and "not interested"
- PUT/DELETE /wishlist/{artist} and GET /wishlist: the artists I want.
- POST/DELETE /discover/{artist}/dismiss and GET /discover/dismissed: the
  artists I am not interested in. An artist is wished or dismissed, never both,
  and both lists are mine alone.
- Discover never suggests a dismissed artist, does not use one as a seed taken
  from my listening, and marks the wished ones it shows (wishlisted).
- New artist_feedback table (migration 0012, SQLite and PostgreSQL), removed
  with the account.
- An artist I marked is not cleaned up when the list that named it is replaced,
  and goes when its last mark is taken off and nobody names it. Taking a
  provider's data back still removes what only it named, marks included.
- Spec, contract test and README updated.

Closes #35
2026-11-11 20:11:18 +01:00

764 lines
25 KiB
Go

package discover
import (
"context"
"errors"
"sync"
"sync/atomic"
"testing"
"time"
"codeberg.org/squidd/sonda/internal/discovery"
"codeberg.org/squidd/sonda/internal/feedback"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/taste"
"codeberg.org/squidd/sonda/internal/usersettings"
)
type fakeTaste struct {
learned taste.Learned
err error
user int64
calls int
}
func (f *fakeTaste) Learn(_ context.Context, userID int64) (taste.Learned, error) {
f.calls++
f.user = userID
return f.learned, f.err
}
type fakeSimilar struct {
mu sync.Mutex
lists map[int64]discovery.Result
errs map[int64]error
calls []int64
inFlight int32
maxSeen int32
delay time.Duration
}
func (f *fakeSimilar) Similar(ctx context.Context, id int64, limit int) (discovery.Result, error) {
n := atomic.AddInt32(&f.inFlight, 1)
defer atomic.AddInt32(&f.inFlight, -1)
for {
m := atomic.LoadInt32(&f.maxSeen)
if n <= m || atomic.CompareAndSwapInt32(&f.maxSeen, m, n) {
break
}
}
f.mu.Lock()
f.calls = append(f.calls, id)
res, err := f.lists[id], f.errs[id]
f.mu.Unlock()
if f.delay > 0 {
select {
case <-time.After(f.delay):
case <-ctx.Done():
return discovery.Result{}, ctx.Err()
}
}
if res.ProviderStatus == "" {
res.ProviderStatus = discovery.StatusOK
}
return res, err
}
func (f *fakeSimilar) called() []int64 {
f.mu.Lock()
defer f.mu.Unlock()
return append([]int64(nil), f.calls...)
}
// fakeStore holds names and stored tags; the tag fetcher writes into it, like the
// real one saves into the database.
type fakeStore struct {
mu sync.Mutex
names map[int64]string
tags map[int64]map[string]float64
}
func (f *fakeStore) ArtistNames(_ context.Context, ids []int64) (map[int64]string, error) {
f.mu.Lock()
defer f.mu.Unlock()
out := map[int64]string{}
for _, id := range ids {
if n, ok := f.names[id]; ok {
out[id] = n
}
}
return out, nil
}
func (f *fakeStore) ArtistTags(_ context.Context, ids []int64) (map[int64]map[string]float64, error) {
f.mu.Lock()
defer f.mu.Unlock()
out := map[int64]map[string]float64{}
for _, id := range ids {
if t := f.tags[id]; len(t) > 0 {
out[id] = t
}
}
return out, nil
}
type fakeFetcher struct {
store *fakeStore
gives map[int64]map[string]float64 // what Last.fm would say, by artist
status string
err error
mu sync.Mutex
calls []int64
prov []string
}
func (f *fakeFetcher) ProviderTags(_ context.Context, id int64, provider string) (discovery.TagSourceResult, error) {
f.mu.Lock()
f.calls = append(f.calls, id)
f.prov = append(f.prov, provider)
f.mu.Unlock()
if f.err != nil {
return discovery.TagSourceResult{}, f.err
}
if t := f.gives[id]; len(t) > 0 {
f.store.mu.Lock()
f.store.tags[id] = t
f.store.mu.Unlock()
}
st := f.status
if st == "" {
st = discovery.StatusOK
}
return discovery.TagSourceResult{Provider: provider, Status: st}, nil
}
func (f *fakeFetcher) called() []int64 {
f.mu.Lock()
defer f.mu.Unlock()
return append([]int64(nil), f.calls...)
}
type fakeSettings struct {
on bool
err error
}
func (f fakeSettings) Get(context.Context, int64) (usersettings.Settings, error) {
return usersettings.Settings{DiscoverFromListening: f.on}, f.err
}
type fakeMarks struct {
marks map[int64]feedback.Kind
err error
user int64
}
func (f *fakeMarks) Marks(_ context.Context, userID int64) (map[int64]feedback.Kind, error) {
f.user = userID
return f.marks, f.err
}
type rig struct {
marks *fakeMarks
svc *Service
taste *fakeTaste
similar *fakeSimilar
store *fakeStore
fetch *fakeFetcher
set *fakeSettings
}
func item(id int64, name string, rank int, score float64, inLib bool) discovery.Item {
return discovery.Item{Artist: discovery.ArtistRef{ID: id, Name: name}, InLibrary: inLib, Score: score, Rank: rank}
}
// newRig has seeds 1 (Seed One) and 2 (Seed Two), candidates 10 to 13, and a
// listener who likes "rock". Artist 1 is liked (0.8), 2 is not heard at all.
func newRig() *rig {
r := &rig{
taste: &fakeTaste{learned: taste.Learned{
Prefs: map[int64]taste.ArtistPref{1: {ArtistID: 1, Preference: 0.8, Score: 2, Listens: 5}, 12: {ArtistID: 12, Preference: 0.5, Score: 1, Listens: 3}},
Liked: []taste.ArtistPref{{ArtistID: 1, Preference: 0.8, Score: 2, Listens: 5}, {ArtistID: 12, Preference: 0.5, Score: 1, Listens: 3}},
Tags: []taste.TagWeight{{Tag: "rock", Weight: 1}},
}},
similar: &fakeSimilar{lists: map[int64]discovery.Result{
1: {Items: []discovery.Item{item(10, "Ten", 1, 1, false), item(11, "Eleven", 2, 0.5, false), item(12, "Twelve", 3, 0.4, true), item(2, "Seed Two", 4, 0.3, true)}},
2: {Items: []discovery.Item{item(10, "Ten", 1, 1, false), item(13, "Thirteen", 2, 0.8, false)}},
}, errs: map[int64]error{}},
store: &fakeStore{
names: map[int64]string{1: "Seed One", 2: "Seed Two", 10: "Ten", 11: "Eleven", 12: "Twelve", 13: "Thirteen"},
tags: map[int64]map[string]float64{10: {"rock": 1}, 11: {"jazz": 1}},
},
set: &fakeSettings{},
marks: &fakeMarks{marks: map[int64]feedback.Kind{}},
}
r.fetch = &fakeFetcher{store: r.store, gives: map[int64]map[string]float64{13: {"rock": 0.5, "pop": 1}}}
r.svc = NewService(r.taste, r.similar, r.fetch, r.store, r.set, r.marks, DefaultWeights())
return r
}
func ids(items []Item) []int64 {
var out []int64
for _, it := range items {
out = append(out, it.Artist.ID)
}
return out
}
func find(t *testing.T, res Result, id int64) Item {
t.Helper()
for _, it := range res.Items {
if it.Artist.ID == id {
return it
}
}
t.Fatalf("artist %d is not in the answer: %v", id, ids(res.Items))
return Item{}
}
func TestDiscoverFromNamedSeedsNeedsNoSetting(t *testing.T) {
r := newRig() // the setting is off
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if err != nil {
t.Fatal(err)
}
if r.taste.user != 7 {
t.Errorf("learned user %d", r.taste.user)
}
if res.FromListening || len(res.Seeds) != 1 || res.Seeds[0].ID != 1 || res.Seeds[0].Name != "Seed One" || res.Seeds[0].Weight != 1 {
t.Errorf("seeds = %+v from listening %v, want Seed One at weight 1", res.Seeds, res.FromListening)
}
if got := r.similar.called(); len(got) != 1 || got[0] != 1 {
t.Errorf("similar lists asked for %v, want only the seed", got)
}
if res.ProviderStatus != discovery.StatusOK {
t.Errorf("status = %q", res.ProviderStatus)
}
// The seed itself is never a suggestion, and Seed Two (similar to One) is a candidate when it is not a seed.
for _, it := range res.Items {
if it.Artist.ID == 1 {
t.Error("a seed was suggested to itself")
}
}
if len(res.Items) != 4 {
t.Errorf("items = %v, want 10, 11, 12 and 2", ids(res.Items))
}
}
func TestDiscoverWithoutSeedsAndTheSettingOffIsRefusedAndAsksNobody(t *testing.T) {
r := newRig()
_, err := r.svc.Discover(context.Background(), 7, Query{})
if !errors.Is(err, ErrSeedRequired) {
t.Fatalf("err = %v, want ErrSeedRequired", err)
}
if len(r.similar.called())+len(r.fetch.called()) != 0 {
t.Error("a provider was asked although the listener did not allow it")
}
if r.taste.calls != 0 {
t.Error("the history was read for a request that was refused")
}
}
func TestDiscoverFromListeningUsesTheArtistsILikeWeightedByHowMuch(t *testing.T) {
r := newRig()
r.set.on = true
res, err := r.svc.Discover(context.Background(), 7, Query{})
if err != nil {
t.Fatal(err)
}
if !res.FromListening || len(res.Seeds) != 2 || res.Seeds[0].ID != 1 || res.Seeds[0].Weight != 0.8 || res.Seeds[1].ID != 12 || res.Seeds[1].Weight != 0.5 {
t.Errorf("seeds = %+v", res.Seeds)
}
if res.Seeds[0].Name != "Seed One" || res.Seeds[1].Name != "Twelve" {
t.Errorf("seed names = %+v", res.Seeds)
}
// Artist 10 is similar to seed 1 with match 1: A = 0.8 * 1.
if got := find(t, res, 10).Components.A; !near(got, 0.8) {
t.Errorf("A of artist 10 = %v, want 0.8", got)
}
// 12 is a seed, so it is not a candidate.
for _, it := range res.Items {
if it.Artist.ID == 12 || it.Artist.ID == 1 {
t.Errorf("seed %d came back as a candidate", it.Artist.ID)
}
}
}
func TestDiscoverFromListeningWithNothingListenedToIsEmptyAndAsksNobody(t *testing.T) {
r := newRig()
r.set.on = true
r.taste.learned = taste.Learned{Prefs: map[int64]taste.ArtistPref{}, Liked: []taste.ArtistPref{}, Tags: []taste.TagWeight{}}
res, err := r.svc.Discover(context.Background(), 7, Query{})
if err != nil || len(res.Items) != 0 || len(res.Seeds) != 0 || !res.FromListening {
t.Errorf("result = %+v err=%v", res, err)
}
if res.Items == nil || res.Seeds == nil {
t.Error("lists must be empty, not nil")
}
if len(r.similar.called()) != 0 {
t.Error("a provider was asked about nothing")
}
}
func TestNamedSeedsWinOverTheListening(t *testing.T) {
r := newRig()
r.set.on = true
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{2}})
if err != nil || res.FromListening || len(res.Seeds) != 1 || res.Seeds[0].ID != 2 {
t.Errorf("result = %+v err=%v", res, err)
}
}
func TestDiscoverUsesAtMostTwentySeedsFromListening(t *testing.T) {
r := newRig()
r.set.on = true
var liked []taste.ArtistPref
for id := int64(100); id < 140; id++ {
liked = append(liked, taste.ArtistPref{ArtistID: id, Preference: 0.5, Score: 1})
r.store.names[id] = "x"
}
r.taste.learned.Liked = liked
res, err := r.svc.Discover(context.Background(), 7, Query{})
if err != nil || len(res.Seeds) != MaxListeningSeeds || len(r.similar.called()) != MaxListeningSeeds {
t.Errorf("seeds %d, similar calls %d, want %d each (err %v)", len(res.Seeds), len(r.similar.called()), MaxListeningSeeds, err)
}
}
func TestSeveralSeedsReinforceACandidateAndSayWhy(t *testing.T) {
r := newRig()
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
ten := find(t, res, 10)
// Both seeds weigh 1 here and both match 1: A = 1.
if !near(ten.Components.A, 1) {
t.Errorf("A = %v, want 1", ten.Components.A)
}
if len(ten.Because) != 2 || ten.Because[0].Match != 1 {
t.Errorf("because = %+v", ten.Because)
}
if got := find(t, res, 11).Because; len(got) != 1 || got[0].Artist.ID != 1 || got[0].Artist.Name != "Seed One" || got[0].Match != 0.5 {
t.Errorf("because for 11 = %+v", got)
}
// Seed One and Seed Two are seeds: neither is suggested.
for _, it := range res.Items {
if it.Artist.ID == 1 || it.Artist.ID == 2 {
t.Errorf("seed %d suggested", it.Artist.ID)
}
}
}
func TestBecauseKeepsTheThreeStrongestSeeds(t *testing.T) {
r := newRig()
r.similar.lists = map[int64]discovery.Result{}
var seeds []int64
for i := int64(1); i <= 5; i++ {
seeds = append(seeds, i)
r.store.names[i] = "s"
r.similar.lists[i] = discovery.Result{Items: []discovery.Item{item(10, "Ten", 1, float64(i)/10, false)}}
}
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: seeds})
if err != nil {
t.Fatal(err)
}
got := find(t, res, 10).Because
if len(got) != 3 || got[0].Match != 0.5 || got[1].Match != 0.4 || got[2].Match != 0.3 {
t.Errorf("because = %+v, want the matches 0.5, 0.4, 0.3", got)
}
}
func TestPreferenceAndDiscoveryComeFromTheListening(t *testing.T) {
r := newRig()
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if err != nil {
t.Fatal(err)
}
// Artist 12 was played 3 times with preference 0.5; 11 never.
twelve, eleven := find(t, res, 12), find(t, res, 11)
if !near(twelve.Components.P, 0.75) || !near(twelve.Components.D, 0.25) {
t.Errorf("12: P=%v D=%v, want 0.75 and 0.25", twelve.Components.P, twelve.Components.D)
}
if !near(eleven.Components.P, 0.5) || !near(eleven.Components.D, 1) {
t.Errorf("11: P=%v D=%v, want 0.5 and 1", eleven.Components.P, eleven.Components.D)
}
}
func TestGenreComesFromTheTagsOfTheCandidate(t *testing.T) {
r := newRig()
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
if g := find(t, res, 10).Components.G; g == nil || !near(*g, 1) {
t.Errorf("G of 10 (rock) = %v, want 1", g)
}
if g := find(t, res, 11).Components.G; g == nil || *g != 0 {
t.Errorf("G of 11 (jazz) = %v, want 0", g)
}
}
func TestTagsAreFetchedOnlyForCandidatesWithNone_AndOnlyFromLastfm(t *testing.T) {
r := newRig()
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
// 10 and 11 have stored tags; 12 (in library, none stored), 13 (none stored) get asked.
got := map[int64]bool{}
for _, id := range r.fetch.called() {
got[id] = true
}
if got[10] || got[11] || !got[12] || !got[13] {
t.Errorf("fetched for %v, want only artists without tags", got)
}
for _, p := range r.fetch.prov {
if p != providers.LastFM {
t.Errorf("asked %q, want only Last.fm", p)
}
}
// What was fetched is used.
if g := find(t, res, 13).Components.G; g == nil || *g <= 0 {
t.Errorf("G of 13 = %v, want a value from the tags just read", g)
}
}
func TestAnArtistWithoutAnyTagsHasNoGenreAndIsScoredWithoutIt(t *testing.T) {
r := newRig()
r.fetch.gives = nil // Last.fm knows nothing about 12 and 13
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
thirteen := find(t, res, 13)
if thirteen.Components.G != nil {
t.Errorf("G = %v, want nil", *thirteen.Components.G)
}
want := Combine(thirteen.Components, DefaultWeights())
if !near(thirteen.Score, want) {
t.Errorf("score = %v, want %v (G left out)", thirteen.Score, want)
}
}
func TestWithoutAListenerProfileThereIsNoGenre(t *testing.T) {
r := newRig()
r.taste.learned.Tags = nil
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if err != nil {
t.Fatal(err)
}
for _, it := range res.Items {
if it.Components.G != nil {
t.Errorf("artist %d has a genre score without a profile to compare with", it.Artist.ID)
}
}
if len(r.fetch.called()) != 0 {
t.Error("tags were fetched although there is no profile to compare them with")
}
}
func TestAFailingTagFetchLeavesTheGenreOutAndNothingBreaks(t *testing.T) {
r := newRig()
r.fetch.err = errors.New("boom")
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatalf("err = %v, want the answer without those tags", err)
}
if find(t, res, 13).Components.G != nil {
t.Error("G of 13 should be unknown")
}
}
func TestScoreOrdersTheAnswerAndTiesGoToAffinityThenId(t *testing.T) {
r := newRig()
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
for i := 1; i < len(res.Items); i++ {
if res.Items[i-1].Score < res.Items[i].Score {
t.Errorf("not ordered by score: %v then %v", res.Items[i-1].Score, res.Items[i].Score)
}
}
// 10 is similar to both seeds with match 1 and likes rock: it must lead.
if res.Items[0].Artist.ID != 10 {
t.Errorf("first = %d, want 10", res.Items[0].Artist.ID)
}
for _, it := range res.Items {
if it.Score < 0 || it.Score > 1 {
t.Errorf("score %v out of range", it.Score)
}
}
}
func TestLimitsAndTheLibraryFilter(t *testing.T) {
r := newRig()
// Only in-library candidates of seed 1: 12 (and Seed Two, id 2).
yes, no := true, false
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, InLibrary: &yes})
if err != nil || len(res.Items) != 2 {
t.Fatalf("in library: %v err=%v", ids(res.Items), err)
}
for _, it := range res.Items {
if !it.InLibrary {
t.Errorf("artist %d is not in the library", it.Artist.ID)
}
}
if res, err = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, InLibrary: &no}); err != nil || len(res.Items) != 2 {
t.Fatalf("outside: %v err=%v", ids(res.Items), err)
}
if res, err = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, Limit: 1}); err != nil || len(res.Items) != 1 {
t.Fatalf("limit 1: %v err=%v", ids(res.Items), err)
}
if _, err = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, Limit: -1}); !errors.Is(err, ErrInvalidQuery) {
t.Errorf("negative limit: err = %v", err)
}
if res, err = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, Limit: 1000}); err != nil || len(res.Items) > MaxLimit {
t.Errorf("large limit: %d items err=%v", len(res.Items), err)
}
}
func TestSeedsMustBeFewDistinctAndKnown(t *testing.T) {
r := newRig()
for name, q := range map[string]Query{
"too many": {Seeds: []int64{1, 2, 3, 4, 5, 6}},
"unknown": {Seeds: []int64{999}},
"zero": {Seeds: []int64{0}},
"negative": {Seeds: []int64{-1}},
"one unknown": {Seeds: []int64{1, 999}},
} {
if _, err := r.svc.Discover(context.Background(), 7, q); !errors.Is(err, ErrInvalidQuery) {
t.Errorf("%s: err = %v, want ErrInvalidQuery", name, err)
}
}
if len(r.similar.called()) != 0 {
t.Error("a provider was asked although the request was refused")
}
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 1, 1}})
if err != nil || len(res.Seeds) != 1 || len(r.similar.called()) != 1 {
t.Errorf("the same seed three times: %d seeds, %d calls, err %v", len(res.Seeds), len(r.similar.called()), err)
}
}
func TestProviderStatusSaysWhatHappened(t *testing.T) {
r := newRig()
r.similar.lists[1] = discovery.Result{ProviderStatus: discovery.StatusDisabled, Items: r.similar.lists[1].Items}
res, _ := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if res.ProviderStatus != discovery.StatusDisabled || len(res.Items) == 0 {
t.Errorf("status %q with %d items: stored data must still be used", res.ProviderStatus, len(res.Items))
}
r = newRig()
r.similar.lists[2] = discovery.Result{ProviderStatus: discovery.StatusError, Items: r.similar.lists[2].Items}
if res, _ = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}}); res.ProviderStatus != discovery.StatusError {
t.Errorf("status = %q, want error when any seed failed", res.ProviderStatus)
}
r = newRig()
r.similar.lists[1] = discovery.Result{ProviderStatus: discovery.StatusDisabled, Items: r.similar.lists[1].Items}
r.similar.lists[2] = discovery.Result{ProviderStatus: discovery.StatusError, Items: r.similar.lists[2].Items}
if res, _ = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}}); res.ProviderStatus != discovery.StatusDisabled {
t.Errorf("status = %q, want disabled to win over error", res.ProviderStatus)
}
}
func TestOneSeedThatCannotBeReadDoesNotSpoilTheOthers(t *testing.T) {
r := newRig()
r.similar.errs[1] = discovery.ErrNotFound // removed in the meantime
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
if len(res.Items) == 0 || find(t, res, 13).Artist.ID != 13 {
t.Errorf("items = %v", ids(res.Items))
}
// Other errors are real.
r = newRig()
boom := errors.New("boom")
r.similar.errs[1] = boom
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}}); !errors.Is(err, boom) {
t.Errorf("err = %v, want the store error", err)
}
}
func TestProvidersAreAskedFourAtATime(t *testing.T) {
r := newRig()
r.similar.delay = 20 * time.Millisecond
r.set.on = true
var liked []taste.ArtistPref
for id := int64(100); id < 112; id++ {
liked = append(liked, taste.ArtistPref{ArtistID: id, Preference: 0.5, Score: 1})
r.store.names[id] = "x"
}
r.taste.learned.Liked = liked
if _, err := r.svc.Discover(context.Background(), 7, Query{}); err != nil {
t.Fatal(err)
}
if m := atomic.LoadInt32(&r.similar.maxSeen); m < 2 || m > Parallelism {
t.Errorf("at most %d calls at once, saw %d (want several, up to %d)", Parallelism, m, Parallelism)
}
}
func TestAListenerWhoLeavesStopsTheWork(t *testing.T) {
r := newRig()
r.similar.delay = time.Second
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
defer cancel()
start := time.Now()
_, err := r.svc.Discover(ctx, 7, Query{Seeds: []int64{1, 2}})
if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > 500*time.Millisecond {
t.Errorf("err = %v after %v, want a prompt deadline error", err, time.Since(start))
}
}
func TestSettingsAndTasteErrorsPass(t *testing.T) {
boom := errors.New("boom")
r := newRig()
r.taste.err = boom
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); !errors.Is(err, boom) {
t.Errorf("taste: err = %v", err)
}
r = newRig()
r.set.err = boom
if _, err := r.svc.Discover(context.Background(), 7, Query{}); !errors.Is(err, boom) {
t.Errorf("settings: err = %v", err)
}
}
func TestASeedThatCannotBeReadIsNotListedAsASeed(t *testing.T) {
r := newRig()
r.similar.errs[1] = discovery.ErrNotFound
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1, 2}})
if err != nil {
t.Fatal(err)
}
if len(res.Seeds) != 1 || res.Seeds[0].ID != 2 {
t.Errorf("seeds = %+v, want only the one that gave something", res.Seeds)
}
}
func TestOnlyThePoolOfBestCandidatesIsScoredAndTaggedWhateverTheLimit(t *testing.T) {
r := newRig()
var items []discovery.Item
for i := 0; i < 50; i++ {
id := int64(200 + i)
items = append(items, item(id, "c", i+1, 1-float64(i)/100, false))
r.store.names[id] = "c"
}
r.similar.lists[1] = discovery.Result{Items: items}
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}, Limit: 3})
if err != nil || len(res.Items) != 3 {
t.Fatalf("items %d err %v", len(res.Items), err)
}
fetched := r.fetch.called()
if len(fetched) != minPool {
t.Errorf("tags fetched for %d candidates, want the pool of %d", len(fetched), minPool)
}
for _, id := range fetched {
if id >= 200+minPool {
t.Errorf("tags fetched for candidate %d, which is below the pool", id)
}
}
}
func TestTagsAreFetchedFourAtATimeAndStopWhenTheListenerLeaves(t *testing.T) {
r := newRig()
var items []discovery.Item
for i := 0; i < 20; i++ {
items = append(items, item(int64(300+i), "c", i+1, 0.5, false))
}
r.similar.lists[1] = discovery.Result{Items: items}
slow := &slowFetcher{delay: 20 * time.Millisecond}
r.svc = NewService(r.taste, r.similar, slow, r.store, r.set, r.marks, DefaultWeights())
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); err != nil {
t.Fatal(err)
}
if m := atomic.LoadInt32(&slow.maxSeen); m < 2 || m > Parallelism {
t.Errorf("at most %d tag requests at once, saw %d", Parallelism, m)
}
slow = &slowFetcher{delay: time.Second}
r.svc = NewService(r.taste, r.similar, slow, r.store, r.set, r.marks, DefaultWeights())
ctx, cancel := context.WithTimeout(context.Background(), 40*time.Millisecond)
defer cancel()
start := time.Now()
if _, err := r.svc.Discover(ctx, 7, Query{Seeds: []int64{1}}); !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > 500*time.Millisecond {
t.Errorf("err = %v after %v, want a prompt deadline error", err, time.Since(start))
}
}
type slowFetcher struct {
delay time.Duration
inFlight int32
maxSeen int32
}
func (f *slowFetcher) ProviderTags(ctx context.Context, id int64, provider string) (discovery.TagSourceResult, error) {
n := atomic.AddInt32(&f.inFlight, 1)
defer atomic.AddInt32(&f.inFlight, -1)
for {
m := atomic.LoadInt32(&f.maxSeen)
if n <= m || atomic.CompareAndSwapInt32(&f.maxSeen, m, n) {
break
}
}
select {
case <-time.After(f.delay):
case <-ctx.Done():
return discovery.TagSourceResult{}, ctx.Err()
}
return discovery.TagSourceResult{Provider: provider, Status: discovery.StatusOK}, nil
}
func TestADismissedArtistIsNeverSuggestedAndAWishedOneIsMarked(t *testing.T) {
r := newRig()
r.marks.marks = map[int64]feedback.Kind{10: feedback.Dismissed, 11: feedback.Wishlist}
res, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if err != nil {
t.Fatal(err)
}
if r.marks.user != 7 {
t.Errorf("marks of user %d were read", r.marks.user)
}
for _, it := range res.Items {
if it.Artist.ID == 10 {
t.Error("a dismissed artist was suggested")
}
}
if !find(t, res, 11).Wishlisted || find(t, res, 12).Wishlisted {
t.Error("only the artist on the wishlist must be marked as wished")
}
// A dismissed artist does not use up a place: the others still fill the answer.
if len(res.Items) != 3 {
t.Errorf("items = %v, want 11, 12 and 2", ids(res.Items))
}
}
func TestADismissedArtistIsNotASeedFromTheListeningButANamedOneIs(t *testing.T) {
r := newRig()
r.set.on = true
r.marks.marks = map[int64]feedback.Kind{1: feedback.Dismissed}
res, err := r.svc.Discover(context.Background(), 7, Query{})
if err != nil {
t.Fatal(err)
}
for _, sd := range res.Seeds {
if sd.ID == 1 {
t.Error("an artist the listener is not interested in seeded the suggestions")
}
}
// Named by the listener, it is a seed: they asked for it.
res, err = r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}})
if err != nil || len(res.Seeds) != 1 || res.Seeds[0].ID != 1 {
t.Errorf("named seed: %+v err=%v", res.Seeds, err)
}
}
func TestMarksErrorsPass(t *testing.T) {
r := newRig()
boom := errors.New("boom")
r.marks.err = boom
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); !errors.Is(err, boom) {
t.Errorf("err = %v", err)
}
}