- 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
134 lines
3.7 KiB
Go
134 lines
3.7 KiB
Go
package feedback
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type fakeStore struct {
|
|
marks map[[2]int64]Kind
|
|
known map[int64]bool
|
|
user map[int64]bool
|
|
listErr error
|
|
last struct{ limit, offset int }
|
|
}
|
|
|
|
func newFake() *fakeStore {
|
|
return &fakeStore{marks: map[[2]int64]Kind{}, known: map[int64]bool{10: true, 11: true}, user: map[int64]bool{1: true, 2: true}}
|
|
}
|
|
|
|
func (f *fakeStore) Mark(_ context.Context, u, a int64, k Kind, _ time.Time) error {
|
|
if !f.user[u] {
|
|
return ErrUserNotFound
|
|
}
|
|
if !f.known[a] {
|
|
return ErrArtistNotFound
|
|
}
|
|
f.marks[[2]int64{u, a}] = k
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeStore) Unmark(_ context.Context, u, a int64, k Kind) error {
|
|
if !f.known[a] {
|
|
return ErrArtistNotFound
|
|
}
|
|
if f.marks[[2]int64{u, a}] == k {
|
|
delete(f.marks, [2]int64{u, a})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeStore) List(_ context.Context, _ int64, _ Kind, limit, offset int) ([]Entry, int, error) {
|
|
f.last.limit, f.last.offset = limit, offset
|
|
return []Entry{}, 0, f.listErr
|
|
}
|
|
|
|
func (f *fakeStore) Marks(context.Context, int64) (map[int64]Kind, error) { return nil, nil }
|
|
|
|
func TestAddAndRemoveNeedARealArtist(t *testing.T) {
|
|
s := NewService(newFake())
|
|
ctx := context.Background()
|
|
if err := s.Add(ctx, 1, 10, Wishlist); err != nil {
|
|
t.Fatalf("Add: %v", err)
|
|
}
|
|
if err := s.Add(ctx, 1, 99, Wishlist); !errors.Is(err, ErrArtistNotFound) {
|
|
t.Errorf("Add unknown: %v", err)
|
|
}
|
|
for _, id := range []int64{0, -3} {
|
|
if err := s.Add(ctx, 1, id, Wishlist); !errors.Is(err, ErrArtistNotFound) {
|
|
t.Errorf("Add %d: %v", id, err)
|
|
}
|
|
if err := s.Remove(ctx, 1, id, Wishlist); !errors.Is(err, ErrArtistNotFound) {
|
|
t.Errorf("Remove %d: %v", id, err)
|
|
}
|
|
}
|
|
if err := s.Remove(ctx, 1, 10, Wishlist); err != nil {
|
|
t.Errorf("Remove: %v", err)
|
|
}
|
|
if err := s.Remove(ctx, 1, 10, Wishlist); err != nil {
|
|
t.Errorf("Remove again must be fine: %v", err)
|
|
}
|
|
if err := s.Remove(ctx, 1, 99, Wishlist); !errors.Is(err, ErrArtistNotFound) {
|
|
t.Errorf("Remove unknown: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestOnlyTheTwoKindsExist(t *testing.T) {
|
|
s := NewService(newFake())
|
|
if err := s.Add(context.Background(), 1, 10, Kind("favourite")); !errors.Is(err, ErrInvalidKind) {
|
|
t.Errorf("Add: %v", err)
|
|
}
|
|
if err := s.Remove(context.Background(), 1, 10, Kind("")); !errors.Is(err, ErrInvalidKind) {
|
|
t.Errorf("Remove: %v", err)
|
|
}
|
|
if _, err := s.List(context.Background(), 1, Kind("x"), Page{}); !errors.Is(err, ErrInvalidKind) {
|
|
t.Errorf("List: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAWishlistIsPerUserAndAnAddReplacesTheOtherKind(t *testing.T) {
|
|
f := newFake()
|
|
s := NewService(f)
|
|
ctx := context.Background()
|
|
_ = s.Add(ctx, 1, 10, Dismissed)
|
|
_ = s.Add(ctx, 1, 10, Wishlist)
|
|
if f.marks[[2]int64{1, 10}] != Wishlist {
|
|
t.Error("the new kind did not replace the old one")
|
|
}
|
|
if _, ok := f.marks[[2]int64{2, 10}]; ok {
|
|
t.Error("another user got the mark")
|
|
}
|
|
if err := s.Add(ctx, 7, 10, Wishlist); !errors.Is(err, ErrUserNotFound) {
|
|
t.Errorf("a deleted account: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestListPaging(t *testing.T) {
|
|
f := newFake()
|
|
s := NewService(f)
|
|
ctx := context.Background()
|
|
for name, tt := range map[string]struct {
|
|
in Page
|
|
limit, off int
|
|
bad bool
|
|
}{
|
|
"defaults": {Page{}, DefaultLimit, 0, false},
|
|
"explicit": {Page{Limit: 5, Offset: 10}, 5, 10, false},
|
|
"too big": {Page{Limit: 100000}, MaxLimit, 0, false},
|
|
"neg limit": {Page{Limit: -1}, 0, 0, true},
|
|
"neg offset": {Page{Offset: -1}, 0, 0, true},
|
|
} {
|
|
page, err := s.List(ctx, 1, Wishlist, tt.in)
|
|
if tt.bad {
|
|
if !errors.Is(err, ErrInvalidQuery) {
|
|
t.Errorf("%s: err = %v", name, err)
|
|
}
|
|
continue
|
|
}
|
|
if err != nil || f.last.limit != tt.limit || f.last.offset != tt.off || page.Limit != tt.limit || page.Offset != tt.off {
|
|
t.Errorf("%s: asked %+v, page %+v, err %v", name, f.last, page, err)
|
|
}
|
|
}
|
|
}
|