- The gate now comes after what only the database decides (a seed that is not an artist, no seed and no permission), so those answers are not held up by three slow Discovers and do not make the listener "busy". - A request that waits more than 30 seconds for a turn answers 429 instead of hanging for as long as the providers are slow. - The spec and the README say that a waiting request counts as running.
942 lines
31 KiB
Go
942 lines
31 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 {
|
|
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)
|
|
}
|
|
}
|