- 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
764 lines
25 KiB
Go
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)
|
|
}
|
|
}
|