sonda/internal/discover/service_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

942 lines
31 KiB
Go

package discover
import (
"context"
"errors"
"sync"
"sync/atomic"
"testing"
"time"
"git.kmalloc.org/squid/sonda/internal/discovery"
"git.kmalloc.org/squid/sonda/internal/feedback"
"git.kmalloc.org/squid/sonda/internal/providers"
"git.kmalloc.org/squid/sonda/internal/taste"
"git.kmalloc.org/squid/sonda/internal/usersettings"
)
type fakeTaste struct {
mu sync.Mutex // Discovers of several listeners run together
learned taste.Learned
err error
user int64
calls int
}
func (f *fakeTaste) Learn(_ context.Context, userID int64) (taste.Learned, error) {
f.mu.Lock()
defer f.mu.Unlock()
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 {
mu sync.Mutex // Discovers of several listeners run together
marks map[int64]feedback.Kind
err error
user int64
}
func (f *fakeMarks) Marks(_ context.Context, userID int64) (map[int64]feedback.Kind, error) {
f.mu.Lock()
defer f.mu.Unlock()
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)
}
}
// ---- how many Discovers run ----
// waitCalled waits until the providers were asked n times: that many Discovers are running.
func waitCalled(t *testing.T, f *fakeSimilar, n int) {
t.Helper()
deadline := time.Now().Add(2 * time.Second)
for len(f.called()) < n {
if time.Now().After(deadline) {
t.Fatalf("the providers were asked %d times, want %d", len(f.called()), n)
}
time.Sleep(2 * time.Millisecond)
}
}
func TestAListenerHasOneDiscoverAtATime(t *testing.T) {
r := newRig()
r.similar.delay = 150 * time.Millisecond
first := make(chan error, 1)
go func() { _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); first <- err }()
waitCalled(t, r.similar, 1)
start := time.Now()
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); !errors.Is(err, ErrBusy) {
t.Errorf("a second one of the same listener: err = %v, want ErrBusy", err)
}
if time.Since(start) > 50*time.Millisecond {
t.Errorf("a refused one waited %v", time.Since(start))
}
if _, err := r.svc.Discover(context.Background(), 8, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("another listener is not held up: %v", err)
}
if err := <-first; err != nil {
t.Fatal(err)
}
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("after the first ended: %v", err)
}
}
func TestOnlyAFewDiscoversRunAtTheSameTimeAndTheRestWait(t *testing.T) {
r := newRig()
r.similar.delay = 40 * time.Millisecond
var wg sync.WaitGroup
for user := int64(1); user <= 9; user++ {
wg.Add(1)
go func() {
defer wg.Done()
if _, err := r.svc.Discover(context.Background(), user, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("listener %d: %v", user, err)
}
}()
}
wg.Wait()
// One seed means one provider request for each Discover, so this is how many ran together.
if m := atomic.LoadInt32(&r.similar.maxSeen); m > MaxConcurrent || m < 2 {
t.Errorf("%d Discovers ran together, want at most %d (and more than one)", m, MaxConcurrent)
}
if n := len(r.similar.called()); n != 9 {
t.Errorf("the providers were asked %d times, want 9: all of them were done", n)
}
}
func TestAListenerWhoLeavesWhileWaitingForATurnDoesNoWorkAndKeepsNoPlace(t *testing.T) {
r := newRig()
r.similar.delay = 250 * time.Millisecond
var wg sync.WaitGroup
for user := int64(1); user <= MaxConcurrent; user++ {
wg.Add(1)
go func() {
defer wg.Done()
_, _ = r.svc.Discover(context.Background(), user, Query{Seeds: []int64{1}})
}()
}
waitCalled(t, r.similar, MaxConcurrent)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
defer cancel()
start := time.Now()
if _, err := r.svc.Discover(ctx, 50, Query{Seeds: []int64{1}}); !errors.Is(err, context.DeadlineExceeded) {
t.Errorf("err = %v, want the deadline of the request", err)
}
if time.Since(start) > 150*time.Millisecond {
t.Errorf("it waited %v for a turn it gave up", time.Since(start))
}
wg.Wait()
if n := len(r.similar.called()); n != MaxConcurrent {
t.Errorf("the providers were asked %d times: the one that left did work", n)
}
// Neither a turn nor the place of that listener was kept.
r.similar.delay = 0
if _, err := r.svc.Discover(context.Background(), 50, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("the listener who left cannot come back: %v", err)
}
}
func TestADiscoverThatFailsFreesTheListenerAndTheTurn(t *testing.T) {
r := newRig()
for i := 0; i < 3*MaxConcurrent; i++ {
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{99999}}); !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("round %d: err = %v, want ErrInvalidQuery and never ErrBusy", i, err)
}
}
r.taste.err = errors.New("boom")
for i := 0; i < 3*MaxConcurrent; i++ {
if _, err := r.svc.Discover(context.Background(), int64(i), Query{Seeds: []int64{1}}); errors.Is(err, ErrBusy) {
t.Fatalf("round %d: busy after a failure", i)
}
}
r.taste.err = nil
if _, err := r.svc.Discover(context.Background(), 7, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("after the failures: %v", err)
}
}
func TestARequestThatIsRefusedForWhatItAsksDoesNotWaitForATurn(t *testing.T) {
r := newRig()
r.similar.delay = 300 * time.Millisecond
var wg sync.WaitGroup
for user := int64(1); user <= MaxConcurrent; user++ {
wg.Add(1)
go func() {
defer wg.Done()
_, _ = r.svc.Discover(context.Background(), user, Query{Seeds: []int64{1}})
}()
}
waitCalled(t, r.similar, MaxConcurrent)
start := time.Now()
if _, err := r.svc.Discover(context.Background(), 50, Query{Seeds: []int64{99999}}); !errors.Is(err, ErrInvalidQuery) {
t.Errorf("a seed that is not an artist: %v", err)
}
if _, err := r.svc.Discover(context.Background(), 50, Query{}); !errors.Is(err, ErrSeedRequired) { // listening not allowed
t.Errorf("no seed and no permission: %v", err)
}
if time.Since(start) > 100*time.Millisecond {
t.Errorf("refusals took %v: they waited for a turn that they do not need", time.Since(start))
}
// And that listener is not "busy" because of them.
wg.Wait()
r.similar.delay = 0
if _, err := r.svc.Discover(context.Background(), 50, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("the listener was held back by its own refusals: %v", err)
}
}
func TestWaitingForATurnHasAnEndAndTheAnswerIsBusy(t *testing.T) {
r := newRig()
r.svc.turnWait = 40 * time.Millisecond
r.similar.delay = 300 * time.Millisecond
var wg sync.WaitGroup
for user := int64(1); user <= MaxConcurrent; user++ {
wg.Add(1)
go func() {
defer wg.Done()
_, _ = r.svc.Discover(context.Background(), user, Query{Seeds: []int64{1}})
}()
}
waitCalled(t, r.similar, MaxConcurrent)
start := time.Now()
if _, err := r.svc.Discover(context.Background(), 50, Query{Seeds: []int64{1}}); !errors.Is(err, ErrBusy) {
t.Errorf("err = %v, want ErrBusy after the wait", err)
}
if el := time.Since(start); el < 30*time.Millisecond || el > 200*time.Millisecond {
t.Errorf("it waited %v, want about the time allowed", el)
}
wg.Wait()
r.similar.delay = 0
if _, err := r.svc.Discover(context.Background(), 50, Query{Seeds: []int64{1}}); err != nil {
t.Errorf("no place was kept by the one who gave up: %v", err)
}
}