feat(smart): smart playlists, playlists made of rules

A smart playlist is a set of rules, an order and a limit, kept under a name and worked out again every time it is opened.

- Rules (all that are set must hold): genres, artists and albums (is, or is not), file formats and a minimum bitrate of the same file, added in the last N days, never played, played or not played in the last N days, played at least N times, skipped or not skipped lately, only liked artists or without the avoided ones, and the length of the song.
- Orders: random (the same all day, a variant gives another), most played, least played, recently added, by title. A limit of 50 by default, 500 at most.
- GET/POST /smart-playlists, GET/PATCH/DELETE /smart-playlists/{id}, GET /smart-playlists/{id}/tracks, POST /smart-playlists/preview to try rules without keeping them, and POST /smart-playlists/{id}/playlist to keep what is shown as a normal playlist.
- Only the rules are stored (migration 0020); the songs come from the files and from the owner's own history and taste. Nothing is sent to a provider, and a smart playlist is its owner's alone. A user can have 200.
- Mixes and smart playlists share the way a list of songs becomes a playlist.
This commit is contained in:
tgiachi 2026-11-13 09:36:52 +01:00
commit 104e41d10a
14 changed files with 2620 additions and 18 deletions

View file

@ -29,6 +29,7 @@ import (
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/playlists"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/smart"
"codeberg.org/squidd/sonda/internal/storage"
"codeberg.org/squidd/sonda/internal/streaming"
"codeberg.org/squidd/sonda/internal/taste"
@ -108,6 +109,7 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
deps.Feedback = feedbackSvc
deps.Playlists = playlists.NewService(storage.NewPlaylistRepo(db))
deps.Mixes = mixes.NewService(storage.NewMixRepo(db), deps.Taste.(mixes.Taster), 20*time.Second)
deps.Smart = smart.NewService(storage.NewSmartRepo(db), deps.Taste.(smart.Taster), 20*time.Second)
imageRepo := storage.NewImageRepo(db)
imageSvc := images.NewService(filepath.Join(t.TempDir(), "data"), imageRepo, imageRepo)
deps.Images, deps.ArtistImages = imageSvc, imageSvc

View file

@ -824,6 +824,7 @@ func TestResponsesMatchTheSpec(t *testing.T) {
// ---- mixes ----
c.mixes(t, token, libID)
c.smartPlaylists(t, token)
// ---- every operation in the spec was exercised ----
var missing []string
@ -1026,3 +1027,41 @@ func (c *contract) mixes(t *testing.T, token, libID string) {
c.expect(c.call("POST", "/mixes/genre%3Apolka/playlist", token, nil), 404, "save an unknown mix", "mix_not_found")
c.expect(c.call("POST", "/mixes/genre%3Asynthwave/playlist", token, map[string]any{"variant": -1}), 400, "save with a negative variant", "invalid_input")
}
// smartPlaylists makes, reads, previews, changes, keeps and deletes smart playlists, over the synthwave
// songs that c.mixes added.
func (c *contract) smartPlaylists(t *testing.T, token string) {
t.Helper()
rules := map[string]any{"genres": []string{"synthwave"}, "formats": []string{"flac"}, "never_played": true}
c.expect(c.call("GET", "/smart-playlists", "", nil), 401, "smart playlists without a token", "unauthorized")
c.expect(c.call("POST", "/smart-playlists", token, map[string]any{"name": "", "rules": rules}), 400, "a smart playlist with no name", "invalid_input")
c.expect(c.call("POST", "/smart-playlists", token, map[string]any{"name": "x", "sort": "loudest"}), 400, "an unknown order", "invalid_input")
made := c.expect(c.call("POST", "/smart-playlists", token, map[string]any{"name": "Fresh synth", "description": "new", "rules": rules, "sort": "title", "limit": 12}), 201, "make a smart playlist")
id := strconv.Itoa(int(made["id"].(float64)))
list := c.expect(c.call("GET", "/smart-playlists?limit=5&offset=0", token, nil), 200, "list smart playlists")
if list["total"] != float64(1) {
t.Fatalf("smart playlists = %v", list)
}
c.expect(c.call("GET", "/smart-playlists/"+id, token, nil), 200, "get a smart playlist")
c.expect(c.call("GET", "/smart-playlists/999999", token, nil), 404, "an unknown smart playlist", "smart_playlist_not_found")
c.expect(c.call("GET", "/smart-playlists/0", token, nil), 400, "a bad smart playlist id", "invalid_input")
got := c.expect(c.call("GET", "/smart-playlists/"+id+"/tracks", token, nil), 200, "the songs of a smart playlist")
if len(got["tracks"].([]any)) != 12 {
t.Fatalf("smart playlist songs = %v", got)
}
c.expect(c.call("GET", "/smart-playlists/"+id+"/tracks?variant=2", token, nil), 200, "the songs, another variant")
c.expect(c.call("GET", "/smart-playlists/"+id+"/tracks?variant=-1", token, nil), 400, "a negative variant", "invalid_input")
c.expect(c.call("GET", "/smart-playlists/999999/tracks", token, nil), 404, "the songs of an unknown smart playlist", "smart_playlist_not_found")
c.expect(c.call("POST", "/smart-playlists/preview", token, map[string]any{"rules": map[string]any{"min_duration_sec": 30, "liked_artists_only": false}, "sort": "most_played", "limit": 5, "variant": 1}), 200, "preview rules")
c.expect(c.call("POST", "/smart-playlists/preview", token, map[string]any{"rules": map[string]any{"min_plays": -1}}), 400, "preview bad rules", "invalid_input")
c.expect(c.call("PATCH", "/smart-playlists/"+id, token, map[string]any{"name": "Fresher", "rules": map[string]any{"added_within_days": 3650}}), 200, "change a smart playlist")
c.expect(c.call("PATCH", "/smart-playlists/"+id, token, map[string]any{"limit": 0, "name": ""}), 400, "change to a bad name", "invalid_input")
c.expect(c.call("PATCH", "/smart-playlists/999999", token, map[string]any{"name": "x"}), 404, "change an unknown smart playlist", "smart_playlist_not_found")
c.expect(c.call("POST", "/smart-playlists/"+id+"/playlist", token, map[string]any{"name": "Kept", "variant": 1}), 201, "keep a smart playlist as a playlist")
c.expect(c.call("POST", "/smart-playlists/"+id+"/playlist", token, nil), 201, "keep with no body")
c.expect(c.call("POST", "/smart-playlists/999999/playlist", token, nil), 404, "keep an unknown smart playlist", "smart_playlist_not_found")
empty := c.expect(c.call("POST", "/smart-playlists", token, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}}), 201, "make a smart playlist that gives nothing")
c.expect(c.call("POST", "/smart-playlists/"+strconv.Itoa(int(empty["id"].(float64)))+"/playlist", token, nil), 422, "keep one that gives no songs", "smart_playlist_empty")
c.expect(c.call("DELETE", "/smart-playlists/"+id, token, nil), 204, "delete a smart playlist")
c.expect(c.call("DELETE", "/smart-playlists/"+id, token, nil), 404, "delete it again", "smart_playlist_not_found")
}

View file

@ -133,20 +133,5 @@ func (h *mixHandlers) save(c *gin.Context) {
if strings.TrimSpace(name) == "" {
name = m.Title
}
pl, err := h.playlists.Create(ctx, user, name, "")
if err != nil {
writePlaylistError(c, err)
return
}
ids := make([]int64, len(tracks))
for i, t := range tracks {
ids[i] = t.ID
}
filled, err := h.playlists.AddTracks(ctx, user, pl.ID, ids, nil)
if err != nil {
_ = h.playlists.Delete(ctx, user, pl.ID)
writePlaylistError(c, err)
return
}
c.JSON(http.StatusCreated, toPlaylistJSON(filled))
keepAsPlaylist(c, h.playlists, user, name, tracks)
}

View file

@ -7,6 +7,7 @@ import (
"github.com/gin-gonic/gin"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/playlists"
)
@ -266,3 +267,25 @@ func (h *playlistHandlers) moveItem(c *gin.Context) {
}
c.Status(http.StatusNoContent)
}
// keepAsPlaylist makes a playlist of the user with the songs, in order, and answers with it. A save that
// fails half way leaves no playlist behind.
func keepAsPlaylist(c *gin.Context, svc playlistService, user int64, name string, tracks []catalog.Track) {
ctx := c.Request.Context()
pl, err := svc.Create(ctx, user, name, "")
if err != nil {
writePlaylistError(c, err)
return
}
ids := make([]int64, len(tracks))
for i, t := range tracks {
ids[i] = t.ID
}
filled, err := svc.AddTracks(ctx, user, pl.ID, ids, nil)
if err != nil {
_ = svc.Delete(ctx, user, pl.ID)
writePlaylistError(c, err)
return
}
c.JSON(http.StatusCreated, toPlaylistJSON(filled))
}

View file

@ -0,0 +1,235 @@
package httpapi
import (
"errors"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"codeberg.org/squidd/sonda/internal/smart"
)
// smartHandlers serve the signed-in user's smart playlists: playlists that are a set of rules, worked out
// every time they are opened. They are theirs alone: one of somebody else answers
// smart_playlist_not_found, as one that does not exist.
type smartHandlers struct {
svc smartService
playlists playlistService
}
type smartJSON struct {
ID int64 `json:"id"`
Name string `json:"name"`
Description string `json:"description"`
Rules smart.Rules `json:"rules"`
Sort string `json:"sort"`
Limit int `json:"limit"`
CreatedAt *string `json:"created_at"`
UpdatedAt *string `json:"updated_at"`
}
type smartPageJSON struct {
Items []smartJSON `json:"items"`
Total int `json:"total"`
Limit int `json:"limit"`
Offset int `json:"offset"`
}
type smartTracksJSON struct {
Variant int `json:"variant"`
Tracks []trackJSON `json:"tracks"`
}
func toSmartJSON(p smart.SmartPlaylist) smartJSON {
return smartJSON{
ID: p.ID, Name: p.Name, Description: p.Description, Rules: p.Rules, Sort: string(p.Sort), Limit: p.Limit,
CreatedAt: rfc3339(p.CreatedAt), UpdatedAt: rfc3339(p.UpdatedAt),
}
}
func writeSmartError(c *gin.Context, err error) {
switch {
case errors.Is(err, smart.ErrInvalidInput):
writeError(c, http.StatusBadRequest, "invalid_input", err.Error())
case errors.Is(err, smart.ErrNotFound):
writeError(c, http.StatusNotFound, "smart_playlist_not_found", "no such smart playlist")
case errors.Is(err, smart.ErrTooMany):
writeError(c, http.StatusConflict, "limit_reached", err.Error())
default:
_ = c.Error(err)
writeError(c, http.StatusInternalServerError, "internal", "internal error")
}
}
type createSmartRequest struct {
Name string `json:"name"`
Description string `json:"description"`
Rules smart.Rules `json:"rules"`
Sort string `json:"sort"` // absent: random
Limit int `json:"limit"` // absent: 50
}
func (h *smartHandlers) create(c *gin.Context) {
var req createSmartRequest
if !bindJSON(c, &req) {
return
}
p, err := h.svc.Create(c.Request.Context(), currentUserID(c), smart.Input{
Name: req.Name, Description: req.Description, Rules: req.Rules, Sort: smart.Sort(req.Sort), Limit: req.Limit,
})
if err != nil {
writeSmartError(c, err)
return
}
c.JSON(http.StatusCreated, toSmartJSON(p))
}
func (h *smartHandlers) list(c *gin.Context) {
page, ok := pageOf(c)
if !ok {
return
}
l, err := h.svc.List(c.Request.Context(), currentUserID(c), page.Limit, page.Offset)
if err != nil {
writeSmartError(c, err)
return
}
out := smartPageJSON{Items: make([]smartJSON, len(l.Items)), Total: l.Total, Limit: l.Limit, Offset: l.Offset}
for i, p := range l.Items {
out.Items[i] = toSmartJSON(p)
}
c.JSON(http.StatusOK, out)
}
func (h *smartHandlers) get(c *gin.Context) {
id, ok := pathID(c)
if !ok {
return
}
p, err := h.svc.Get(c.Request.Context(), currentUserID(c), id)
if err != nil {
writeSmartError(c, err)
return
}
c.JSON(http.StatusOK, toSmartJSON(p))
}
type updateSmartRequest struct {
Name *string `json:"name"` // pointers: absent must not mean empty
Description *string `json:"description"`
Rules *smart.Rules `json:"rules"` // replace the old ones whole
Sort *string `json:"sort"`
Limit *int `json:"limit"`
}
func (h *smartHandlers) update(c *gin.Context) {
id, ok := pathID(c)
if !ok {
return
}
var req updateSmartRequest
if !bindJSON(c, &req) {
return
}
patch := smart.Patch{Name: req.Name, Description: req.Description, Rules: req.Rules, Limit: req.Limit}
if req.Sort != nil {
s := smart.Sort(*req.Sort)
patch.Sort = &s
}
p, err := h.svc.Update(c.Request.Context(), currentUserID(c), id, patch)
if err != nil {
writeSmartError(c, err)
return
}
c.JSON(http.StatusOK, toSmartJSON(p))
}
func (h *smartHandlers) remove(c *gin.Context) {
id, ok := pathID(c)
if !ok {
return
}
if err := h.svc.Delete(c.Request.Context(), currentUserID(c), id); err != nil {
writeSmartError(c, err)
return
}
c.Status(http.StatusNoContent)
}
// tracks works the songs out now: the same all day, and other ones for another variant.
func (h *smartHandlers) tracks(c *gin.Context) {
id, ok := pathID(c)
if !ok {
return
}
variant, ok := variantOf(c)
if !ok {
return
}
_, tracks, err := h.svc.Tracks(c.Request.Context(), currentUserID(c), id, variant)
if err != nil {
writeSmartError(c, err)
return
}
c.JSON(http.StatusOK, smartTracksJSON{Variant: variant, Tracks: toTracksJSON(tracks)})
}
type previewSmartRequest struct {
Rules smart.Rules `json:"rules"`
Sort string `json:"sort"`
Limit int `json:"limit"`
Variant int `json:"variant"`
}
// preview works the songs out for rules that are not kept, so they can be tried before saving.
func (h *smartHandlers) preview(c *gin.Context) {
var req previewSmartRequest
if !bindJSON(c, &req) {
return
}
tracks, err := h.svc.Preview(c.Request.Context(), currentUserID(c), smart.Input{
Rules: req.Rules, Sort: smart.Sort(req.Sort), Limit: req.Limit,
}, req.Variant)
if err != nil {
writeSmartError(c, err)
return
}
c.JSON(http.StatusOK, smartTracksJSON{Variant: req.Variant, Tracks: toTracksJSON(tracks)})
}
type saveSmartRequest struct {
Name string `json:"name"` // blank: the name of the smart playlist
Variant *int `json:"variant"` // absent: the songs of the day
}
// save makes a normal playlist of the songs the smart playlist gives now (the ones that variant shows).
func (h *smartHandlers) save(c *gin.Context) {
id, ok := pathID(c)
if !ok {
return
}
var req saveSmartRequest
if c.Request.ContentLength != 0 && !bindJSON(c, &req) {
return
}
variant := 0
if req.Variant != nil {
variant = *req.Variant
}
user := currentUserID(c)
p, tracks, err := h.svc.Tracks(c.Request.Context(), user, id, variant)
if err != nil {
writeSmartError(c, err)
return
}
if len(tracks) == 0 {
writeError(c, http.StatusUnprocessableEntity, "smart_playlist_empty", "the rules give no songs to save")
return
}
name := req.Name
if strings.TrimSpace(name) == "" {
name = p.Name
}
keepAsPlaylist(c, h.playlists, user, name, tracks)
}

View file

@ -27,6 +27,7 @@ import (
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/playlists"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/smart"
"codeberg.org/squidd/sonda/internal/streaming"
"codeberg.org/squidd/sonda/internal/taste"
"codeberg.org/squidd/sonda/internal/usersettings"
@ -106,6 +107,17 @@ type mixService interface {
Get(ctx context.Context, userID int64, id string, variant int) (mixes.Mix, []catalog.Track, error)
}
// smartService is what the handlers need from smart.Service.
type smartService interface {
Create(ctx context.Context, userID int64, in smart.Input) (smart.SmartPlaylist, error)
List(ctx context.Context, userID int64, limit, offset int) (smart.Listing, error)
Get(ctx context.Context, userID, id int64) (smart.SmartPlaylist, error)
Update(ctx context.Context, userID, id int64, p smart.Patch) (smart.SmartPlaylist, error)
Delete(ctx context.Context, userID, id int64) error
Tracks(ctx context.Context, userID, id int64, variant int) (smart.SmartPlaylist, []catalog.Track, error)
Preview(ctx context.Context, userID int64, in smart.Input, variant int) ([]catalog.Track, error)
}
type feedbackService interface {
Add(ctx context.Context, userID, artistID int64, kind feedback.Kind) error
Remove(ctx context.Context, userID, artistID int64, kind feedback.Kind) error
@ -180,6 +192,7 @@ type Deps struct {
Feedback feedbackService
Playlists playlistService
Mixes mixService
Smart smartService
Images coverService
CoversJob jobService
ArtistImagesJob jobService
@ -263,6 +276,15 @@ func NewRouter(d Deps) *gin.Engine {
protected.GET("/mixes", mx.list)
protected.GET("/mixes/:id", mx.get)
protected.POST("/mixes/:id/playlist", mx.save)
sm := &smartHandlers{svc: d.Smart, playlists: d.Playlists}
protected.GET("/smart-playlists", sm.list)
protected.POST("/smart-playlists", sm.create)
protected.POST("/smart-playlists/preview", sm.preview)
protected.GET("/smart-playlists/:id", sm.get)
protected.PATCH("/smart-playlists/:id", sm.update)
protected.DELETE("/smart-playlists/:id", sm.remove)
protected.GET("/smart-playlists/:id/tracks", sm.tracks)
protected.POST("/smart-playlists/:id/playlist", sm.save)
protected.GET("/wishlist", fb.list(feedback.Wishlist))
protected.PUT("/wishlist/:id", fb.add(feedback.Wishlist))
protected.DELETE("/wishlist/:id", fb.remove(feedback.Wishlist))

View file

@ -0,0 +1,265 @@
package httpapi
import (
"fmt"
"net/http"
"slices"
"strings"
"testing"
)
const sp = "/api/v1/smart-playlists"
// smartMade makes a smart playlist of alice's and returns its id.
func smartMade(t *testing.T, m *mixAPI, body map[string]any) int {
t.Helper()
r := do(t, m.h, "POST", sp, m.alice, body)
if r.Code != http.StatusCreated {
t.Fatalf("create: %d %v", r.Code, r.Body)
}
return int(r.Body["id"].(float64))
}
func smartTracks(t *testing.T, m *mixAPI, id int, query string) []float64 {
t.Helper()
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks%s", sp, id, query), m.alice, nil)
if r.Code != http.StatusOK {
t.Fatalf("tracks: %d %v", r.Code, r.Body)
}
return trackIDs(t, r)
}
func TestSmartPlaylistRoutesNeedASignedInUser(t *testing.T) {
m := newMixAPI(t)
for _, rt := range []struct{ method, path string }{
{"GET", sp}, {"POST", sp}, {"POST", sp + "/preview"}, {"GET", sp + "/1"}, {"PATCH", sp + "/1"}, {"DELETE", sp + "/1"},
{"GET", sp + "/1/tracks"}, {"POST", sp + "/1/playlist"},
} {
if r := do(t, m.h, rt.method, rt.path, "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("%s %s without a token: %d", rt.method, rt.path, r.Code)
}
}
}
func TestASmartPlaylistIsMadeReadChangedAndDeleted(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "POST", sp, m.alice, map[string]any{
"name": " Rock, new ", "rules": map[string]any{"genres": []string{"Rock"}, "never_played": true, "formats": []string{"FLAC"}},
})
if r.Code != http.StatusCreated {
t.Fatalf("create: %d %v", r.Code, r.Body)
}
id := int(r.Body["id"].(float64))
rules := r.Body["rules"].(map[string]any)
if r.Body["name"] != "Rock, new" || r.Body["sort"] != "random" || r.Body["limit"] != float64(50) || r.Body["description"] != "" ||
r.Body["created_at"] == nil || r.Body["updated_at"] == nil ||
rules["never_played"] != true || fmt.Sprint(rules["genres"]) != "[rock]" || fmt.Sprint(rules["formats"]) != "[flac]" {
t.Errorf("created = %v", r.Body)
}
got := do(t, m.h, "GET", fmt.Sprintf("%s/%d", sp, id), m.alice, nil)
if got.Code != http.StatusOK || got.Body["name"] != "Rock, new" {
t.Errorf("get: %d %v", got.Code, got.Body)
}
list := do(t, m.h, "GET", sp, m.alice, nil)
if list.Body["total"] != float64(1) || list.Body["limit"] != float64(50) || list.Body["offset"] != float64(0) || len(list.Body["items"].([]any)) != 1 {
t.Errorf("list = %v", list.Body)
}
upd := do(t, m.h, "PATCH", fmt.Sprintf("%s/%d", sp, id), m.alice, map[string]any{
"name": "Rock, again", "sort": "title", "limit": 20, "rules": map[string]any{"min_plays": 3},
})
rules = upd.Body["rules"].(map[string]any)
if upd.Code != http.StatusOK || upd.Body["name"] != "Rock, again" || upd.Body["sort"] != "title" || upd.Body["limit"] != float64(20) ||
rules["min_plays"] != float64(3) || rules["never_played"] != nil || rules["genres"] != nil {
t.Errorf("update: %d %v: the rules are replaced whole", upd.Code, upd.Body)
}
// Only what is sent changes.
again := do(t, m.h, "PATCH", fmt.Sprintf("%s/%d", sp, id), m.alice, map[string]any{"description": "d"})
if again.Body["name"] != "Rock, again" || again.Body["description"] != "d" || again.Body["sort"] != "title" {
t.Errorf("a patch with one field: %v", again.Body)
}
if del := do(t, m.h, "DELETE", fmt.Sprintf("%s/%d", sp, id), m.alice, nil); del.Code != http.StatusNoContent {
t.Errorf("delete: %d", del.Code)
}
if r := do(t, m.h, "GET", fmt.Sprintf("%s/%d", sp, id), m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "smart_playlist_not_found" {
t.Errorf("get after delete: %d %v", r.Code, r.Body)
}
}
func TestWhatIsNotAcceptedIsSaidSo(t *testing.T) {
m := newMixAPI(t)
for name, body := range map[string]map[string]any{
"no name": {"rules": map[string]any{}},
"an unknown order": {"name": "a", "sort": "loudest"},
"a limit too big": {"name": "a", "limit": 501},
"days below zero": {"name": "a", "rules": map[string]any{"played_within_days": -1}},
"a genre that isn't": {"name": "a", "rules": map[string]any{"genres": []string{"unknown"}}},
"a bad format": {"name": "a", "rules": map[string]any{"formats": []string{"fl/ac"}}},
} {
if r := do(t, m.h, "POST", sp, m.alice, body); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("%s: %d %v", name, r.Code, r.Body)
}
}
for _, path := range []string{sp + "/0", sp + "/x", sp + "/1/tracks?variant=-1", sp + "/1/tracks?variant=x", sp + "?limit=-1"} {
if r := do(t, m.h, "GET", path, m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("GET %s: %d %v", path, r.Code, r.Body)
}
}
if r := do(t, m.h, "POST", sp, m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("no body: %d", r.Code)
}
}
func TestTheSongsAreWorkedOutFromTheRules(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Hard", "sort": "title", "limit": 5, "rules": map[string]any{"genres": []string{"hard rock"}}})
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks", sp, id), m.alice, nil)
ids := trackIDs(t, r)
if r.Code != http.StatusOK || r.Body["variant"] != float64(0) || len(ids) != 5 {
t.Fatalf("tracks: %d %v", r.Code, r.Body)
}
for _, x := range r.Body["tracks"].([]any) {
track := x.(map[string]any)
if !strings.HasPrefix(track["title"].(string), "hard song") || track["album"] == nil || len(track["artists"].([]any)) != 1 {
t.Errorf("a song = %v", track)
}
}
if again := smartTracks(t, m, id, ""); !slices.Equal(ids, again) {
t.Error("the same order twice is not the same")
}
// A rule that no song meets gives an empty list, which is no error.
none := smartMade(t, m, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}})
if got := smartTracks(t, m, none, ""); len(got) != 0 {
t.Errorf("polka: %v", got)
}
}
func TestARandomOrderStaysTheSameForADayAndAVariantGivesAnother(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Any", "limit": 10, "rules": map[string]any{"genres": []string{"rock"}}})
first := smartTracks(t, m, id, "")
if len(first) != 10 || !slices.Equal(first, smartTracks(t, m, id, "")) {
t.Fatalf("the random order of a day changed: %v", first)
}
if v := smartTracks(t, m, id, "?variant=1"); slices.Equal(first, v) {
t.Error("another variant gave the same songs")
}
}
func TestListeningRulesUseTheHistoryOfTheOwner(t *testing.T) {
m := newMixAPI(t)
var played []int64
rows, err := m.db.Query("SELECT id FROM tracks WHERE title LIKE 'hard song%' ORDER BY id LIMIT 4")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
t.Fatal(err)
}
played = append(played, id)
}
rows.Close()
for i, id := range played {
if _, err := m.db.Exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (1, ?, 'complete', strftime('%s','now'), 60000, ?)`, id, fmt.Sprintf("k%d", i)); err != nil {
t.Skipf("cannot add listening events by hand here: %v", err)
}
}
never := smartMade(t, m, map[string]any{"name": "New hard", "limit": 500, "rules": map[string]any{"genres": []string{"hard rock"}, "never_played": true}})
if got := smartTracks(t, m, never, ""); len(got) != 36-4 {
t.Errorf("never played: %d songs, want 32", len(got))
}
heard := smartMade(t, m, map[string]any{"name": "Heard", "limit": 500, "rules": map[string]any{"played_within_days": 7}})
if got := smartTracks(t, m, heard, ""); len(got) != 4 {
t.Errorf("played this week: %d songs, want 4", len(got))
}
}
func TestPreviewTriesRulesWithoutKeepingAnything(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"rules": map[string]any{"genres": []string{"hard rock"}}, "sort": "title", "limit": 3})
if r.Code != http.StatusOK || r.Body["variant"] != float64(0) || len(trackIDs(t, r)) != 3 {
t.Fatalf("preview: %d %v", r.Code, r.Body)
}
if list := do(t, m.h, "GET", sp, m.alice, nil); list.Body["total"] != float64(0) {
t.Errorf("a preview kept something: %v", list.Body)
}
r = do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"rules": map[string]any{"genres": []string{"rock"}}, "limit": 10, "variant": 2})
if r.Code != http.StatusOK || r.Body["variant"] != float64(2) {
t.Errorf("preview with a variant: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"sort": "loudest"}); r.Code != http.StatusBadRequest {
t.Errorf("preview of a bad order: %d", r.Code)
}
if r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"variant": -1}); r.Code != http.StatusBadRequest {
t.Errorf("preview of a bad variant: %d", r.Code)
}
}
func TestASmartPlaylistIsKeptAsAPlaylistWithTheSongsShown(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Hard, kept", "limit": 6, "rules": map[string]any{"genres": []string{"hard rock"}}})
shown := smartTracks(t, m, id, "?variant=3")
r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, map[string]any{"variant": 3})
if r.Code != http.StatusCreated || r.Body["name"] != "Hard, kept" || r.Body["track_count"] != float64(6) {
t.Fatalf("save: %d %v", r.Code, r.Body)
}
items := do(t, m.h, "GET", fmt.Sprintf("/api/v1/playlists/%d/tracks", int(r.Body["id"].(float64))), m.alice, nil)
var kept []float64
for _, x := range items.Body["items"].([]any) {
kept = append(kept, x.(map[string]any)["track"].(map[string]any)["id"].(float64))
}
if !slices.Equal(kept, shown) {
t.Errorf("the playlist has %v, the smart playlist showed %v", kept, shown)
}
// It is a copy: the smart playlist is still there, and a name can be given.
named := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, map[string]any{"name": "Mine"})
if named.Code != http.StatusCreated || named.Body["name"] != "Mine" {
t.Errorf("named save: %d %v", named.Code, named.Body)
}
if r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, nil); r.Code != http.StatusCreated {
t.Errorf("a save with no body: %d", r.Code)
}
}
func TestASmartPlaylistWithNoSongsIsNotKept(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}})
r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, nil)
if r.Code != http.StatusUnprocessableEntity || errCode(r) != "smart_playlist_empty" {
t.Errorf("save: %d %v", r.Code, r.Body)
}
if list := do(t, m.h, "GET", "/api/v1/playlists", m.alice, nil); list.Body["total"] != float64(0) {
t.Errorf("a playlist was made: %v", list.Body)
}
}
func TestASmartPlaylistIsItsOwnersAlone(t *testing.T) {
m := newMixAPI(t)
_, bob := addUser(t, m.h, m.alice, "bob", false)
id := smartMade(t, m, map[string]any{"name": "Mine", "rules": map[string]any{}})
path := fmt.Sprintf("%s/%d", sp, id)
for _, rt := range []struct {
method, path string
body any
}{
{"GET", path, nil}, {"PATCH", path, map[string]any{"name": "x"}}, {"DELETE", path, nil},
{"GET", path + "/tracks", nil}, {"POST", path + "/playlist", nil},
} {
if r := do(t, m.h, rt.method, rt.path, bob, rt.body); r.Code != http.StatusNotFound || errCode(r) != "smart_playlist_not_found" {
t.Errorf("bob %s %s: %d %v, want 404 smart_playlist_not_found", rt.method, rt.path, r.Code, r.Body)
}
}
if list := do(t, m.h, "GET", sp, bob, nil); list.Body["total"] != float64(0) {
t.Errorf("bob's list: %v", list.Body)
}
if r := do(t, m.h, "GET", path, m.alice, nil); r.Code != http.StatusOK || r.Body["name"] != "Mine" {
t.Errorf("alice's own changed: %d %v", r.Code, r.Body)
}
}

View file

@ -39,6 +39,8 @@ tags:
description: Ordered lists of tracks that belong to one user.
- name: Mixes
description: Playlists made for you, from what you listen to and from the genres of your music.
- name: Smart playlists
description: Playlists that are a set of rules, worked out again every time they are opened.
- name: Discovery
description: Music outside the library, from external providers an admin switched on, and suggestions scored for you.
- name: Providers
@ -1286,6 +1288,191 @@ paths:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/smart-playlists:
get:
tags: [Smart playlists]
operationId: listSmartPlaylists
summary: Your smart playlists
description: |
The smart playlists you made, the one changed last first. Only yours. A smart playlist is a set
of rules: its songs come from `GET /smart-playlists/{id}/tracks`.
security: [{bearerAuth: []}]
parameters:
- {$ref: '#/components/parameters/Limit'}
- {$ref: '#/components/parameters/Offset'}
responses:
'200':
description: A page of smart playlists.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartPlaylistPage'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
post:
tags: [Smart playlists]
operationId: createSmartPlaylist
summary: Make a smart playlist
description: |
Keeps a set of rules, an order and a limit under a name. Only that is stored: the songs are worked
out again every time. A user can have 200. Names can repeat. Use `POST /smart-playlists/preview`
to try the rules first.
security: [{bearerAuth: []}]
requestBody:
required: true
content:
application/json:
schema: {$ref: '#/components/schemas/CreateSmartPlaylist'}
responses:
'201':
description: The smart playlist.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartPlaylist'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409':
description: A user can have 200 smart playlists (`limit_reached`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/smart-playlists/preview:
post:
tags: [Smart playlists]
operationId: previewSmartPlaylist
summary: Try rules without keeping them
description: |
Works the songs out for rules that are not kept, the way `GET /smart-playlists/{id}/tracks` would,
so they can be tried while they are written. Nothing is stored.
security: [{bearerAuth: []}]
requestBody:
required: true
content:
application/json:
schema: {$ref: '#/components/schemas/PreviewSmartPlaylist'}
responses:
'200':
description: The songs.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartTracks'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
/smart-playlists/{id}:
parameters:
- {$ref: '#/components/parameters/Id'}
get:
tags: [Smart playlists]
operationId: getSmartPlaylist
summary: A smart playlist
description: |
Its name, rules, order and limit, without the songs. One of somebody else answers
`smart_playlist_not_found`.
security: [{bearerAuth: []}]
responses:
'200':
description: The smart playlist.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartPlaylist'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'404': {$ref: '#/components/responses/SmartPlaylistNotFound'}
patch:
tags: [Smart playlists]
operationId: updateSmartPlaylist
summary: Change a smart playlist
description: |
Changes what is given. The rules, when given, replace the old ones whole. An empty description clears
it; a name cannot be empty.
security: [{bearerAuth: []}]
requestBody:
required: true
content:
application/json:
schema: {$ref: '#/components/schemas/UpdateSmartPlaylist'}
responses:
'200':
description: The smart playlist as it is now.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartPlaylist'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'404': {$ref: '#/components/responses/SmartPlaylistNotFound'}
delete:
tags: [Smart playlists]
operationId: deleteSmartPlaylist
summary: Delete a smart playlist
description: Deletes the rules. Playlists that were made from it with `POST /smart-playlists/{id}/playlist` stay.
security: [{bearerAuth: []}]
responses:
'204': {description: Deleted.}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'404': {$ref: '#/components/responses/SmartPlaylistNotFound'}
/smart-playlists/{id}/tracks:
parameters:
- {$ref: '#/components/parameters/Id'}
get:
tags: [Smart playlists]
operationId: getSmartPlaylistTracks
summary: The songs of a smart playlist, now
description: |
Works the rules out on the playable songs of the library, with your own listening history and taste
for the rules that use them, puts them in the order and cuts the end at the limit. A song whose files
are gone is never offered. Nothing is stored, and nothing is asked of a provider. With the random
order the songs stay the same all day, and another `variant` gives other ones.
security: [{bearerAuth: []}]
parameters:
- name: variant
in: query
description: Other songs for the random order, from 0 (the songs of the day) up.
schema: {type: integer, minimum: 0, maximum: 1000000, default: 0}
responses:
'200':
description: The songs.
content:
application/json:
schema: {$ref: '#/components/schemas/SmartTracks'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'404': {$ref: '#/components/responses/SmartPlaylistNotFound'}
/smart-playlists/{id}/playlist:
parameters:
- {$ref: '#/components/parameters/Id'}
post:
tags: [Smart playlists]
operationId: saveSmartPlaylist
summary: Keep a smart playlist as a playlist
description: |
Makes a playlist of your own with the songs that `variant` gives now, in the same order. The playlist
is a copy: it does not change afterwards, and is yours to edit. The body is optional.
security: [{bearerAuth: []}]
requestBody:
required: false
content:
application/json:
schema: {$ref: '#/components/schemas/SaveSmartPlaylist'}
responses:
'201':
description: The playlist.
content:
application/json:
schema: {$ref: '#/components/schemas/Playlist'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'404': {$ref: '#/components/responses/SmartPlaylistNotFound'}
'409': {$ref: '#/components/responses/PlaylistLimit'}
'422':
description: The rules give no songs to save (`smart_playlist_empty`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/playlists:
get:
tags: [Playlists]
@ -2555,6 +2742,11 @@ components:
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
SmartPlaylistNotFound:
description: No such smart playlist, or it is somebody else's (`smart_playlist_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
PlaylistNotFound:
description: No such playlist, or it is somebody else's (`playlist_not_found`).
content:
@ -3193,6 +3385,113 @@ components:
name: {type: string, maxLength: 200, description: "The name of the playlist; blank or absent means the title of the mix."}
variant: {type: integer, minimum: 0, maximum: 1000000, description: "The variant the client showed; absent means the mix of the day."}
SmartRules:
type: object
additionalProperties: false
description: |
Every rule that is set must hold; one that is absent, empty, false or 0 does not count. Of a list rule a
song needs to match one item.
properties:
genres: {type: array, maxItems: 50, items: {type: string}, description: "Kept lower case, with `+`, `-`, `_` and `/` taken for spaces: `jazz+funk` and `jazz-funk` are one genre."}
not_genres: {type: array, maxItems: 50, items: {type: string}, description: Leaves out songs of these genres.}
artist_ids: {type: array, maxItems: 50, items: {type: integer, format: int64, minimum: 1}, description: Songs whose main artist is one of these.}
not_artist_ids: {type: array, maxItems: 50, items: {type: integer, format: int64, minimum: 1}}
album_ids: {type: array, maxItems: 50, items: {type: integer, format: int64, minimum: 1}}
not_album_ids: {type: array, maxItems: 50, items: {type: integer, format: int64, minimum: 1}}
formats: {type: array, maxItems: 50, items: {type: string}, description: "File formats in lower case (`flac`, `mpeg`). A song counts when a file of it that is not missing has one of them."}
min_bitrate_kbps: {type: integer, minimum: 0, maximum: 100000, description: Needs a file of the song with this bitrate or more (the same file as `formats`).}
added_within_days: {type: integer, minimum: 0, maximum: 36500, description: "About the date of the file, which is the best the index knows."}
never_played: {type: boolean, description: Songs you never listened to.}
played_within_days: {type: integer, minimum: 0, maximum: 36500}
not_played_within_days: {type: integer, minimum: 0, maximum: 36500, description: Songs not played for this many days (the ones never played too).}
min_plays: {type: integer, minimum: 0, maximum: 1000000}
skipped_within_days: {type: integer, minimum: 0, maximum: 36500}
not_skipped_within_days: {type: integer, minimum: 0, maximum: 36500, description: Leaves out songs skipped in the last days.}
liked_artists_only: {type: boolean, description: Only songs by artists you like.}
without_avoided_artists: {type: boolean, description: Leaves out songs by artists you avoid.}
min_duration_sec: {type: integer, minimum: 0, maximum: 86400}
max_duration_sec: {type: integer, minimum: 0, maximum: 86400}
SmartSort:
type: string
enum: [random, most_played, least_played, recently_added, title]
description: A tie always goes to the lower song id.
SmartPlaylist:
type: object
additionalProperties: false
required: [id, name, description, rules, sort, limit, created_at, updated_at]
properties:
id: {type: integer, format: int64}
name: {type: string}
description: {type: string}
rules: {$ref: '#/components/schemas/SmartRules'}
sort: {$ref: '#/components/schemas/SmartSort'}
limit: {type: integer, minimum: 1, maximum: 500, description: The most songs it gives.}
created_at: {type: string, format: date-time}
updated_at: {type: string, format: date-time}
SmartPlaylistPage:
type: object
additionalProperties: false
required: [items, total, limit, offset]
properties:
items:
type: array
items: {$ref: '#/components/schemas/SmartPlaylist'}
total: {type: integer}
limit: {type: integer}
offset: {type: integer}
CreateSmartPlaylist:
type: object
additionalProperties: false
required: [name]
properties:
name: {type: string, minLength: 1, maxLength: 200, description: Trimmed.}
description: {type: string, maxLength: 2000}
rules: {$ref: '#/components/schemas/SmartRules'}
sort: {$ref: '#/components/schemas/SmartSort'}
limit: {type: integer, minimum: 1, maximum: 500, default: 50}
UpdateSmartPlaylist:
type: object
additionalProperties: false
description: What is given changes; the rules replace the old ones whole.
properties:
name: {type: string, minLength: 1, maxLength: 200}
description: {type: string, maxLength: 2000}
rules: {$ref: '#/components/schemas/SmartRules'}
sort: {$ref: '#/components/schemas/SmartSort'}
limit: {type: integer, minimum: 1, maximum: 500}
PreviewSmartPlaylist:
type: object
additionalProperties: false
properties:
rules: {$ref: '#/components/schemas/SmartRules'}
sort: {$ref: '#/components/schemas/SmartSort'}
limit: {type: integer, minimum: 1, maximum: 500, default: 50}
variant: {type: integer, minimum: 0, maximum: 1000000, default: 0}
SmartTracks:
type: object
additionalProperties: false
required: [variant, tracks]
properties:
variant: {type: integer, minimum: 0}
tracks:
type: array
description: In the order of the playlist. Empty when no song meets the rules.
items: {$ref: '#/components/schemas/Track'}
SaveSmartPlaylist:
type: object
additionalProperties: false
properties:
name: {type: string, maxLength: 200, description: "The name of the playlist; blank or absent means the name of the smart playlist."}
variant: {type: integer, minimum: 0, maximum: 1000000, description: "The variant the client showed; absent means the songs of the day."}
Playlist:
type: object
additionalProperties: false

View file

@ -159,6 +159,9 @@ func normalizeGenre(g string) string {
return g
}
// NormalizeGenre is normalizeGenre for the packages that compare genres the way the mixes do.
func NormalizeGenre(g string) string { return normalizeGenre(g) }
func titleCase(s string) string {
words := strings.Fields(s)
for i, w := range words {

615
internal/smart/smart.go Normal file
View file

@ -0,0 +1,615 @@
// Package smart keeps the smart playlists of each user: playlists that are a set of rules instead of a
// list of songs, worked out again every time they are opened, so the songs that arrive and what the
// listener plays change them by themselves.
//
// A smart playlist is made of Rules (every rule that is set must hold), an order and a limit. Only that is
// stored. The songs come from the playable songs of the library, then from the history and the taste of the
// owner, the way the mixes are made (see package mixes): nothing here contacts anyone, and a smart playlist
// that belongs to somebody else is as if it did not exist (ErrNotFound).
//
// "Random" is not new at every request: like a mix it stays the same for a day, and a variant number asks
// for another.
package smart
import (
"context"
"errors"
"fmt"
"hash/fnv"
"regexp"
"slices"
"sort"
"strings"
"time"
"unicode/utf8"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/taste"
)
// Limits. They keep one user from filling the database and one request from doing too much.
const (
MaxNameLen = 200
MaxDescriptionLen = 2000
MaxListed = 50 // genres, artists, albums or formats in one rule
MaxDays = 36_500
MaxPlays = 1_000_000
MaxBitrateKbps = 100_000
MaxDurationSec = 86_400
DefaultLimit = 50
MaxLimit = 500
MaxPlaylists = 200 // smart playlists of one user
MaxVariant = mixes.MaxVariant
DefaultPageLimit = 50
MaxPageLimit = 200
)
// Errors returned by the service and the store.
var (
ErrInvalidInput = errors.New("invalid input")
ErrNotFound = errors.New("smart playlist not found")
ErrTooMany = errors.New("limit reached")
)
// Sort is the order of the songs of a smart playlist, before the limit cuts the end.
type Sort string
// The orders. A tie always goes to the lower song id.
const (
SortRandom Sort = "random"
SortMostPlayed Sort = "most_played"
SortLeastPlayed Sort = "least_played"
SortRecentlyAdded Sort = "recently_added"
SortTitle Sort = "title"
)
func (s Sort) valid() bool {
switch s {
case SortRandom, SortMostPlayed, SortLeastPlayed, SortRecentlyAdded, SortTitle:
return true
}
return false
}
// Rules say which songs a smart playlist takes. A rule that is not set (empty, false or 0) does not count;
// every rule that is set must hold. The songs of a list rule match when they are by one of the artists, in
// one of the albums, have one of the genres or are in one of the formats.
type Rules struct {
// Genres are kept as they are compared: lower case, with "+", "-", "_" and "/" taken for spaces
// ("jazz+funk" and "jazz-funk" are the same genre).
Genres []string `json:"genres,omitempty"`
NotGenres []string `json:"not_genres,omitempty"`
// Artists are the main artists of the song.
ArtistIDs []int64 `json:"artist_ids,omitempty"`
NotArtistIDs []int64 `json:"not_artist_ids,omitempty"`
AlbumIDs []int64 `json:"album_ids,omitempty"`
NotAlbumIDs []int64 `json:"not_album_ids,omitempty"`
// Formats are those of the files ("flac", "mpeg"), in lower case. A song counts when a file of it, that is
// not missing, has one of them (and, with MinBitrateKbps, that bitrate or more).
Formats []string `json:"formats,omitempty"`
MinBitrateKbps int `json:"min_bitrate_kbps,omitempty"`
// AddedWithinDays is about the date of the file, which is the best the index knows.
AddedWithinDays int `json:"added_within_days,omitempty"`
// The listening rules are about the owner's history: a listen counts when the play was completed or lasted
// the minimum listen of the server, and a skip when it came before that.
NeverPlayed bool `json:"never_played,omitempty"`
PlayedWithinDays int `json:"played_within_days,omitempty"`
NotPlayedWithinDays int `json:"not_played_within_days,omitempty"`
MinPlays int `json:"min_plays,omitempty"`
SkippedWithinDays int `json:"skipped_within_days,omitempty"`
NotSkippedWithinDays int `json:"not_skipped_within_days,omitempty"`
// LikedArtistsOnly keeps the songs of artists the owner likes; WithoutAvoidedArtists leaves out the ones
// the owner avoids (see package taste).
LikedArtistsOnly bool `json:"liked_artists_only,omitempty"`
WithoutAvoidedArtists bool `json:"without_avoided_artists,omitempty"`
MinDurationSec int `json:"min_duration_sec,omitempty"`
MaxDurationSec int `json:"max_duration_sec,omitempty"`
}
// SmartPlaylist is a smart playlist.
type SmartPlaylist struct {
ID int64
Name string
Description string
Rules Rules
Sort Sort
Limit int
CreatedAt time.Time
UpdatedAt time.Time
}
// Input is what makes a smart playlist, or the preview of one. A zero Sort is random and a zero Limit is
// DefaultLimit.
type Input struct {
Name string
Description string
Rules Rules
Sort Sort
Limit int
}
// Patch changes the smart playlist in the fields that are not nil. Rules replace the old ones whole.
type Patch struct {
Name *string
Description *string
Rules *Rules
Sort *Sort
Limit *int
}
// History is what one listener did with one song.
type History = mixes.History
// Candidate is a playable song the rules may take, with what they need to know of it.
type Candidate struct {
TrackID int64
ArtistID int64 // the main artist, 0 when there is none
Title string
DurationMs int64
AddedAt time.Time // the date of its newest file that is not missing
}
// Filter is the part of the rules that the index answers: every list that is set narrows the songs.
// Genres are spelled as the files have them.
type Filter struct {
Genres, NotGenres []string
ArtistIDs, NotArtistIDs []int64
AlbumIDs, NotAlbumIDs []int64
Formats []string
MinBitrateKbps int
}
// Store keeps the smart playlists and reads what they are made of. Every call that is about one playlist is
// for one user and gives ErrNotFound for a playlist that does not exist or is not theirs.
type Store interface {
// Create keeps a playlist (its ID is ignored), or gives ErrTooMany when the user has MaxPlaylists.
Create(ctx context.Context, userID int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
// List returns a page of the user's smart playlists, the one changed last first, and how many there are.
List(ctx context.Context, userID int64, limit, offset int) ([]SmartPlaylist, int, error)
Get(ctx context.Context, userID, id int64) (SmartPlaylist, error)
// Update replaces name, description, rules, order and limit.
Update(ctx context.Context, userID, id int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
Delete(ctx context.Context, userID, id int64) error
// Genres returns every genre of the playable songs, as spelled in the files.
Genres(ctx context.Context) ([]mixes.Genre, error)
// Candidates returns the playable songs of the filter.
Candidates(ctx context.Context, f Filter) ([]Candidate, error)
// History returns what the user did with the songs they did anything with; minListen is how long a
// play must last to count as a listen.
History(ctx context.Context, userID int64, minListen time.Duration) (map[int64]History, error)
// Tracks returns the songs in the order given, leaving out any that cannot be played.
Tracks(ctx context.Context, ids []int64) ([]catalog.Track, error)
}
// Taster says what the listener likes: *taste.Service.
type Taster interface {
Learn(ctx context.Context, userID int64) (taste.Learned, error)
}
// Service validates what it is given, keeps the smart playlists and works their songs out.
type Service struct {
store Store
taster Taster
minListen time.Duration
now func() time.Time
}
// NewService builds a Service. minListen is how long a play must last to count as a listen.
func NewService(store Store, taster Taster, minListen time.Duration) *Service {
return &Service{store: store, taster: taster, minListen: minListen, now: time.Now}
}
func invalid(format string, a ...any) error {
return fmt.Errorf("%w: %s", ErrInvalidInput, fmt.Sprintf(format, a...))
}
func cleanName(name string) (string, error) {
name = strings.TrimSpace(name)
if name == "" || utf8.RuneCountInString(name) > MaxNameLen {
return "", invalid("the name must have 1 to %d characters", MaxNameLen)
}
return name, nil
}
func cleanDescription(d string) (string, error) {
d = strings.TrimSpace(d)
if utf8.RuneCountInString(d) > MaxDescriptionLen {
return "", invalid("the description can have up to %d characters", MaxDescriptionLen)
}
return d, nil
}
var formatRe = regexp.MustCompile(`^[a-z0-9]{1,16}$`)
func cleanGenres(rule string, in []string) ([]string, error) {
if len(in) > MaxListed {
return nil, invalid("%s can have up to %d genres", rule, MaxListed)
}
var out []string
for _, g := range in {
n := mixes.NormalizeGenre(g)
if n == "" {
return nil, invalid("%q is not a genre", g)
}
if !slices.Contains(out, n) {
out = append(out, n)
}
}
return out, nil
}
func cleanFormats(in []string) ([]string, error) {
if len(in) > MaxListed {
return nil, invalid("formats can have up to %d items", MaxListed)
}
var out []string
for _, f := range in {
f = strings.ToLower(strings.TrimSpace(f))
if !formatRe.MatchString(f) {
return nil, invalid("%q is not a format", f)
}
if !slices.Contains(out, f) {
out = append(out, f)
}
}
return out, nil
}
func cleanIDs(rule string, in []int64) ([]int64, error) {
if len(in) > MaxListed {
return nil, invalid("%s can have up to %d ids", rule, MaxListed)
}
var out []int64
for _, id := range in {
if id < 1 {
return nil, invalid("%s must be ids, from 1", rule)
}
if !slices.Contains(out, id) {
out = append(out, id)
}
}
return out, nil
}
func inRange(rule string, n, max int) error {
if n < 0 || n > max {
return invalid("%s must be from 0 to %d", rule, max)
}
return nil
}
// cleanRules checks the rules and returns them in the form they are kept in.
func cleanRules(r Rules) (Rules, error) {
var err error
if r.Genres, err = cleanGenres("genres", r.Genres); err != nil {
return Rules{}, err
}
if r.NotGenres, err = cleanGenres("not_genres", r.NotGenres); err != nil {
return Rules{}, err
}
for _, l := range []struct {
name string
ids *[]int64
}{{"artist_ids", &r.ArtistIDs}, {"not_artist_ids", &r.NotArtistIDs}, {"album_ids", &r.AlbumIDs}, {"not_album_ids", &r.NotAlbumIDs}} {
if *l.ids, err = cleanIDs(l.name, *l.ids); err != nil {
return Rules{}, err
}
}
if r.Formats, err = cleanFormats(r.Formats); err != nil {
return Rules{}, err
}
for _, n := range []struct {
name string
got, max int
}{
{"min_bitrate_kbps", r.MinBitrateKbps, MaxBitrateKbps},
{"added_within_days", r.AddedWithinDays, MaxDays},
{"played_within_days", r.PlayedWithinDays, MaxDays},
{"not_played_within_days", r.NotPlayedWithinDays, MaxDays},
{"skipped_within_days", r.SkippedWithinDays, MaxDays},
{"not_skipped_within_days", r.NotSkippedWithinDays, MaxDays},
{"min_plays", r.MinPlays, MaxPlays},
{"min_duration_sec", r.MinDurationSec, MaxDurationSec},
{"max_duration_sec", r.MaxDurationSec, MaxDurationSec},
} {
if err := inRange(n.name, n.got, n.max); err != nil {
return Rules{}, err
}
}
if r.MaxDurationSec > 0 && r.MinDurationSec > r.MaxDurationSec {
return Rules{}, invalid("min_duration_sec is more than max_duration_sec")
}
return r, nil
}
// cleanShape checks the order and the limit and gives them their defaults.
func cleanShape(sortBy Sort, limit int) (Sort, int, error) {
if sortBy == "" {
sortBy = SortRandom
}
if !sortBy.valid() {
return "", 0, invalid("sort must be random, most_played, least_played, recently_added or title")
}
if limit == 0 {
limit = DefaultLimit
}
if limit < 1 || limit > MaxLimit {
return "", 0, invalid("limit must be from 1 to %d", MaxLimit)
}
return sortBy, limit, nil
}
// clean checks everything but the name, which a preview does not have.
func clean(in Input) (Input, error) {
var err error
if in.Description, err = cleanDescription(in.Description); err != nil {
return Input{}, err
}
if in.Rules, err = cleanRules(in.Rules); err != nil {
return Input{}, err
}
if in.Sort, in.Limit, err = cleanShape(in.Sort, in.Limit); err != nil {
return Input{}, err
}
return in, nil
}
// Create keeps a smart playlist for the user.
func (s *Service) Create(ctx context.Context, userID int64, in Input) (SmartPlaylist, error) {
name, err := cleanName(in.Name)
if err != nil {
return SmartPlaylist{}, err
}
in, err = clean(in)
if err != nil {
return SmartPlaylist{}, err
}
return s.store.Create(ctx, userID, SmartPlaylist{Name: name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
}
// Listing is a page of smart playlists.
type Listing struct {
Items []SmartPlaylist
Total int
Limit int
Offset int
}
// List returns a page of the user's smart playlists, the one changed last first. A limit of 0 is
// DefaultPageLimit, and one above MaxPageLimit is lowered to it, as for the playlists.
func (s *Service) List(ctx context.Context, userID int64, limit, offset int) (Listing, error) {
if limit < 0 || offset < 0 {
return Listing{}, invalid("limit and offset cannot be negative")
}
switch {
case limit == 0:
limit = DefaultPageLimit
case limit > MaxPageLimit:
limit = MaxPageLimit
}
items, total, err := s.store.List(ctx, userID, limit, offset)
if err != nil {
return Listing{}, err
}
return Listing{Items: items, Total: total, Limit: limit, Offset: offset}, nil
}
// Get returns a smart playlist of the user, without its songs.
func (s *Service) Get(ctx context.Context, userID, id int64) (SmartPlaylist, error) {
return s.store.Get(ctx, userID, id)
}
// Update changes the fields of the patch that are not nil.
func (s *Service) Update(ctx context.Context, userID, id int64, p Patch) (SmartPlaylist, error) {
cur, err := s.store.Get(ctx, userID, id)
if err != nil {
return SmartPlaylist{}, err
}
in := Input{Name: cur.Name, Description: cur.Description, Rules: cur.Rules, Sort: cur.Sort, Limit: cur.Limit}
if p.Name != nil {
in.Name = *p.Name
}
if p.Description != nil {
in.Description = *p.Description
}
if p.Rules != nil {
in.Rules = *p.Rules
}
if p.Sort != nil {
in.Sort = *p.Sort
}
if p.Limit != nil {
in.Limit = *p.Limit
}
if in.Name, err = cleanName(in.Name); err != nil {
return SmartPlaylist{}, err
}
if in, err = clean(in); err != nil {
return SmartPlaylist{}, err
}
return s.store.Update(ctx, userID, id, SmartPlaylist{Name: in.Name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
}
// Delete removes a smart playlist of the user.
func (s *Service) Delete(ctx context.Context, userID, id int64) error {
return s.store.Delete(ctx, userID, id)
}
// Tracks works the songs of a smart playlist out. variant 0 is the one of the day; with a random order,
// another number gives other songs.
func (s *Service) Tracks(ctx context.Context, userID, id int64, variant int) (SmartPlaylist, []catalog.Track, error) {
if err := checkVariant(variant); err != nil {
return SmartPlaylist{}, nil, err
}
p, err := s.store.Get(ctx, userID, id)
if err != nil {
return SmartPlaylist{}, nil, err
}
tracks, err := s.run(ctx, userID, p.ID, p.Rules, p.Sort, p.Limit, variant)
return p, tracks, err
}
// Preview works the songs out for rules that are not kept, to try them before saving.
func (s *Service) Preview(ctx context.Context, userID int64, in Input, variant int) ([]catalog.Track, error) {
if err := checkVariant(variant); err != nil {
return nil, err
}
in, err := clean(in)
if err != nil {
return nil, err
}
return s.run(ctx, userID, 0, in.Rules, in.Sort, in.Limit, variant)
}
func checkVariant(v int) error {
if v < 0 || v > MaxVariant {
return invalid("variant must be from 0 to %d", MaxVariant)
}
return nil
}
// spellings returns the spellings the files have of the genres (all compared as normalized).
func spellings(all []mixes.Genre, genres []string) []string {
var out []string
for _, g := range all {
if slices.Contains(genres, mixes.NormalizeGenre(g.Name)) {
out = append(out, g.Name)
}
}
return out
}
func (s *Service) run(ctx context.Context, userID, id int64, r Rules, order Sort, limit, variant int) ([]catalog.Track, error) {
f := Filter{
ArtistIDs: r.ArtistIDs, NotArtistIDs: r.NotArtistIDs, AlbumIDs: r.AlbumIDs, NotAlbumIDs: r.NotAlbumIDs,
Formats: r.Formats, MinBitrateKbps: r.MinBitrateKbps,
}
if len(r.Genres) > 0 || len(r.NotGenres) > 0 {
all, err := s.store.Genres(ctx)
if err != nil {
return nil, fmt.Errorf("read genres: %w", err)
}
f.Genres, f.NotGenres = spellings(all, r.Genres), spellings(all, r.NotGenres)
if len(r.Genres) > 0 && len(f.Genres) == 0 {
return []catalog.Track{}, nil // no file has any of the genres
}
}
cands, err := s.store.Candidates(ctx, f)
if err != nil {
return nil, fmt.Errorf("read the songs: %w", err)
}
var history map[int64]History
if order == SortMostPlayed || order == SortLeastPlayed || r.NeverPlayed || r.MinPlays > 0 ||
r.PlayedWithinDays > 0 || r.NotPlayedWithinDays > 0 || r.SkippedWithinDays > 0 || r.NotSkippedWithinDays > 0 {
if history, err = s.store.History(ctx, userID, s.minListen); err != nil {
return nil, fmt.Errorf("read history: %w", err)
}
}
var learned taste.Learned
if r.LikedArtistsOnly || r.WithoutAvoidedArtists {
if learned, err = s.taster.Learn(ctx, userID); err != nil {
return nil, fmt.Errorf("learn taste: %w", err)
}
}
now := s.now()
within := func(t time.Time, days int) bool {
return !t.IsZero() && now.Sub(t) <= time.Duration(days)*24*time.Hour
}
kept := make([]Candidate, 0, len(cands))
for _, c := range cands {
h := history[c.TrackID]
switch {
case r.AddedWithinDays > 0 && !within(c.AddedAt, r.AddedWithinDays),
r.MinDurationSec > 0 && c.DurationMs < int64(r.MinDurationSec)*1000,
r.MaxDurationSec > 0 && c.DurationMs > int64(r.MaxDurationSec)*1000,
r.NeverPlayed && h.Plays > 0,
r.PlayedWithinDays > 0 && !within(h.LastPlayed, r.PlayedWithinDays),
r.NotPlayedWithinDays > 0 && within(h.LastPlayed, r.NotPlayedWithinDays),
r.MinPlays > 0 && h.Plays < r.MinPlays,
r.SkippedWithinDays > 0 && !within(h.SkippedAt, r.SkippedWithinDays),
r.NotSkippedWithinDays > 0 && within(h.SkippedAt, r.NotSkippedWithinDays),
r.LikedArtistsOnly && learned.Prefs[c.ArtistID].Preference <= 0,
r.WithoutAvoidedArtists && learned.Prefs[c.ArtistID].Preference < 0:
continue
}
kept = append(kept, c)
}
sortCandidates(kept, order, history, func(c Candidate) uint64 {
h := fnv.New64a()
fmt.Fprintf(h, "%d|%d|%d|%d|%d", userID, id, now.Unix()/86400, variant, c.TrackID)
return h.Sum64()
})
if len(kept) > limit {
kept = kept[:limit]
}
picked := make([]int64, len(kept))
for i, c := range kept {
picked[i] = c.TrackID
}
tracks, err := s.store.Tracks(ctx, picked)
if err != nil {
return nil, fmt.Errorf("read songs: %w", err)
}
return tracks, nil
}
// sortCandidates puts the songs in the order; a tie goes to the lower id. A random order sorts by the
// hash of the song with the seed of the day, which is the same until the day or the variant changes.
func sortCandidates(c []Candidate, order Sort, history map[int64]History, hash func(Candidate) uint64) {
var keys map[int64]uint64
if order == SortRandom {
keys = make(map[int64]uint64, len(c))
for _, x := range c {
keys[x.TrackID] = hash(x)
}
}
less := func(a, b Candidate) int {
switch order {
case SortRandom:
if ka, kb := keys[a.TrackID], keys[b.TrackID]; ka != kb {
if ka < kb {
return -1
}
return 1
}
case SortMostPlayed, SortLeastPlayed:
pa, pb := history[a.TrackID].Plays, history[b.TrackID].Plays
if order == SortLeastPlayed {
pa, pb = pb, pa
}
if pa != pb {
if pa > pb {
return -1
}
return 1
}
case SortRecentlyAdded:
if !a.AddedAt.Equal(b.AddedAt) {
if a.AddedAt.After(b.AddedAt) {
return -1
}
return 1
}
case SortTitle:
if a.Title != b.Title {
if a.Title < b.Title {
return -1
}
return 1
}
}
switch {
case a.TrackID < b.TrackID:
return -1
case a.TrackID > b.TrackID:
return 1
}
return 0
}
sort.SliceStable(c, func(i, j int) bool { return less(c[i], c[j]) < 0 })
}

View file

@ -0,0 +1,501 @@
package smart
import (
"context"
"errors"
"slices"
"testing"
"time"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/taste"
)
var now = time.Date(2026, 11, 12, 10, 0, 0, 0, time.UTC)
func daysAgo(n int) time.Time { return now.Add(-time.Duration(n) * 24 * time.Hour) }
// ---- a store in memory ----
type fakeStore struct {
genres []mixes.Genre
cands []Candidate
history map[int64]History
asked []Filter
saved map[int64]SmartPlaylist // by id
nextID int64
listened int // how many times history was read
}
func newStore() *fakeStore {
return &fakeStore{saved: map[int64]SmartPlaylist{}, history: map[int64]History{}}
}
func (f *fakeStore) Genres(context.Context) ([]mixes.Genre, error) { return f.genres, nil }
func (f *fakeStore) Candidates(_ context.Context, flt Filter) ([]Candidate, error) {
f.asked = append(f.asked, flt)
return f.cands, nil
}
func (f *fakeStore) History(context.Context, int64, time.Duration) (map[int64]History, error) {
f.listened++
return f.history, nil
}
func (f *fakeStore) Tracks(_ context.Context, ids []int64) ([]catalog.Track, error) {
out := make([]catalog.Track, len(ids))
for i, id := range ids {
out[i] = catalog.Track{ID: id, Title: "t"}
}
return out, nil
}
func (f *fakeStore) Create(_ context.Context, userID int64, p SmartPlaylist, at time.Time) (SmartPlaylist, error) {
f.nextID++
p.ID, p.CreatedAt, p.UpdatedAt = f.nextID, at, at
f.saved[p.ID] = p
return p, nil
}
func (f *fakeStore) List(context.Context, int64, int, int) ([]SmartPlaylist, int, error) {
return nil, 0, nil
}
func (f *fakeStore) Get(_ context.Context, _ int64, id int64) (SmartPlaylist, error) {
p, ok := f.saved[id]
if !ok {
return SmartPlaylist{}, ErrNotFound
}
return p, nil
}
func (f *fakeStore) Update(_ context.Context, _ int64, id int64, p SmartPlaylist, at time.Time) (SmartPlaylist, error) {
if _, ok := f.saved[id]; !ok {
return SmartPlaylist{}, ErrNotFound
}
p.ID, p.UpdatedAt = id, at
f.saved[id] = p
return p, nil
}
func (f *fakeStore) Delete(context.Context, int64, int64) error { return nil }
type fakeTaster struct{ learned taste.Learned }
func (f fakeTaster) Learn(context.Context, int64) (taste.Learned, error) { return f.learned, nil }
func newService(s *fakeStore, learned taste.Learned) *Service {
svc := NewService(s, fakeTaster{learned}, 20*time.Second)
svc.now = func() time.Time { return now }
return svc
}
// songs makes n candidates, numbered from 1: song i is by artist i, is i minutes long and was added i days ago.
func songs(n int) []Candidate {
out := make([]Candidate, n)
for i := range out {
k := i + 1
out[i] = Candidate{TrackID: int64(k), ArtistID: int64(k), Title: string(rune('a' + i)), DurationMs: int64(k) * 60_000, AddedAt: daysAgo(k)}
}
return out
}
func ids(tracks []catalog.Track) []int64 {
out := make([]int64, len(tracks))
for i, t := range tracks {
out[i] = t.ID
}
return out
}
// preview runs rules in the order given, with a limit big enough for every song.
func preview(t *testing.T, svc *Service, r Rules, sort Sort) []int64 {
t.Helper()
tracks, err := svc.Preview(context.Background(), 1, Input{Rules: r, Sort: sort, Limit: 500}, 0)
if err != nil {
t.Fatal(err)
}
return ids(tracks)
}
// ---- what the rules keep ----
func TestRulesAboutListening(t *testing.T) {
st := newStore()
st.cands = songs(6)
st.history = map[int64]History{
1: {Plays: 5, LastPlayed: daysAgo(2)}, // played lately, a lot
2: {Plays: 1, LastPlayed: daysAgo(40)}, // played long ago
3: {Plays: 0, SkippedAt: daysAgo(3)}, // only skipped, lately
4: {Plays: 2, LastPlayed: daysAgo(10), SkippedAt: daysAgo(1)}, // played, then skipped yesterday
// 5 and 6 were never touched
}
svc := newService(st, taste.Learned{})
for name, tc := range map[string]struct {
rules Rules
want []int64
}{
"no rule keeps every song": {Rules{}, []int64{1, 2, 3, 4, 5, 6}},
"never played": {Rules{NeverPlayed: true}, []int64{3, 5, 6}},
"played in the last 7 days": {Rules{PlayedWithinDays: 7}, []int64{1}},
"played in the last 30 days": {Rules{PlayedWithinDays: 30}, []int64{1, 4}},
"not played for 30 days": {Rules{NotPlayedWithinDays: 30}, []int64{2, 3, 5, 6}},
"played at least twice": {Rules{MinPlays: 2}, []int64{1, 4}},
"skipped in the last 2 days": {Rules{SkippedWithinDays: 2}, []int64{4}},
"skipped in the last 7 days": {Rules{SkippedWithinDays: 7}, []int64{3, 4}},
"not skipped in the last 7 days": {Rules{NotSkippedWithinDays: 7}, []int64{1, 2, 5, 6}},
"two rules must both hold": {Rules{NotPlayedWithinDays: 30, MinPlays: 1}, []int64{2}},
} {
t.Run(name, func(t *testing.T) {
got := preview(t, svc, tc.rules, SortTitle)
if !slices.Equal(got, tc.want) {
t.Errorf("got %v, want %v", got, tc.want)
}
})
}
}
func TestRulesAboutTheSongItself(t *testing.T) {
st := newStore()
st.cands = songs(6) // song k: k minutes, added k days ago
svc := newService(st, taste.Learned{})
for name, tc := range map[string]struct {
rules Rules
want []int64
}{
"added in the last 3 days": {Rules{AddedWithinDays: 3}, []int64{1, 2, 3}},
"at least 4 minutes": {Rules{MinDurationSec: 240}, []int64{4, 5, 6}},
"at most 2 minutes": {Rules{MaxDurationSec: 120}, []int64{1, 2}},
"between 2 and 4 minutes": {Rules{MinDurationSec: 120, MaxDurationSec: 240}, []int64{2, 3, 4}},
"added lately and long": {Rules{AddedWithinDays: 5, MinDurationSec: 180}, []int64{3, 4, 5}},
} {
t.Run(name, func(t *testing.T) {
got := preview(t, svc, tc.rules, SortTitle)
if !slices.Equal(got, tc.want) {
t.Errorf("got %v, want %v", got, tc.want)
}
})
}
}
func TestRulesAboutTaste(t *testing.T) {
st := newStore()
st.cands = songs(4)
learned := taste.Learned{Prefs: map[int64]taste.ArtistPref{
1: {ArtistID: 1, Preference: 0.8}, // loved
2: {ArtistID: 2, Preference: -0.5}, // avoided
3: {ArtistID: 3, Preference: 0}, // neutral
}}
svc := newService(st, learned) // artist 4 was never listened to
if got := preview(t, svc, Rules{LikedArtistsOnly: true}, SortTitle); !slices.Equal(got, []int64{1}) {
t.Errorf("liked artists only: %v, want [1]", got)
}
if got := preview(t, svc, Rules{WithoutAvoidedArtists: true}, SortTitle); !slices.Equal(got, []int64{1, 3, 4}) {
t.Errorf("without avoided artists: %v, want [1 3 4]", got)
}
if got := preview(t, svc, Rules{}, SortTitle); !slices.Equal(got, []int64{1, 2, 3, 4}) {
t.Errorf("no rule keeps the avoided artists too: %v", got)
}
}
// ---- the order ----
func TestTheOrders(t *testing.T) {
st := newStore()
st.cands = []Candidate{
{TrackID: 1, Title: "delta", AddedAt: daysAgo(10)},
{TrackID: 2, Title: "alpha", AddedAt: daysAgo(30)},
{TrackID: 3, Title: "charlie", AddedAt: daysAgo(1)},
{TrackID: 4, Title: "bravo", AddedAt: daysAgo(20)},
}
st.history = map[int64]History{1: {Plays: 3}, 2: {Plays: 9}, 4: {Plays: 3}}
svc := newService(st, taste.Learned{})
for name, tc := range map[string]struct {
sort Sort
want []int64
}{
"by title": {SortTitle, []int64{2, 4, 3, 1}},
"most played first": {SortMostPlayed, []int64{2, 1, 4, 3}}, // a tie goes to the lower id
"least played first": {SortLeastPlayed, []int64{3, 1, 4, 2}},
"recently added first": {SortRecentlyAdded, []int64{3, 1, 4, 2}},
} {
t.Run(name, func(t *testing.T) {
if got := preview(t, svc, Rules{}, tc.sort); !slices.Equal(got, tc.want) {
t.Errorf("got %v, want %v", got, tc.want)
}
})
}
}
func TestTheLimitCutsTheEndOfTheOrder(t *testing.T) {
st := newStore()
st.cands = songs(10)
svc := newService(st, taste.Learned{})
tracks, err := svc.Preview(context.Background(), 1, Input{Sort: SortTitle, Limit: 3}, 0)
if err != nil {
t.Fatal(err)
}
if got := ids(tracks); !slices.Equal(got, []int64{1, 2, 3}) {
t.Errorf("got %v, want the first three", got)
}
}
func TestRandomIsTheSameAllDayAndAnotherForAnotherVariantOrDay(t *testing.T) {
st := newStore()
st.cands = songs(40)
svc := newService(st, taste.Learned{})
run := func(variant int) []int64 {
tracks, err := svc.Preview(context.Background(), 1, Input{Sort: SortRandom, Limit: 10}, variant)
if err != nil {
t.Fatal(err)
}
return ids(tracks)
}
a := run(0)
if len(a) != 10 {
t.Fatalf("%d songs, want 10", len(a))
}
if b := run(0); !slices.Equal(a, b) {
t.Errorf("the same day and variant gave %v then %v", a, b)
}
if b := run(1); slices.Equal(a, b) {
t.Errorf("another variant gave the same songs: %v", a)
}
seen := map[int64]bool{}
for _, id := range a {
if seen[id] {
t.Errorf("song %d twice in %v", id, a)
}
seen[id] = true
}
svc.now = func() time.Time { return now.Add(24 * time.Hour) }
if b := run(0); slices.Equal(a, b) {
t.Errorf("the next day gave the same songs: %v", a)
}
// Another listener gets their own.
svc.now = func() time.Time { return now }
other, err := svc.Preview(context.Background(), 2, Input{Sort: SortRandom, Limit: 10}, 0)
if err != nil {
t.Fatal(err)
}
if slices.Equal(a, ids(other)) {
t.Errorf("another listener got the same songs: %v", a)
}
}
// ---- genres, as the files spell them ----
func TestAGenreIsAskedInEverySpellingTheFilesHave(t *testing.T) {
st := newStore()
st.genres = []mixes.Genre{{Name: "Jazz+Funk"}, {Name: "jazz-funk"}, {Name: "Jazz"}, {Name: "Rock"}, {Name: "Hard Rock"}, {Name: "other"}}
st.cands = songs(2)
svc := newService(st, taste.Learned{})
preview(t, svc, Rules{Genres: []string{"Jazz Funk", "rock"}, NotGenres: []string{"hard rock"}}, SortTitle)
got := st.asked[0]
slices.Sort(got.Genres)
if want := []string{"Jazz+Funk", "Rock", "jazz-funk"}; !slices.Equal(got.Genres, want) {
t.Errorf("genres asked = %v, want %v", got.Genres, want)
}
if want := []string{"Hard Rock"}; !slices.Equal(got.NotGenres, want) {
t.Errorf("genres left out = %v, want %v", got.NotGenres, want)
}
}
func TestAGenreNoFileHasGivesNoSongsAndAsksNothing(t *testing.T) {
st := newStore()
st.genres = []mixes.Genre{{Name: "Rock"}}
st.cands = songs(3)
svc := newService(st, taste.Learned{})
if got := preview(t, svc, Rules{Genres: []string{"polka"}}, SortTitle); len(got) != 0 {
t.Errorf("got %v, want no songs", got)
}
if len(st.asked) != 0 {
t.Errorf("the store was asked for songs: %v", st.asked)
}
// A genre to leave out that no file has leaves out nothing.
if got := preview(t, svc, Rules{NotGenres: []string{"polka"}}, SortTitle); len(got) != 3 {
t.Errorf("got %v, want every song", got)
}
}
func TestTheOtherRulesGoToTheStoreAsTheyAre(t *testing.T) {
st := newStore()
st.cands = songs(1)
svc := newService(st, taste.Learned{})
preview(t, svc, Rules{
ArtistIDs: []int64{1, 2}, NotArtistIDs: []int64{3}, AlbumIDs: []int64{4}, NotAlbumIDs: []int64{5, 6},
Formats: []string{"FLAC", " mpeg "}, MinBitrateKbps: 900,
}, SortTitle)
f := st.asked[0]
if !slices.Equal(f.ArtistIDs, []int64{1, 2}) || !slices.Equal(f.NotArtistIDs, []int64{3}) ||
!slices.Equal(f.AlbumIDs, []int64{4}) || !slices.Equal(f.NotAlbumIDs, []int64{5, 6}) {
t.Errorf("filter = %+v", f)
}
if !slices.Equal(f.Formats, []string{"flac", "mpeg"}) || f.MinBitrateKbps != 900 {
t.Errorf("formats = %v, bitrate = %d", f.Formats, f.MinBitrateKbps)
}
}
func TestHistoryIsReadOnlyWhenARuleNeedsIt(t *testing.T) {
st := newStore()
st.cands = songs(3)
svc := newService(st, taste.Learned{})
preview(t, svc, Rules{AddedWithinDays: 30}, SortTitle)
preview(t, svc, Rules{}, SortRandom)
if st.listened != 0 {
t.Errorf("history was read %d times for rules that do not use it", st.listened)
}
preview(t, svc, Rules{}, SortMostPlayed)
preview(t, svc, Rules{NeverPlayed: true}, SortTitle)
if st.listened != 2 {
t.Errorf("history was read %d times, want 2", st.listened)
}
}
// ---- what is accepted ----
func TestCreateFillsInTheDefaultsAndCleansTheText(t *testing.T) {
st := newStore()
svc := newService(st, taste.Learned{})
p, err := svc.Create(context.Background(), 1, Input{Name: " Fresh ", Description: " lately added ", Rules: Rules{AddedWithinDays: 30, Genres: []string{" Rock "}}})
if err != nil {
t.Fatal(err)
}
if p.Name != "Fresh" || p.Description != "lately added" || p.Sort != SortRandom || p.Limit != DefaultLimit {
t.Errorf("playlist = %+v", p)
}
if !slices.Equal(p.Rules.Genres, []string{"rock"}) {
t.Errorf("genres = %v: they are kept as they are compared", p.Rules.Genres)
}
if p.CreatedAt != now {
t.Errorf("created at %v, want %v", p.CreatedAt, now)
}
}
func TestWhatIsRefused(t *testing.T) {
long := make([]string, MaxListed+1)
for i := range long {
long[i] = "x"
}
longIDs := make([]int64, MaxListed+1)
for i := range longIDs {
longIDs[i] = int64(i + 1)
}
aboutTheName := map[string]bool{"no name": true, "a name that is too long": true}
for name, in := range map[string]Input{
"no name": {Name: " "},
"a name that is too long": {Name: string(make([]byte, MaxNameLen+1))},
"a description too long": {Name: "a", Description: string(make([]rune, MaxDescriptionLen+1))},
"an unknown order": {Name: "a", Sort: "loudest"},
"a limit below 1": {Name: "a", Limit: -1},
"a limit over the maximum": {Name: "a", Limit: MaxLimit + 1},
"too many genres": {Name: "a", Rules: Rules{Genres: long}},
"too many artists": {Name: "a", Rules: Rules{ArtistIDs: longIDs}},
"a blank genre": {Name: "a", Rules: Rules{Genres: []string{" "}}},
"a genre that is not one": {Name: "a", Rules: Rules{Genres: []string{"unknown"}}},
"an id below 1": {Name: "a", Rules: Rules{AlbumIDs: []int64{0}}},
"a format with a symbol": {Name: "a", Rules: Rules{Formats: []string{"fl/ac"}}},
"a negative number of days": {Name: "a", Rules: Rules{PlayedWithinDays: -1}},
"too many days": {Name: "a", Rules: Rules{AddedWithinDays: MaxDays + 1}},
"a negative minimum": {Name: "a", Rules: Rules{MinPlays: -1}},
"a negative bitrate": {Name: "a", Rules: Rules{MinBitrateKbps: -1}},
"a minimum over a maximum": {Name: "a", Rules: Rules{MinDurationSec: 200, MaxDurationSec: 100}},
} {
t.Run(name, func(t *testing.T) {
if _, err := newService(newStore(), taste.Learned{}).Create(context.Background(), 1, in); !errors.Is(err, ErrInvalidInput) {
t.Errorf("err = %v, want ErrInvalidInput", err)
}
if aboutTheName[name] {
return // a preview has no name
}
if _, err := newService(newStore(), taste.Learned{}).Preview(context.Background(), 1, in, 0); !errors.Is(err, ErrInvalidInput) {
t.Errorf("preview: err = %v, want ErrInvalidInput", err)
}
})
}
if _, err := newService(newStore(), taste.Learned{}).Preview(context.Background(), 1, Input{}, mixes.MaxVariant+1); !errors.Is(err, ErrInvalidInput) {
t.Errorf("a variant that is too big: err = %v", err)
}
}
func TestAPreviewNeedsNoName(t *testing.T) {
st := newStore()
st.cands = songs(2)
if _, err := newService(st, taste.Learned{}).Preview(context.Background(), 1, Input{Sort: SortTitle}, 0); err != nil {
t.Errorf("err = %v", err)
}
}
// ---- keeping and reading a smart playlist ----
func TestTracksRunsTheRulesOfASavedPlaylist(t *testing.T) {
st := newStore()
st.cands = songs(8)
svc := newService(st, taste.Learned{})
p, err := svc.Create(context.Background(), 1, Input{Name: "Short", Rules: Rules{MaxDurationSec: 240}, Sort: SortTitle, Limit: 3})
if err != nil {
t.Fatal(err)
}
got, tracks, err := svc.Tracks(context.Background(), 1, p.ID, 0)
if err != nil {
t.Fatal(err)
}
if got.ID != p.ID || !slices.Equal(ids(tracks), []int64{1, 2, 3}) {
t.Errorf("playlist %d, songs %v", got.ID, ids(tracks))
}
if _, _, err := svc.Tracks(context.Background(), 1, 99, 0); !errors.Is(err, ErrNotFound) {
t.Errorf("err = %v, want ErrNotFound", err)
}
}
func TestUpdateChangesWhatWasSentAndChecksIt(t *testing.T) {
st := newStore()
svc := newService(st, taste.Learned{})
p, _ := svc.Create(context.Background(), 1, Input{Name: "A", Description: "d", Rules: Rules{NeverPlayed: true}, Sort: SortTitle, Limit: 20})
name, sort, limit := "B", SortMostPlayed, 30
got, err := svc.Update(context.Background(), 1, p.ID, Patch{Name: &name, Sort: &sort, Limit: &limit, Rules: &Rules{MinPlays: 3}})
if err != nil {
t.Fatal(err)
}
if got.Name != "B" || got.Description != "d" || got.Sort != SortMostPlayed || got.Limit != 30 || got.Rules.MinPlays != 3 || got.Rules.NeverPlayed {
t.Errorf("playlist = %+v: the rules are replaced whole, the rest only when sent", got)
}
if !got.UpdatedAt.Equal(now) {
t.Errorf("updated at %v", got.UpdatedAt)
}
bad := ""
if _, err := svc.Update(context.Background(), 1, p.ID, Patch{Name: &bad}); !errors.Is(err, ErrInvalidInput) {
t.Errorf("blank name: err = %v", err)
}
if _, err := svc.Update(context.Background(), 1, p.ID, Patch{Rules: &Rules{MinPlays: -1}}); !errors.Is(err, ErrInvalidInput) {
t.Errorf("bad rules: err = %v", err)
}
if _, err := svc.Update(context.Background(), 1, 99, Patch{Name: &name}); !errors.Is(err, ErrNotFound) {
t.Errorf("unknown playlist: err = %v", err)
}
}
func TestListLowersAPageThatIsTooBigAndRefusesNegatives(t *testing.T) {
svc := newService(newStore(), taste.Learned{})
for _, tc := range []struct{ in, want int }{{0, DefaultPageLimit}, {10, 10}, {MaxPageLimit + 1, MaxPageLimit}} {
l, err := svc.List(context.Background(), 1, tc.in, 0)
if err != nil || l.Limit != tc.want {
t.Errorf("limit %d: got %d, %v; want %d", tc.in, l.Limit, err, tc.want)
}
}
if _, err := svc.List(context.Background(), 1, -1, 0); !errors.Is(err, ErrInvalidInput) {
t.Errorf("a negative limit: %v", err)
}
if _, err := svc.List(context.Background(), 1, 10, -1); !errors.Is(err, ErrInvalidInput) {
t.Errorf("a negative offset: %v", err)
}
}

241
internal/storage/smart.go Normal file
View file

@ -0,0 +1,241 @@
package storage
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/smart"
)
// SmartRepo stores smart playlists and reads the songs their rules choose from. It implements smart.Store.
type SmartRepo struct {
db *bun.DB
mix *MixRepo // reads the genres, the history and the songs, as the mixes do
}
// NewSmartRepo builds a SmartRepo.
func NewSmartRepo(db *bun.DB) *SmartRepo { return &SmartRepo{db: db, mix: NewMixRepo(db)} }
const smartColumns = "id, name, description, rules, sort, max_tracks, created_at, updated_at"
func scanSmart(rows interface{ Scan(...any) error }) (smart.SmartPlaylist, error) {
var (
p smart.SmartPlaylist
rules, sort string
created, updated int64
)
if err := rows.Scan(&p.ID, &p.Name, &p.Description, &rules, &sort, &p.Limit, &created, &updated); err != nil {
return smart.SmartPlaylist{}, err
}
if err := json.Unmarshal([]byte(rules), &p.Rules); err != nil {
return smart.SmartPlaylist{}, fmt.Errorf("read the rules of smart playlist %d: %w", p.ID, err)
}
p.Sort = smart.Sort(sort)
p.CreatedAt, p.UpdatedAt = time.Unix(created, 0), time.Unix(updated, 0)
return p, nil
}
func (r *SmartRepo) get(ctx context.Context, db bun.IDB, userID, id int64) (smart.SmartPlaylist, error) {
p, err := scanSmart(db.QueryRowContext(ctx, "SELECT "+smartColumns+" FROM smart_playlists WHERE id = ? AND user_id = ?", id, userID))
if errors.Is(err, sql.ErrNoRows) {
return smart.SmartPlaylist{}, smart.ErrNotFound
}
if err != nil {
return smart.SmartPlaylist{}, fmt.Errorf("read smart playlist: %w", err)
}
return p, nil
}
// Create keeps a smart playlist.
func (r *SmartRepo) Create(ctx context.Context, userID int64, p smart.SmartPlaylist, now time.Time) (smart.SmartPlaylist, error) {
rules, err := json.Marshal(p.Rules)
if err != nil {
return smart.SmartPlaylist{}, fmt.Errorf("write the rules: %w", err)
}
var out smart.SmartPlaylist
err = r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
// The row of the user is the lock that makes the count below hold for two requests at once.
res, err := tx.ExecContext(ctx, "UPDATE users SET is_admin = is_admin WHERE id = ?", userID)
if err != nil {
return fmt.Errorf("lock user: %w", err)
}
if n, _ := res.RowsAffected(); n == 0 {
return smart.ErrNotFound // the account is gone
}
var have int
if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM smart_playlists WHERE user_id = ?", userID).Scan(&have); err != nil {
return fmt.Errorf("count smart playlists: %w", err)
}
if have >= smart.MaxPlaylists {
return fmt.Errorf("%w: a user can have %d smart playlists", smart.ErrTooMany, smart.MaxPlaylists)
}
var id int64
err = tx.QueryRowContext(ctx,
`INSERT INTO smart_playlists (user_id, name, description, rules, sort, max_tracks, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING id`,
userID, p.Name, p.Description, string(rules), string(p.Sort), p.Limit, now.Unix(), now.Unix()).Scan(&id)
if err != nil {
return fmt.Errorf("insert smart playlist: %w", err)
}
out, err = r.get(ctx, tx, userID, id)
return err
})
return out, err
}
// List returns a page of the user's smart playlists, the one changed last first.
func (r *SmartRepo) List(ctx context.Context, userID int64, limit, offset int) ([]smart.SmartPlaylist, int, error) {
var total int
if err := r.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM smart_playlists WHERE user_id = ?", userID).Scan(&total); err != nil {
return nil, 0, fmt.Errorf("count smart playlists: %w", err)
}
rows, err := r.db.QueryContext(ctx,
"SELECT "+smartColumns+" FROM smart_playlists WHERE user_id = ? ORDER BY updated_at DESC, id DESC LIMIT ? OFFSET ?",
userID, limit, offset)
if err != nil {
return nil, 0, fmt.Errorf("list smart playlists: %w", err)
}
defer rows.Close()
out := []smart.SmartPlaylist{}
for rows.Next() {
p, err := scanSmart(rows)
if err != nil {
return nil, 0, err
}
out = append(out, p)
}
return out, total, rows.Err()
}
// Get returns a smart playlist of the user.
func (r *SmartRepo) Get(ctx context.Context, userID, id int64) (smart.SmartPlaylist, error) {
return r.get(ctx, r.db, userID, id)
}
// Update replaces what a smart playlist says.
func (r *SmartRepo) Update(ctx context.Context, userID, id int64, p smart.SmartPlaylist, now time.Time) (smart.SmartPlaylist, error) {
rules, err := json.Marshal(p.Rules)
if err != nil {
return smart.SmartPlaylist{}, fmt.Errorf("write the rules: %w", err)
}
var out smart.SmartPlaylist
err = r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
res, err := tx.ExecContext(ctx,
"UPDATE smart_playlists SET name = ?, description = ?, rules = ?, sort = ?, max_tracks = ?, updated_at = ? WHERE id = ? AND user_id = ?",
p.Name, p.Description, string(rules), string(p.Sort), p.Limit, now.Unix(), id, userID)
if err := affectedOrNotFoundSmart(res, err); err != nil {
return err
}
out, err = r.get(ctx, tx, userID, id)
return err
})
return out, err
}
func affectedOrNotFoundSmart(res sql.Result, err error) error {
if err != nil {
return fmt.Errorf("change smart playlist: %w", err)
}
if n, _ := res.RowsAffected(); n == 0 {
return smart.ErrNotFound
}
return nil
}
// Delete removes a smart playlist of the user.
func (r *SmartRepo) Delete(ctx context.Context, userID, id int64) error {
res, err := r.db.ExecContext(ctx, "DELETE FROM smart_playlists WHERE id = ? AND user_id = ?", id, userID)
return affectedOrNotFoundSmart(res, err)
}
// Genres returns every genre of the playable songs as the files spell it.
func (r *SmartRepo) Genres(ctx context.Context) ([]mixes.Genre, error) { return r.mix.Genres(ctx) }
// History returns what the user did with each song they did anything with.
func (r *SmartRepo) History(ctx context.Context, userID int64, minListen time.Duration) (map[int64]smart.History, error) {
return r.mix.History(ctx, userID, minListen)
}
// Tracks returns the playable songs among ids, in the order given.
func (r *SmartRepo) Tracks(ctx context.Context, ids []int64) ([]catalog.Track, error) {
return r.mix.Tracks(ctx, ids)
}
// Candidates returns the playable songs that the filter keeps, with their main artist (the one with the
// lowest id when there are several), the key of the title, the length and the date of the newest file.
func (r *SmartRepo) Candidates(ctx context.Context, f smart.Filter) ([]smart.Candidate, error) {
vis, _ := visible("t", 0)
conds := []string{vis}
var args []any
add := func(cond string, a ...any) {
conds = append(conds, cond)
args = append(args, a...)
}
const genre = "EXISTS (SELECT 1 FROM track_genres g WHERE g.track_id = t.id AND g.genre IN (?))"
const artist = "EXISTS (SELECT 1 FROM track_artists x WHERE x.track_id = t.id AND x.role = 'main' AND x.artist_id IN (?))"
if len(f.Genres) > 0 {
add(genre, bun.In(f.Genres))
}
if len(f.NotGenres) > 0 {
add("NOT "+genre, bun.In(f.NotGenres))
}
if len(f.ArtistIDs) > 0 {
add(artist, bun.In(f.ArtistIDs))
}
if len(f.NotArtistIDs) > 0 {
add("NOT "+artist, bun.In(f.NotArtistIDs))
}
if len(f.AlbumIDs) > 0 {
add("t.album_id IN (?)", bun.In(f.AlbumIDs))
}
if len(f.NotAlbumIDs) > 0 {
add("(t.album_id IS NULL OR t.album_id NOT IN (?))", bun.In(f.NotAlbumIDs))
}
if len(f.Formats) > 0 || f.MinBitrateKbps > 0 {
file := "EXISTS (SELECT 1 FROM audio_files f WHERE f.track_id = t.id AND f.missing_at IS NULL"
var fargs []any
if len(f.Formats) > 0 {
file += " AND f.format IN (?)"
fargs = append(fargs, bun.In(f.Formats))
}
if f.MinBitrateKbps > 0 {
file += " AND f.bitrate >= ?"
fargs = append(fargs, f.MinBitrateKbps)
}
add(file+")", fargs...)
}
rows, err := r.db.QueryContext(ctx,
`SELECT t.id,
COALESCE((SELECT MIN(ta.artist_id) FROM track_artists ta WHERE ta.track_id = t.id AND ta.role = 'main'), 0),
t.title_key, COALESCE(t.duration_ms, 0),
COALESCE((SELECT MAX(f.mtime_unix) FROM audio_files f WHERE f.track_id = t.id AND f.missing_at IS NULL), 0)
FROM tracks t WHERE `+strings.Join(conds, " AND ")+` ORDER BY t.id`, args...)
if err != nil {
return nil, fmt.Errorf("read the songs: %w", err)
}
defer rows.Close()
out := []smart.Candidate{}
for rows.Next() {
var (
c smart.Candidate
added int64
)
if err := rows.Scan(&c.TrackID, &c.ArtistID, &c.Title, &c.DurationMs, &added); err != nil {
return nil, err
}
if added > 0 {
c.AddedAt = time.Unix(added, 0)
}
out = append(out, c)
}
return out, rows.Err()
}

View file

@ -0,0 +1,333 @@
package storage
import (
"context"
"errors"
"slices"
"testing"
"time"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/smart"
)
// smartEnv is two users and a library of songs that differ in what the rules ask about.
type smartEnv struct {
t *testing.T
db *bun.DB
repo *SmartRepo
alice int64
bob int64
tracks map[string]int64
artist map[string]int64
album map[string]int64
now time.Time
}
type smartSong struct {
title, artist, album, format string
genres []string
bitrate int
mtime int64
seconds int64
}
func newSmartEnv(t *testing.T, db *bun.DB, songs []smartSong) *smartEnv {
t.Helper()
ctx := context.Background()
users := NewUserRepo(db)
a, err := users.CreateUser(ctx, "alice@example.org", "hash", false)
if err != nil {
t.Fatal(err)
}
b, err := users.CreateUser(ctx, "bob@example.org", "hash", false)
if err != nil {
t.Fatal(err)
}
lib := NewLibraryRepo(db)
l, err := lib.CreateLibrary(ctx, "m", "/lib/m")
if err != nil {
t.Fatal(err)
}
e := &smartEnv{t: t, db: db, repo: NewSmartRepo(db), alice: a.ID, bob: b.ID, now: time.Unix(1_700_000_000, 0),
tracks: map[string]int64{}, artist: map[string]int64{}, album: map[string]int64{}}
for i, s := range songs {
f := pf("x/"+s.title+"."+s.format, s.title, s.album, s.artist, i+1, 1, s.format, s.artist)
f.Tags.Genres = s.genres
f.BitRate = s.bitrate
f.MTimeUnix = s.mtime
if s.seconds > 0 {
f.DurationMs = s.seconds * 1000
}
if _, err := lib.SaveFile(ctx, l.ID, f, 0); err != nil {
t.Fatal(err)
}
var id int64
if err := db.QueryRow("SELECT id FROM tracks WHERE title = ?", s.title).Scan(&id); err != nil {
t.Fatal(err)
}
e.tracks[s.title] = id
}
for _, q := range []struct {
sql string
to map[string]int64
}{{"SELECT id, name FROM artists", e.artist}, {"SELECT id, title FROM albums", e.album}} {
rows, err := db.Query(q.sql)
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
var name string
if err := rows.Scan(&id, &name); err != nil {
t.Fatal(err)
}
q.to[name] = id
}
rows.Close()
}
return e
}
func (e *smartEnv) tick() time.Time { e.now = e.now.Add(time.Minute); return e.now }
func smartBackends(t *testing.T, songs []smartSong, fn func(t *testing.T, e *smartEnv)) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) { fn(t, newSmartEnv(t, db, songs)) })
}
var smartSongs = []smartSong{
{"a", "Queen", "News", "flac", []string{"rock", "classic rock"}, 1000, 1_000, 120},
{"b", "Queen", "News", "mpeg", []string{"rock"}, 320, 2_000, 200},
{"c", "Kiss", "Alive", "mpeg", []string{"rock", "hard rock"}, 192, 3_000, 240},
{"d", "Slayer", "Reign", "flac", []string{"metal"}, 800, 4_000, 180},
{"e", "Miles", "Blue", "flac", []string{"jazz+funk"}, 1100, 5_000, 300},
}
func names(e *smartEnv, cands []smart.Candidate) []string {
byID := map[int64]string{}
for k, v := range e.tracks {
byID[v] = k
}
out := make([]string, len(cands))
for i, c := range cands {
out[i] = byID[c.TrackID]
}
slices.Sort(out)
return out
}
func TestSmartRepoCandidatesNarrowByEveryList(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
for name, tc := range map[string]struct {
f smart.Filter
want []string
}{
"no filter: every playable song": {smart.Filter{}, []string{"a", "b", "c", "d", "e"}},
"a genre": {smart.Filter{Genres: []string{"rock"}}, []string{"a", "b", "c"}},
"one of two genres": {smart.Filter{Genres: []string{"metal", "jazz+funk"}}, []string{"d", "e"}},
"not a genre": {smart.Filter{NotGenres: []string{"hard rock", "metal"}}, []string{"a", "b", "e"}},
"a genre and not another": {smart.Filter{Genres: []string{"rock"}, NotGenres: []string{"hard rock"}}, []string{"a", "b"}},
"an artist": {smart.Filter{ArtistIDs: []int64{e.artist["Queen"]}}, []string{"a", "b"}},
"not an artist": {smart.Filter{NotArtistIDs: []int64{e.artist["Queen"], e.artist["Kiss"]}}, []string{"d", "e"}},
"an album": {smart.Filter{AlbumIDs: []int64{e.album["Alive"]}}, []string{"c"}},
"not an album": {smart.Filter{NotAlbumIDs: []int64{e.album["News"]}}, []string{"c", "d", "e"}},
"a format": {smart.Filter{Formats: []string{"mpeg"}}, []string{"b", "c"}},
"two formats": {smart.Filter{Formats: []string{"mpeg", "flac"}}, []string{"a", "b", "c", "d", "e"}},
"a bitrate": {smart.Filter{MinBitrateKbps: 900}, []string{"a", "e"}},
"a format and a bitrate": {smart.Filter{Formats: []string{"flac"}, MinBitrateKbps: 900}, []string{"a", "e"}},
"a format that nothing has": {smart.Filter{Formats: []string{"ogg"}}, []string{}},
"two lists must both hold": {smart.Filter{Genres: []string{"rock"}, Formats: []string{"flac"}}, []string{"a"}},
} {
t.Run(name, func(t *testing.T) {
got, err := e.repo.Candidates(ctx, tc.f)
if err != nil {
t.Fatal(err)
}
if g := names(e, got); !slices.Equal(g, tc.want) {
t.Errorf("got %v, want %v", g, tc.want)
}
})
}
})
}
func TestSmartRepoAFormatAndABitrateAreAboutTheSameFile(t *testing.T) {
songs := []smartSong{{"a", "Queen", "News", "flac", nil, 500, 1, 60}}
smartBackends(t, songs, func(t *testing.T, e *smartEnv) {
// A second file of the same song: an mp3 with a high bitrate. flac AND 900 holds for no file.
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix, bitrate)
SELECT track_id, library_id, 'x/a.mp3', 'mpeg', 1, 9000, 1000 FROM audio_files LIMIT 1`); err != nil {
t.Fatal(err)
}
got, err := e.repo.Candidates(context.Background(), smart.Filter{Formats: []string{"flac"}, MinBitrateKbps: 900})
if err != nil {
t.Fatal(err)
}
if len(got) != 0 {
t.Errorf("got %v: the format and the bitrate belong to one file", names(e, got))
}
got, _ = e.repo.Candidates(context.Background(), smart.Filter{Formats: []string{"mpeg"}, MinBitrateKbps: 900})
if len(got) != 1 {
t.Errorf("the mp3 file has both: got %v", names(e, got))
}
})
}
func TestSmartRepoCandidatesGiveWhatTheRulesNeedAndLeaveOutSongsWithNoFile(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
if _, err := e.db.Exec("UPDATE audio_files SET missing_at = 1 WHERE track_id = ?", e.tracks["e"]); err != nil {
t.Fatal(err)
}
got, err := e.repo.Candidates(ctx, smart.Filter{})
if err != nil {
t.Fatal(err)
}
if g := names(e, got); !slices.Equal(g, []string{"a", "b", "c", "d"}) {
t.Errorf("got %v: a song whose files are gone is not offered", g)
}
for _, c := range got {
if c.TrackID != e.tracks["c"] {
continue
}
if c.ArtistID != e.artist["Kiss"] || c.DurationMs != 240_000 || c.Title != "c" || !c.AddedAt.Equal(time.Unix(3_000, 0)) {
t.Errorf("candidate = %+v", c)
}
}
// The date is the newest file that is not missing.
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix)
SELECT track_id, library_id, 'x/c2.mpeg', 'mpeg', 1, 7000 FROM audio_files WHERE track_id = ? LIMIT 1`, e.tracks["c"]); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix, missing_at)
SELECT track_id, library_id, 'x/c3.mpeg', 'mpeg', 1, 9000, 5 FROM audio_files WHERE track_id = ? LIMIT 1`, e.tracks["c"]); err != nil {
t.Fatal(err)
}
got, _ = e.repo.Candidates(ctx, smart.Filter{ArtistIDs: []int64{e.artist["Kiss"]}})
if len(got) != 1 || !got[0].AddedAt.Equal(time.Unix(7_000, 0)) {
t.Errorf("got %+v, want one song added at 7000", got)
}
})
}
func sample() smart.SmartPlaylist {
return smart.SmartPlaylist{
Name: "Fresh", Description: "new things", Sort: smart.SortRecentlyAdded, Limit: 30,
Rules: smart.Rules{Genres: []string{"rock"}, ArtistIDs: []int64{3, 4}, Formats: []string{"flac"}, MinBitrateKbps: 900, AddedWithinDays: 30, NeverPlayed: true, MinDurationSec: 60},
}
}
func TestSmartRepoKeepsAPlaylistAndItsRulesPerUser(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
p, err := e.repo.Create(ctx, e.alice, sample(), e.tick())
if err != nil {
t.Fatal(err)
}
want := sample()
want.ID, want.CreatedAt, want.UpdatedAt = p.ID, e.now, e.now
if p.ID == 0 || p.Name != want.Name || p.Description != want.Description || p.Sort != want.Sort || p.Limit != want.Limit ||
!slices.Equal(p.Rules.Genres, want.Rules.Genres) || !slices.Equal(p.Rules.ArtistIDs, want.Rules.ArtistIDs) ||
!slices.Equal(p.Rules.Formats, want.Rules.Formats) || p.Rules.MinBitrateKbps != 900 || p.Rules.AddedWithinDays != 30 ||
!p.Rules.NeverPlayed || p.Rules.MinDurationSec != 60 || !p.CreatedAt.Equal(e.now) || !p.UpdatedAt.Equal(e.now) {
t.Errorf("created = %+v, want %+v", p, want)
}
got, err := e.repo.Get(ctx, e.alice, p.ID)
if err != nil || got.Name != "Fresh" || !slices.Equal(got.Rules.Genres, []string{"rock"}) {
t.Errorf("get = %+v, %v", got, err)
}
// Somebody else's is as if it did not exist, whatever is done to it.
if _, err := e.repo.Get(ctx, e.bob, p.ID); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("get by another user: %v", err)
}
if _, err := e.repo.Update(ctx, e.bob, p.ID, sample(), e.tick()); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("update by another user: %v", err)
}
if err := e.repo.Delete(ctx, e.bob, p.ID); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("delete by another user: %v", err)
}
if got, _ := e.repo.Get(ctx, e.alice, p.ID); got.Name != "Fresh" {
t.Errorf("the playlist changed: %+v", got)
}
if _, err := e.repo.Get(ctx, e.alice, p.ID+100); !errors.Is(err, smart.ErrNotFound) {
t.Errorf("get of nothing: %v", err)
}
})
}
func TestSmartRepoListsTheOneChangedLastFirstInPages(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
var ids []int64
for _, n := range []string{"one", "two", "three"} {
p := sample()
p.Name = n
made, err := e.repo.Create(ctx, e.alice, p, e.tick())
if err != nil {
t.Fatal(err)
}
ids = append(ids, made.ID)
}
other := sample()
other.Name = "bob's"
if _, err := e.repo.Create(ctx, e.bob, other, e.tick()); err != nil {
t.Fatal(err)
}
// Changing "one" brings it to the top.
upd := sample()
upd.Name = "one, again"
if _, err := e.repo.Update(ctx, e.alice, ids[0], upd, e.tick()); err != nil {
t.Fatal(err)
}
list, total, err := e.repo.List(ctx, e.alice, 2, 0)
if err != nil || total != 3 || len(list) != 2 || list[0].Name != "one, again" || list[1].Name != "three" {
t.Fatalf("page 1 = %+v, total %d, %v", list, total, err)
}
list, _, _ = e.repo.List(ctx, e.alice, 2, 2)
if len(list) != 1 || list[0].Name != "two" {
t.Errorf("page 2 = %+v", list)
}
if err := e.repo.Delete(ctx, e.alice, ids[1]); err != nil {
t.Fatal(err)
}
if _, total, _ := e.repo.List(ctx, e.alice, 10, 0); total != 2 {
t.Errorf("total after a delete = %d", total)
}
})
}
func TestSmartRepoStopsAtTheMostASmartPlaylistsAUserCanHave(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
for i := 0; i < smart.MaxPlaylists; i++ {
if _, err := e.repo.Create(ctx, e.alice, sample(), e.tick()); err != nil {
t.Fatalf("playlist %d: %v", i+1, err)
}
}
if _, err := e.repo.Create(ctx, e.alice, sample(), e.tick()); !errors.Is(err, smart.ErrTooMany) {
t.Errorf("err = %v, want ErrTooMany", err)
}
if _, err := e.repo.Create(ctx, e.bob, sample(), e.tick()); err != nil {
t.Errorf("another user is not held back: %v", err)
}
})
}
func TestSmartPlaylistsGoWhenTheirOwnerGoes(t *testing.T) {
smartBackends(t, smartSongs, func(t *testing.T, e *smartEnv) {
ctx := context.Background()
if _, err := e.repo.Create(ctx, e.bob, sample(), e.tick()); err != nil {
t.Fatal(err)
}
if _, err := e.db.Exec("DELETE FROM users WHERE id = ?", e.bob); err != nil {
t.Fatal(err)
}
var n int
if err := e.db.QueryRow("SELECT COUNT(*) FROM smart_playlists").Scan(&n); err != nil || n != 0 {
t.Errorf("%d smart playlists left, %v", n, err)
}
})
}

View file

@ -156,8 +156,8 @@ func TestMigrateCreatesSchemaAndIsIdempotent(t *testing.T) {
if err := db.QueryRow("SELECT COUNT(*) FROM schema_migrations").Scan(&applied); err != nil {
t.Fatal(err)
}
if applied != 19 {
t.Errorf("applied migrations = %d, want 19", applied)
if applied != 20 {
t.Errorf("applied migrations = %d, want 20", applied)
}
})
}