Merge remote-tracking branch 'origin/main' into feat/duplicates-api
This commit is contained in:
commit
3d986f051d
11 changed files with 2732 additions and 2 deletions
|
|
@ -26,6 +26,7 @@ import (
|
|||
"codeberg.org/squidd/sonda/internal/jobs"
|
||||
"codeberg.org/squidd/sonda/internal/library"
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
"codeberg.org/squidd/sonda/internal/playlists"
|
||||
"codeberg.org/squidd/sonda/internal/providers"
|
||||
"codeberg.org/squidd/sonda/internal/storage"
|
||||
"codeberg.org/squidd/sonda/internal/streaming"
|
||||
|
|
@ -104,6 +105,7 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
|
|||
}
|
||||
feedbackSvc := feedback.NewService(storage.NewFeedbackRepo(db))
|
||||
deps.Feedback = feedbackSvc
|
||||
deps.Playlists = playlists.NewService(storage.NewPlaylistRepo(db))
|
||||
imageRepo := storage.NewImageRepo(db)
|
||||
imageSvc := images.NewService(filepath.Join(t.TempDir(), "data"), imageRepo, imageRepo)
|
||||
deps.Images, deps.ArtistImages = imageSvc, imageSvc
|
||||
|
|
|
|||
|
|
@ -282,6 +282,15 @@ func (c *contract) expect(rec *httptest.ResponseRecorder, want int, what string,
|
|||
return out
|
||||
}
|
||||
|
||||
func mustInt(t *testing.T, s string) int64 {
|
||||
t.Helper()
|
||||
n, err := strconv.ParseInt(s, 10, 64)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func idOf(m map[string]any) string { return strconv.FormatInt(int64(m["id"].(float64)), 10) }
|
||||
|
||||
// scanDone waits for the running scan to finish.
|
||||
|
|
@ -742,6 +751,42 @@ func TestResponsesMatchTheSpec(t *testing.T) {
|
|||
}
|
||||
c.expect(c.call("PATCH", "/me/settings", token, map[string]any{"discover_from_listening": false}), 200, "forbid it again")
|
||||
|
||||
// ---- playlists ----
|
||||
c.expect(c.call("GET", "/playlists", "", nil), 401, "playlists without a token", "unauthorized")
|
||||
c.expect(c.call("POST", "/playlists", token, map[string]string{"name": " "}), 400, "playlist with a blank name", "invalid_input")
|
||||
plID := idOf(c.expect(c.call("POST", "/playlists", token, map[string]string{"name": "Road trip", "description": "for the car"}), 201, "create a playlist"))
|
||||
if pls := c.expect(c.call("GET", "/playlists?limit=5", token, nil), 200, "list playlists"); pls["total"] != float64(1) {
|
||||
t.Fatalf("playlists = %v", pls)
|
||||
}
|
||||
c.expect(c.call("GET", "/playlists?limit=-1", token, nil), 400, "playlists with a bad limit", "invalid_input")
|
||||
c.expect(c.call("GET", "/playlists/"+plID, token, nil), 200, "get a playlist")
|
||||
c.expect(c.call("GET", "/playlists/999", token, nil), 404, "get an unknown playlist", "playlist_not_found")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID, token, map[string]string{"name": "Road trip 2"}), 200, "rename a playlist")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID, token, map[string]string{}), 400, "patch a playlist with nothing", "invalid_input")
|
||||
c.expect(c.call("PATCH", "/playlists/999", token, map[string]string{"name": "x"}), 404, "patch an unknown playlist", "playlist_not_found")
|
||||
c.expect(c.call("POST", "/playlists/"+plID+"/tracks", token, map[string]any{"track_ids": []string{trackID, trackID}}), 400, "track ids as strings", "invalid_input")
|
||||
if pl := c.expect(c.call("POST", "/playlists/"+plID+"/tracks", token, map[string]any{"track_ids": []int64{mustInt(t, trackID), mustInt(t, trackID)}}), 200, "add tracks to a playlist"); pl["track_count"] != float64(2) {
|
||||
t.Fatalf("playlist = %v", pl)
|
||||
}
|
||||
c.expect(c.call("POST", "/playlists/"+plID+"/tracks", token, map[string]any{"track_ids": []int64{mustInt(t, trackID)}, "position": 0}), 200, "add a track at the front")
|
||||
c.expect(c.call("POST", "/playlists/"+plID+"/tracks", token, map[string]any{"track_ids": []int64{mustInt(t, trackID)}, "position": 9}), 400, "add beyond the end", "invalid_position")
|
||||
c.expect(c.call("POST", "/playlists/"+plID+"/tracks", token, map[string]any{"track_ids": []int64{999999}}), 422, "add an unknown track", "track_not_found")
|
||||
c.expect(c.call("POST", "/playlists/999/tracks", token, map[string]any{"track_ids": []int64{mustInt(t, trackID)}}), 404, "add to an unknown playlist", "playlist_not_found")
|
||||
plItems := c.expect(c.call("GET", "/playlists/"+plID+"/tracks?limit=10", token, nil), 200, "the tracks of a playlist")
|
||||
if plItems["total"] != float64(3) {
|
||||
t.Fatalf("items = %v", plItems)
|
||||
}
|
||||
firstItem := idOf(plItems["items"].([]any)[0].(map[string]any))
|
||||
c.expect(c.call("GET", "/playlists/999/tracks", token, nil), 404, "tracks of an unknown playlist", "playlist_not_found")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID+"/tracks/"+firstItem, token, map[string]int{"position": 2}), 204, "move an item")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID+"/tracks/"+firstItem, token, map[string]int{"position": 3}), 400, "move beyond the end", "invalid_position")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID+"/tracks/"+firstItem, token, map[string]string{}), 400, "move with no position", "invalid_input")
|
||||
c.expect(c.call("PATCH", "/playlists/"+plID+"/tracks/999999", token, map[string]int{"position": 0}), 404, "move an unknown item", "item_not_found")
|
||||
c.expect(c.call("DELETE", "/playlists/"+plID+"/tracks/"+firstItem, token, nil), 204, "remove an item")
|
||||
c.expect(c.call("DELETE", "/playlists/"+plID+"/tracks/"+firstItem, token, nil), 404, "remove it twice", "item_not_found")
|
||||
c.expect(c.call("DELETE", "/playlists/"+plID, token, nil), 204, "delete a playlist")
|
||||
c.expect(c.call("DELETE", "/playlists/"+plID, token, nil), 404, "delete it twice", "playlist_not_found")
|
||||
|
||||
// ---- wishlist and dismissed ----
|
||||
gammaID := idOf(found["items"].([]any)[0].(map[string]any)["artist"].(map[string]any))
|
||||
c.expect(c.call("PUT", "/wishlist/"+gammaID, token, nil), 204, "wish for an artist")
|
||||
|
|
|
|||
268
internal/api/http/handlers_playlists.go
Normal file
268
internal/api/http/handlers_playlists.go
Normal file
|
|
@ -0,0 +1,268 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/playlists"
|
||||
)
|
||||
|
||||
// playlistHandlers serve the signed-in user's playlists. They are theirs alone: a playlist of
|
||||
// somebody else answers playlist_not_found, as one that does not exist.
|
||||
type playlistHandlers struct{ svc playlistService }
|
||||
|
||||
type playlistJSON struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
TrackCount int `json:"track_count"`
|
||||
DurationMs int64 `json:"duration_ms"`
|
||||
CreatedAt *string `json:"created_at"`
|
||||
UpdatedAt *string `json:"updated_at"`
|
||||
}
|
||||
|
||||
type playlistPageJSON struct {
|
||||
Items []playlistJSON `json:"items"`
|
||||
Total int `json:"total"`
|
||||
Limit int `json:"limit"`
|
||||
Offset int `json:"offset"`
|
||||
}
|
||||
|
||||
type playlistItemJSON struct {
|
||||
ID int64 `json:"id"`
|
||||
Position int `json:"position"`
|
||||
Available bool `json:"available"`
|
||||
AddedAt *string `json:"added_at"`
|
||||
Track trackJSON `json:"track"`
|
||||
}
|
||||
|
||||
type playlistItemsJSON struct {
|
||||
Items []playlistItemJSON `json:"items"`
|
||||
Total int `json:"total"`
|
||||
Limit int `json:"limit"`
|
||||
Offset int `json:"offset"`
|
||||
}
|
||||
|
||||
func toPlaylistJSON(p playlists.Playlist) playlistJSON {
|
||||
return playlistJSON{
|
||||
ID: p.ID, Name: p.Name, Description: p.Description, TrackCount: p.TrackCount, DurationMs: p.DurationMs,
|
||||
CreatedAt: rfc3339(p.CreatedAt), UpdatedAt: rfc3339(p.UpdatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func writePlaylistError(c *gin.Context, err error) {
|
||||
switch {
|
||||
case errors.Is(err, playlists.ErrInvalidInput):
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", err.Error())
|
||||
case errors.Is(err, playlists.ErrNotFound):
|
||||
writeError(c, http.StatusNotFound, "playlist_not_found", "no such playlist")
|
||||
case errors.Is(err, playlists.ErrItemNotFound):
|
||||
writeError(c, http.StatusNotFound, "item_not_found", "the playlist has no such item")
|
||||
case errors.Is(err, playlists.ErrTrackNotFound):
|
||||
writeError(c, http.StatusUnprocessableEntity, "track_not_found", "one of the tracks does not exist")
|
||||
case errors.Is(err, playlists.ErrPosition):
|
||||
writeError(c, http.StatusBadRequest, "invalid_position", err.Error())
|
||||
case errors.Is(err, playlists.ErrTooMany):
|
||||
writeError(c, http.StatusConflict, "limit_reached", err.Error())
|
||||
default:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
// itemID reads the item of the path.
|
||||
func itemID(c *gin.Context) (int64, bool) {
|
||||
id, err := strconv.ParseInt(c.Param("item"), 10, 64)
|
||||
if err != nil || id <= 0 {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "item must be a positive number")
|
||||
return 0, false
|
||||
}
|
||||
return id, true
|
||||
}
|
||||
|
||||
// pageOf reads limit and offset from the query string.
|
||||
func pageOf(c *gin.Context) (playlists.Page, bool) {
|
||||
limit, ok := queryInt(c, "limit")
|
||||
if !ok {
|
||||
return playlists.Page{}, false
|
||||
}
|
||||
offset, ok := queryInt(c, "offset")
|
||||
if !ok {
|
||||
return playlists.Page{}, false
|
||||
}
|
||||
return playlists.Page{Limit: clampInt(limit), Offset: clampInt(offset)}, true
|
||||
}
|
||||
|
||||
type createPlaylistRequest struct {
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) create(c *gin.Context) {
|
||||
var req createPlaylistRequest
|
||||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
p, err := h.svc.Create(c.Request.Context(), currentUserID(c), req.Name, req.Description)
|
||||
if err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusCreated, toPlaylistJSON(p))
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) list(c *gin.Context) {
|
||||
page, ok := pageOf(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
l, err := h.svc.List(c.Request.Context(), currentUserID(c), page)
|
||||
if err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
out := playlistPageJSON{Items: make([]playlistJSON, len(l.Items)), Total: l.Total, Limit: l.Limit, Offset: l.Offset}
|
||||
for i, p := range l.Items {
|
||||
out.Items[i] = toPlaylistJSON(p)
|
||||
}
|
||||
c.JSON(http.StatusOK, out)
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) 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 {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, toPlaylistJSON(p))
|
||||
}
|
||||
|
||||
type updatePlaylistRequest struct {
|
||||
Name *string `json:"name"` // pointers: absent must not mean empty
|
||||
Description *string `json:"description"` // an empty one clears it
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) update(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var req updatePlaylistRequest
|
||||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
p, err := h.svc.Update(c.Request.Context(), currentUserID(c), id, req.Name, req.Description)
|
||||
if err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, toPlaylistJSON(p))
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) remove(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if err := h.svc.Delete(c.Request.Context(), currentUserID(c), id); err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) items(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
page, ok := pageOf(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
l, err := h.svc.Items(c.Request.Context(), currentUserID(c), id, page)
|
||||
if err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
out := playlistItemsJSON{Items: make([]playlistItemJSON, len(l.Items)), Total: l.Total, Limit: l.Limit, Offset: l.Offset}
|
||||
for i, it := range l.Items {
|
||||
out.Items[i] = playlistItemJSON{
|
||||
ID: it.ID, Position: it.Position, Available: it.Available, AddedAt: rfc3339(it.AddedAt), Track: toTrackJSON(it.Track),
|
||||
}
|
||||
}
|
||||
c.JSON(http.StatusOK, out)
|
||||
}
|
||||
|
||||
type addTracksRequest struct {
|
||||
TrackIDs []int64 `json:"track_ids"`
|
||||
Position *int `json:"position"` // absent: at the end
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) addTracks(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var req addTracksRequest
|
||||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
p, err := h.svc.AddTracks(c.Request.Context(), currentUserID(c), id, req.TrackIDs, req.Position)
|
||||
if err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, toPlaylistJSON(p))
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) removeItem(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
item, ok := itemID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if err := h.svc.RemoveItem(c.Request.Context(), currentUserID(c), id, item); err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusNoContent)
|
||||
}
|
||||
|
||||
type moveItemRequest struct {
|
||||
Position *int `json:"position"`
|
||||
}
|
||||
|
||||
func (h *playlistHandlers) moveItem(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
item, ok := itemID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var req moveItemRequest
|
||||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
if req.Position == nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "position is required")
|
||||
return
|
||||
}
|
||||
if err := h.svc.MoveItem(c.Request.Context(), currentUserID(c), id, item, *req.Position); err != nil {
|
||||
writePlaylistError(c, err)
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusNoContent)
|
||||
}
|
||||
261
internal/api/http/playlists_test.go
Normal file
261
internal/api/http/playlists_test.go
Normal file
|
|
@ -0,0 +1,261 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/uptrace/bun"
|
||||
)
|
||||
|
||||
// plAPI is a server with an admin (alice), a second user (bob) and four tracks.
|
||||
type plAPI struct {
|
||||
h http.Handler
|
||||
alice string
|
||||
bob string
|
||||
tracks []int64
|
||||
}
|
||||
|
||||
func newPlAPI(t *testing.T) *plAPI {
|
||||
t.Helper()
|
||||
h, database := newTestEnvDB(t, func(*Deps, *bun.DB) {})
|
||||
alice := registerAndLogin(t, h)
|
||||
_, bob := addUser(t, h, alice, "bob", false)
|
||||
for _, title := range []string{"one", "two", "three"} {
|
||||
if _, err := database.Exec("INSERT INTO tracks (title) VALUES (?)", title); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
var tracks []int64
|
||||
rows, err := database.Query("SELECT id FROM tracks ORDER BY id")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tracks = append(tracks, id)
|
||||
}
|
||||
return &plAPI{h: h, alice: alice, bob: bob, tracks: tracks}
|
||||
}
|
||||
|
||||
func (p *plAPI) create(t *testing.T, token, name string) int64 {
|
||||
t.Helper()
|
||||
r := do(t, p.h, "POST", "/api/v1/playlists", token, map[string]any{"name": name})
|
||||
if r.Code != http.StatusCreated {
|
||||
t.Fatalf("create %q: %d %v", name, r.Code, r.Body)
|
||||
}
|
||||
return int64(r.Body["id"].(float64))
|
||||
}
|
||||
|
||||
func (p *plAPI) add(t *testing.T, token string, pl int64, ids ...int64) resp {
|
||||
t.Helper()
|
||||
return do(t, p.h, "POST", "/api/v1/playlists/"+id(pl)+"/tracks", token, map[string]any{"track_ids": ids})
|
||||
}
|
||||
|
||||
func (p *plAPI) titles(t *testing.T, token string, pl int64) []string {
|
||||
t.Helper()
|
||||
r := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl)+"/tracks", token, nil)
|
||||
if r.Code != http.StatusOK {
|
||||
t.Fatalf("items: %d %v", r.Code, r.Body)
|
||||
}
|
||||
var out []string
|
||||
for _, it := range r.Body["items"].([]any) {
|
||||
out = append(out, it.(map[string]any)["track"].(map[string]any)["title"].(string))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestPlaylistRoutesNeedASignedInUser(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
for _, rt := range []struct{ method, path string }{
|
||||
{"GET", "/api/v1/playlists"}, {"POST", "/api/v1/playlists"},
|
||||
{"GET", "/api/v1/playlists/1"}, {"PATCH", "/api/v1/playlists/1"}, {"DELETE", "/api/v1/playlists/1"},
|
||||
{"GET", "/api/v1/playlists/1/tracks"}, {"POST", "/api/v1/playlists/1/tracks"},
|
||||
{"DELETE", "/api/v1/playlists/1/tracks/1"}, {"PATCH", "/api/v1/playlists/1/tracks/1"},
|
||||
} {
|
||||
if r := do(t, p.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 TestCreateListGetUpdateAndDeleteAPlaylist(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
r := do(t, p.h, "POST", "/api/v1/playlists", p.alice, map[string]any{"name": " Road trip ", "description": "for the car"})
|
||||
if r.Code != http.StatusCreated || r.Body["name"] != "Road trip" || r.Body["description"] != "for the car" ||
|
||||
r.Body["track_count"] != float64(0) || r.Body["duration_ms"] != float64(0) || r.Body["created_at"] == nil || r.Body["updated_at"] == nil {
|
||||
t.Fatalf("create: %d %v", r.Code, r.Body)
|
||||
}
|
||||
pl := int64(r.Body["id"].(float64))
|
||||
second := p.create(t, p.alice, "Second")
|
||||
|
||||
list := do(t, p.h, "GET", "/api/v1/playlists", p.alice, nil)
|
||||
items, _ := list.Body["items"].([]any)
|
||||
if list.Code != http.StatusOK || list.Body["total"] != float64(2) || len(items) != 2 || items[0].(map[string]any)["id"] != float64(second) {
|
||||
t.Fatalf("list: %d %v", list.Code, list.Body)
|
||||
}
|
||||
if got := do(t, p.h, "GET", "/api/v1/playlists?limit=1&offset=1", p.alice, nil); len(got.Body["items"].([]any)) != 1 || got.Body["limit"] != float64(1) || got.Body["offset"] != float64(1) {
|
||||
t.Errorf("paging: %v", got.Body)
|
||||
}
|
||||
if got := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl), p.alice, nil); got.Code != http.StatusOK || got.Body["name"] != "Road trip" {
|
||||
t.Errorf("get: %d %v", got.Code, got.Body)
|
||||
}
|
||||
|
||||
upd := do(t, p.h, "PATCH", "/api/v1/playlists/"+id(pl), p.alice, map[string]any{"name": "Renamed"})
|
||||
if upd.Code != http.StatusOK || upd.Body["name"] != "Renamed" || upd.Body["description"] != "for the car" {
|
||||
t.Errorf("rename: %d %v", upd.Code, upd.Body)
|
||||
}
|
||||
upd = do(t, p.h, "PATCH", "/api/v1/playlists/"+id(pl), p.alice, map[string]any{"description": ""})
|
||||
if upd.Code != http.StatusOK || upd.Body["description"] != "" || upd.Body["name"] != "Renamed" {
|
||||
t.Errorf("clear the description: %d %v", upd.Code, upd.Body)
|
||||
}
|
||||
|
||||
if r := do(t, p.h, "DELETE", "/api/v1/playlists/"+id(pl), p.alice, nil); r.Code != http.StatusNoContent {
|
||||
t.Errorf("delete: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl), p.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "playlist_not_found" {
|
||||
t.Errorf("get after delete: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPlaylistInputIsChecked(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
pl := p.create(t, p.alice, "P")
|
||||
long := strings.Repeat("a", 201)
|
||||
for name, tt := range map[string]struct {
|
||||
method, path string
|
||||
body any
|
||||
}{
|
||||
"no name": {"POST", "/api/v1/playlists", map[string]any{}},
|
||||
"a blank name": {"POST", "/api/v1/playlists", map[string]any{"name": " "}},
|
||||
"a long name": {"POST", "/api/v1/playlists", map[string]any{"name": long}},
|
||||
"not json": {"POST", "/api/v1/playlists", "{"},
|
||||
"a name that is a number": {"POST", "/api/v1/playlists", `{"name": 5}`},
|
||||
"nothing to change": {"PATCH", "/api/v1/playlists/" + id(pl), map[string]any{}},
|
||||
"an empty new name": {"PATCH", "/api/v1/playlists/" + id(pl), map[string]any{"name": ""}},
|
||||
"no track ids": {"POST", "/api/v1/playlists/" + id(pl) + "/tracks", map[string]any{}},
|
||||
"an empty list": {"POST", "/api/v1/playlists/" + id(pl) + "/tracks", map[string]any{"track_ids": []int64{}}},
|
||||
"a zero track id": {"POST", "/api/v1/playlists/" + id(pl) + "/tracks", map[string]any{"track_ids": []int64{0}}},
|
||||
"a negative position": {"POST", "/api/v1/playlists/" + id(pl) + "/tracks", map[string]any{"track_ids": []int64{p.tracks[0]}, "position": -1}},
|
||||
"a move with no place": {"PATCH", "/api/v1/playlists/" + id(pl) + "/tracks/1", map[string]any{}},
|
||||
"a negative place": {"PATCH", "/api/v1/playlists/" + id(pl) + "/tracks/1", map[string]any{"position": -1}},
|
||||
"a bad id": {"GET", "/api/v1/playlists/abc", nil},
|
||||
"a zero id": {"GET", "/api/v1/playlists/0", nil},
|
||||
"a bad limit": {"GET", "/api/v1/playlists?limit=x", nil},
|
||||
"a negative offset": {"GET", "/api/v1/playlists/" + id(pl) + "/tracks?offset=-1", nil},
|
||||
} {
|
||||
if r := do(t, p.h, tt.method, tt.path, p.alice, tt.body); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
||||
t.Errorf("%s: %d %v, want 400 invalid_input", name, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddTracksListThemMoveAndRemove(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
pl := p.create(t, p.alice, "P")
|
||||
a, b, c := p.tracks[1], p.tracks[2], p.tracks[3]
|
||||
|
||||
r := p.add(t, p.alice, pl, a, b, a)
|
||||
if r.Code != http.StatusOK || r.Body["track_count"] != float64(3) {
|
||||
t.Fatalf("add: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if got := p.titles(t, p.alice, pl); strings.Join(got, ",") != "one,two,one" {
|
||||
t.Fatalf("titles = %v", got)
|
||||
}
|
||||
// In the middle.
|
||||
if r := do(t, p.h, "POST", "/api/v1/playlists/"+id(pl)+"/tracks", p.alice, map[string]any{"track_ids": []int64{c}, "position": 1}); r.Code != http.StatusOK {
|
||||
t.Fatalf("add at 1: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if got := p.titles(t, p.alice, pl); strings.Join(got, ",") != "one,three,two,one" {
|
||||
t.Fatalf("titles = %v", got)
|
||||
}
|
||||
|
||||
page := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl)+"/tracks?limit=2&offset=1", p.alice, nil)
|
||||
items := page.Body["items"].([]any)
|
||||
first := items[0].(map[string]any)
|
||||
if page.Code != http.StatusOK || len(items) != 2 || page.Body["total"] != float64(4) || first["position"] != float64(1) ||
|
||||
first["id"] == nil || first["available"] != false || first["added_at"] == nil || first["track"].(map[string]any)["title"] != "three" {
|
||||
t.Fatalf("page: %d %v", page.Code, page.Body)
|
||||
}
|
||||
|
||||
// Move the item at 3 to the front, then remove the one now at 1.
|
||||
all := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl)+"/tracks", p.alice, nil).Body["items"].([]any)
|
||||
itemID := func(i int) string { return id(int64(all[i].(map[string]any)["id"].(float64))) }
|
||||
if r := do(t, p.h, "PATCH", "/api/v1/playlists/"+id(pl)+"/tracks/"+itemID(3), p.alice, map[string]any{"position": 0}); r.Code != http.StatusNoContent {
|
||||
t.Fatalf("move: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if got := p.titles(t, p.alice, pl); strings.Join(got, ",") != "one,one,three,two" {
|
||||
t.Fatalf("after the move: %v", got)
|
||||
}
|
||||
if r := do(t, p.h, "DELETE", "/api/v1/playlists/"+id(pl)+"/tracks/"+itemID(1), p.alice, nil); r.Code != http.StatusNoContent {
|
||||
t.Fatalf("remove: %d %v", r.Code, r.Body)
|
||||
}
|
||||
// itemID(1) was "three" before the move: it is the one that goes.
|
||||
if got := p.titles(t, p.alice, pl); strings.Join(got, ",") != "one,one,two" {
|
||||
t.Fatalf("after the removal: %v", got)
|
||||
}
|
||||
if got := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl), p.alice, nil); got.Body["track_count"] != float64(3) {
|
||||
t.Errorf("track count = %v", got.Body["track_count"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestPlaylistErrorsHaveTheirOwnCodes(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
pl := p.create(t, p.alice, "P")
|
||||
if r := p.add(t, p.alice, pl, p.tracks[1]); r.Code != http.StatusOK {
|
||||
t.Fatal(r.Body)
|
||||
}
|
||||
if r := p.add(t, p.alice, pl, p.tracks[1], 99999); r.Code != http.StatusUnprocessableEntity || errCode(r) != "track_not_found" {
|
||||
t.Errorf("unknown track: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := do(t, p.h, "POST", "/api/v1/playlists/"+id(pl)+"/tracks", p.alice, map[string]any{"track_ids": []int64{p.tracks[1]}, "position": 5}); r.Code != http.StatusBadRequest || errCode(r) != "invalid_position" {
|
||||
t.Errorf("position beyond the end: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := do(t, p.h, "PATCH", "/api/v1/playlists/"+id(pl)+"/tracks/99999", p.alice, map[string]any{"position": 0}); r.Code != http.StatusNotFound || errCode(r) != "item_not_found" {
|
||||
t.Errorf("move an unknown item: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := do(t, p.h, "DELETE", "/api/v1/playlists/"+id(pl)+"/tracks/99999", p.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "item_not_found" {
|
||||
t.Errorf("remove an unknown item: %d %v", r.Code, r.Body)
|
||||
}
|
||||
items := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl)+"/tracks", p.alice, nil).Body["items"].([]any)
|
||||
itemID := id(int64(items[0].(map[string]any)["id"].(float64)))
|
||||
if r := do(t, p.h, "PATCH", "/api/v1/playlists/"+id(pl)+"/tracks/"+itemID, p.alice, map[string]any{"position": 1}); r.Code != http.StatusBadRequest || errCode(r) != "invalid_position" {
|
||||
t.Errorf("move beyond the end: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := do(t, p.h, "GET", "/api/v1/playlists/99999/tracks", p.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "playlist_not_found" {
|
||||
t.Errorf("items of an unknown playlist: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPlaylistIsOnlyItsOwnersAndAnyoneElseGetsNotFound(t *testing.T) {
|
||||
p := newPlAPI(t)
|
||||
pl := p.create(t, p.alice, "Private")
|
||||
if r := p.add(t, p.alice, pl, p.tracks[1]); r.Code != http.StatusOK {
|
||||
t.Fatal(r.Body)
|
||||
}
|
||||
items := do(t, p.h, "GET", "/api/v1/playlists/"+id(pl)+"/tracks", p.alice, nil).Body["items"].([]any)
|
||||
itemID := id(int64(items[0].(map[string]any)["id"].(float64)))
|
||||
base := "/api/v1/playlists/" + id(pl)
|
||||
for _, rt := range []struct {
|
||||
method, path string
|
||||
body any
|
||||
}{
|
||||
{"GET", base, nil}, {"PATCH", base, map[string]any{"name": "mine now"}}, {"DELETE", base, nil},
|
||||
{"GET", base + "/tracks", nil}, {"POST", base + "/tracks", map[string]any{"track_ids": []int64{p.tracks[1]}}},
|
||||
{"DELETE", base + "/tracks/" + itemID, nil}, {"PATCH", base + "/tracks/" + itemID, map[string]any{"position": 0}},
|
||||
} {
|
||||
if r := do(t, p.h, rt.method, rt.path, p.bob, rt.body); r.Code != http.StatusNotFound || errCode(r) != "playlist_not_found" {
|
||||
t.Errorf("bob %s %s: %d %v, want 404 playlist_not_found", rt.method, rt.path, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
if list := do(t, p.h, "GET", "/api/v1/playlists", p.bob, nil); list.Body["total"] != float64(0) {
|
||||
t.Errorf("bob's list: %v", list.Body)
|
||||
}
|
||||
if got := do(t, p.h, "GET", base, p.alice, nil); got.Code != http.StatusOK || got.Body["name"] != "Private" || got.Body["track_count"] != float64(1) {
|
||||
t.Errorf("alice's playlist was changed: %v", got.Body)
|
||||
}
|
||||
}
|
||||
|
|
@ -24,6 +24,7 @@ import (
|
|||
"codeberg.org/squidd/sonda/internal/jobs"
|
||||
"codeberg.org/squidd/sonda/internal/library"
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
"codeberg.org/squidd/sonda/internal/playlists"
|
||||
"codeberg.org/squidd/sonda/internal/providers"
|
||||
"codeberg.org/squidd/sonda/internal/streaming"
|
||||
"codeberg.org/squidd/sonda/internal/taste"
|
||||
|
|
@ -85,6 +86,19 @@ type discoverService interface {
|
|||
Discover(ctx context.Context, userID int64, q discover.Query) (discover.Result, error)
|
||||
}
|
||||
|
||||
// playlistService is what the handlers need from playlists.Service.
|
||||
type playlistService interface {
|
||||
Create(ctx context.Context, userID int64, name, description string) (playlists.Playlist, error)
|
||||
List(ctx context.Context, userID int64, p playlists.Page) (playlists.Listing, error)
|
||||
Get(ctx context.Context, userID, id int64) (playlists.Playlist, error)
|
||||
Update(ctx context.Context, userID, id int64, name, description *string) (playlists.Playlist, error)
|
||||
Delete(ctx context.Context, userID, id int64) error
|
||||
Items(ctx context.Context, userID, id int64, p playlists.Page) (playlists.ItemsListing, error)
|
||||
AddTracks(ctx context.Context, userID, id int64, trackIDs []int64, position *int) (playlists.Playlist, error)
|
||||
RemoveItem(ctx context.Context, userID, id, itemID int64) error
|
||||
MoveItem(ctx context.Context, userID, id, itemID int64, position int) 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
|
||||
|
|
@ -157,6 +171,7 @@ type Deps struct {
|
|||
Taste tasteService
|
||||
Discover discoverService
|
||||
Feedback feedbackService
|
||||
Playlists playlistService
|
||||
Images coverService
|
||||
CoversJob jobService
|
||||
ArtistImagesJob jobService
|
||||
|
|
@ -226,6 +241,16 @@ func NewRouter(d Deps) *gin.Engine {
|
|||
protected.GET("/discover/dismissed", fb.list(feedback.Dismissed))
|
||||
protected.POST("/discover/:id/dismiss", fb.add(feedback.Dismissed))
|
||||
protected.DELETE("/discover/:id/dismiss", fb.remove(feedback.Dismissed))
|
||||
pl := &playlistHandlers{svc: d.Playlists}
|
||||
protected.GET("/playlists", pl.list)
|
||||
protected.POST("/playlists", pl.create)
|
||||
protected.GET("/playlists/:id", pl.get)
|
||||
protected.PATCH("/playlists/:id", pl.update)
|
||||
protected.DELETE("/playlists/:id", pl.remove)
|
||||
protected.GET("/playlists/:id/tracks", pl.items)
|
||||
protected.POST("/playlists/:id/tracks", pl.addTracks)
|
||||
protected.DELETE("/playlists/:id/tracks/:item", pl.removeItem)
|
||||
protected.PATCH("/playlists/:id/tracks/:item", pl.moveItem)
|
||||
protected.GET("/wishlist", fb.list(feedback.Wishlist))
|
||||
protected.PUT("/wishlist/:id", fb.add(feedback.Wishlist))
|
||||
protected.DELETE("/wishlist/:id", fb.remove(feedback.Wishlist))
|
||||
|
|
|
|||
|
|
@ -35,6 +35,8 @@ tags:
|
|||
description: Streaming and listening history.
|
||||
- name: Taste
|
||||
description: What Sonda has learned from your listening, and the settings that are yours.
|
||||
- name: Playlists
|
||||
description: Ordered lists of tracks that belong to one user.
|
||||
- name: Discovery
|
||||
description: Music outside the library, from external providers an admin switched on, and suggestions scored for you.
|
||||
- name: Providers
|
||||
|
|
@ -1194,6 +1196,210 @@ paths:
|
|||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/playlists:
|
||||
get:
|
||||
tags: [Playlists]
|
||||
operationId: listPlaylists
|
||||
summary: Your playlists
|
||||
description: |
|
||||
The playlists you made, the one changed last first. Only yours: nobody else's are ever
|
||||
listed.
|
||||
security: [{bearerAuth: []}]
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Limit'}
|
||||
- {$ref: '#/components/parameters/Offset'}
|
||||
responses:
|
||||
'200':
|
||||
description: A page of playlists.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/PlaylistPage'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
post:
|
||||
tags: [Playlists]
|
||||
operationId: createPlaylist
|
||||
summary: Make a playlist
|
||||
description: |
|
||||
Makes an empty playlist. A user can have 1000. Names can repeat.
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/CreatePlaylist'}
|
||||
responses:
|
||||
'201':
|
||||
description: The playlist.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Playlist'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'409': {$ref: '#/components/responses/PlaylistLimit'}
|
||||
|
||||
/playlists/{id}:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Playlists]
|
||||
operationId: getPlaylist
|
||||
summary: A playlist
|
||||
description: |
|
||||
Its name, description, how many tracks it has and how long they are. The tracks come from
|
||||
`GET /playlists/{id}/tracks`. A playlist of somebody else answers `playlist_not_found`.
|
||||
security: [{bearerAuth: []}]
|
||||
responses:
|
||||
'200':
|
||||
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/PlaylistNotFound'}
|
||||
patch:
|
||||
tags: [Playlists]
|
||||
operationId: updatePlaylist
|
||||
summary: Rename a playlist or change its description
|
||||
description: |
|
||||
Changes what is given. An empty description clears it; a name cannot be empty.
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/UpdatePlaylist'}
|
||||
responses:
|
||||
'200':
|
||||
description: The playlist as it is now.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Playlist'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404': {$ref: '#/components/responses/PlaylistNotFound'}
|
||||
delete:
|
||||
tags: [Playlists]
|
||||
operationId: deletePlaylist
|
||||
summary: Delete a playlist
|
||||
description: Deletes the playlist and its list of tracks. The tracks themselves stay in the library.
|
||||
security: [{bearerAuth: []}]
|
||||
responses:
|
||||
'204': {description: Deleted.}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404': {$ref: '#/components/responses/PlaylistNotFound'}
|
||||
|
||||
/playlists/{id}/tracks:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Playlists]
|
||||
operationId: listPlaylistTracks
|
||||
summary: The tracks of a playlist
|
||||
description: |
|
||||
The items in order, each with its own `id` (a track can be in a playlist more than once),
|
||||
its `position` (counted from 0, without gaps) and the track. A track whose files were
|
||||
deleted or moved away stays in the playlist with `available` false: it is not lost, and
|
||||
it plays again when the files are back and a scan has found them.
|
||||
security: [{bearerAuth: []}]
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Limit'}
|
||||
- {$ref: '#/components/parameters/Offset'}
|
||||
responses:
|
||||
'200':
|
||||
description: A page of items.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/PlaylistItemPage'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404': {$ref: '#/components/responses/PlaylistNotFound'}
|
||||
post:
|
||||
tags: [Playlists]
|
||||
operationId: addPlaylistTracks
|
||||
summary: Add tracks to a playlist
|
||||
description: |
|
||||
Puts 1 to 500 tracks, in the order given, at `position` (the tracks from there on move
|
||||
down) or at the end when it is absent. A track can be added again. If one id is not a
|
||||
track nothing is added. A playlist holds up to 10000 tracks.
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/AddPlaylistTracks'}
|
||||
responses:
|
||||
'200':
|
||||
description: The playlist as it is now.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Playlist'}
|
||||
'400':
|
||||
description: The request is malformed, or `position` is beyond the end (`invalid_position`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404': {$ref: '#/components/responses/PlaylistNotFound'}
|
||||
'409': {$ref: '#/components/responses/PlaylistLimit'}
|
||||
'422':
|
||||
description: One of the tracks does not exist (`track_not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/playlists/{id}/tracks/{item}:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
- name: item
|
||||
in: path
|
||||
required: true
|
||||
description: The `id` of the item, not of the track.
|
||||
schema: {type: integer, format: int64, minimum: 1}
|
||||
patch:
|
||||
tags: [Playlists]
|
||||
operationId: movePlaylistItem
|
||||
summary: Move a track inside a playlist
|
||||
description: |
|
||||
Puts the item at `position`, from 0 to the number of items less one; the ones in between
|
||||
shift by one.
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/MovePlaylistItem'}
|
||||
responses:
|
||||
'204': {description: Moved.}
|
||||
'400':
|
||||
description: The request is malformed, or `position` is beyond the end (`invalid_position`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404':
|
||||
description: No such playlist (`playlist_not_found`) or no such item in it (`item_not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
delete:
|
||||
tags: [Playlists]
|
||||
operationId: removePlaylistItem
|
||||
summary: Take a track out of a playlist
|
||||
description: Removes that one item; the ones after it move up by one.
|
||||
security: [{bearerAuth: []}]
|
||||
responses:
|
||||
'204': {description: Removed.}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'404':
|
||||
description: No such playlist (`playlist_not_found`) or no such item in it (`item_not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/wishlist:
|
||||
get:
|
||||
tags: [Discovery]
|
||||
|
|
@ -2248,6 +2454,16 @@ components:
|
|||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
PlaylistNotFound:
|
||||
description: No such playlist, or it is somebody else's (`playlist_not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
PlaylistLimit:
|
||||
description: A limit was reached, 1000 playlists for a user or 10000 tracks in a playlist (`limit_reached`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
LibraryNotFound:
|
||||
description: No such library (`library_not_found`).
|
||||
content:
|
||||
|
|
@ -2833,6 +3049,89 @@ components:
|
|||
type: array
|
||||
items: {$ref: '#/components/schemas/Suggestion'}
|
||||
|
||||
Playlist:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [id, name, description, track_count, duration_ms, created_at, updated_at]
|
||||
properties:
|
||||
id: {type: integer, format: int64}
|
||||
name: {type: string}
|
||||
description: {type: string}
|
||||
track_count: {type: integer, description: "Items in the playlist, available or not."}
|
||||
duration_ms: {type: integer, format: int64, description: "Their total length."}
|
||||
created_at: {type: string, format: date-time}
|
||||
updated_at: {type: string, format: date-time, description: "When it was last changed, tracks included."}
|
||||
|
||||
PlaylistPage:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [items, total, limit, offset]
|
||||
properties:
|
||||
items:
|
||||
type: array
|
||||
items: {$ref: '#/components/schemas/Playlist'}
|
||||
total: {type: integer, description: "Size of the whole list, not of this page."}
|
||||
limit: {type: integer}
|
||||
offset: {type: integer}
|
||||
|
||||
PlaylistItem:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [id, position, available, added_at, track]
|
||||
properties:
|
||||
id: {type: integer, format: int64, description: "Identifies this place of the playlist; the track may be there twice."}
|
||||
position: {type: integer, minimum: 0}
|
||||
available: {type: boolean, description: "False when the track has no file to play now."}
|
||||
added_at: {type: string, format: date-time}
|
||||
track: {$ref: '#/components/schemas/Track'}
|
||||
|
||||
PlaylistItemPage:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [items, total, limit, offset]
|
||||
properties:
|
||||
items:
|
||||
type: array
|
||||
items: {$ref: '#/components/schemas/PlaylistItem'}
|
||||
total: {type: integer, description: "Items in the whole playlist."}
|
||||
limit: {type: integer}
|
||||
offset: {type: integer}
|
||||
|
||||
CreatePlaylist:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [name]
|
||||
properties:
|
||||
name: {type: string, minLength: 1, maxLength: 200, description: Trimmed.}
|
||||
description: {type: string, maxLength: 2000}
|
||||
|
||||
UpdatePlaylist:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
description: At least one of the two.
|
||||
properties:
|
||||
name: {type: string, minLength: 1, maxLength: 200}
|
||||
description: {type: string, maxLength: 2000, description: "An empty one clears it."}
|
||||
|
||||
AddPlaylistTracks:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [track_ids]
|
||||
properties:
|
||||
track_ids:
|
||||
type: array
|
||||
minItems: 1
|
||||
maxItems: 500
|
||||
items: {type: integer, format: int64, minimum: 1}
|
||||
position: {type: integer, minimum: 0, description: "Where the first one goes, up to the number of items; absent means the end."}
|
||||
|
||||
MovePlaylistItem:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [position]
|
||||
properties:
|
||||
position: {type: integer, minimum: 0}
|
||||
|
||||
MarkedPage:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
|
|
|
|||
275
internal/playlists/playlists.go
Normal file
275
internal/playlists/playlists.go
Normal file
|
|
@ -0,0 +1,275 @@
|
|||
// Package playlists keeps the playlists of each user: named, ordered lists of tracks that only
|
||||
// their owner sees. Nothing here contacts anyone.
|
||||
//
|
||||
// A track can be in a playlist more than once, so an item has an id of its own, and the place of
|
||||
// an item (its position) counts from 0 without gaps. A track whose files were deleted or moved
|
||||
// away stays in its playlists and is listed as not available: it is not lost.
|
||||
//
|
||||
// A playlist that belongs to somebody else is as if it did not exist (ErrNotFound), so nobody
|
||||
// can find out which ids are in use.
|
||||
package playlists
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/catalog"
|
||||
)
|
||||
|
||||
// Limits. They keep one user from filling the database and one request from doing too much.
|
||||
const (
|
||||
MaxNameLen = 200
|
||||
MaxDescriptionLen = 2000
|
||||
MaxAddAtOnce = 500 // track ids in one request
|
||||
MaxItems = 10_000 // tracks in one playlist
|
||||
MaxPlaylists = 1_000 // playlists of one user
|
||||
DefaultLimit = 50
|
||||
MaxLimit = 200
|
||||
)
|
||||
|
||||
// Errors returned by the service and the store.
|
||||
var (
|
||||
ErrInvalidInput = errors.New("invalid input")
|
||||
ErrNotFound = errors.New("playlist not found")
|
||||
ErrItemNotFound = errors.New("item not found in the playlist")
|
||||
ErrTrackNotFound = errors.New("track not found")
|
||||
ErrPosition = errors.New("position out of range")
|
||||
ErrTooMany = errors.New("limit reached")
|
||||
)
|
||||
|
||||
// Playlist is a playlist and what it holds, counted over all its items, available or not.
|
||||
type Playlist struct {
|
||||
ID int64
|
||||
Name string
|
||||
Description string
|
||||
TrackCount int
|
||||
DurationMs int64
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
// Item is one place of a playlist. Available says whether the track has a file to play.
|
||||
type Item struct {
|
||||
ID int64
|
||||
Position int
|
||||
Track catalog.Track
|
||||
Available bool
|
||||
AddedAt time.Time
|
||||
}
|
||||
|
||||
// Page says which part of a list is wanted.
|
||||
type Page struct {
|
||||
Limit int
|
||||
Offset int
|
||||
}
|
||||
|
||||
// Store keeps the playlists. Every call is for one user and gives ErrNotFound for a playlist
|
||||
// that does not exist or is not theirs. Calls that change a playlist do it in one transaction
|
||||
// and set its updated time.
|
||||
type Store interface {
|
||||
// Create makes an empty playlist, or gives ErrTooMany when the user has MaxPlaylists.
|
||||
Create(ctx context.Context, userID int64, name, description string, now time.Time) (Playlist, error)
|
||||
// List returns a page of the user's playlists, the one changed last first, and how many there are.
|
||||
List(ctx context.Context, userID int64, limit, offset int) ([]Playlist, int, error)
|
||||
Get(ctx context.Context, userID, id int64) (Playlist, error)
|
||||
// Update changes the name and/or the description that are not nil.
|
||||
Update(ctx context.Context, userID, id int64, name, description *string, now time.Time) (Playlist, error)
|
||||
Delete(ctx context.Context, userID, id int64) error
|
||||
// Items returns a page of the playlist in order, and how many items it has.
|
||||
Items(ctx context.Context, userID, id int64, limit, offset int) ([]Item, int, error)
|
||||
// AddTracks puts the tracks at position (at the end when nil), in the order given, and
|
||||
// returns the playlist. It gives ErrTrackNotFound when one of them does not exist (nothing
|
||||
// is added), ErrPosition when position is beyond the end, and ErrTooMany when the
|
||||
// playlist would have more than MaxItems.
|
||||
AddTracks(ctx context.Context, userID, id int64, trackIDs []int64, position *int, now time.Time) (Playlist, error)
|
||||
// RemoveItem takes an item out and closes the gap; ErrItemNotFound for one that is not in it.
|
||||
RemoveItem(ctx context.Context, userID, id, itemID int64, now time.Time) error
|
||||
// MoveItem puts an item at a position (0 to the number of items less one), ErrPosition otherwise.
|
||||
MoveItem(ctx context.Context, userID, id, itemID int64, position int, now time.Time) error
|
||||
}
|
||||
|
||||
// Service validates what it is given and keeps the playlists.
|
||||
type Service struct{ store Store }
|
||||
|
||||
// NewService builds a Service.
|
||||
func NewService(store Store) *Service { return &Service{store: store} }
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
func cleanPage(p Page) (Page, error) {
|
||||
if p.Limit < 0 || p.Offset < 0 {
|
||||
return p, invalid("limit and offset cannot be negative")
|
||||
}
|
||||
switch {
|
||||
case p.Limit == 0:
|
||||
p.Limit = DefaultLimit
|
||||
case p.Limit > MaxLimit:
|
||||
p.Limit = MaxLimit
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
// Create makes a playlist.
|
||||
func (s *Service) Create(ctx context.Context, userID int64, name, description string) (Playlist, error) {
|
||||
name, err := cleanName(name)
|
||||
if err != nil {
|
||||
return Playlist{}, err
|
||||
}
|
||||
description, err = cleanDescription(description)
|
||||
if err != nil {
|
||||
return Playlist{}, err
|
||||
}
|
||||
return s.store.Create(ctx, userID, name, description, time.Now())
|
||||
}
|
||||
|
||||
// List returns a page of the user's playlists.
|
||||
func (s *Service) List(ctx context.Context, userID int64, p Page) (Listing, error) {
|
||||
p, err := cleanPage(p)
|
||||
if err != nil {
|
||||
return Listing{}, err
|
||||
}
|
||||
items, total, err := s.store.List(ctx, userID, p.Limit, p.Offset)
|
||||
if err != nil {
|
||||
return Listing{}, err
|
||||
}
|
||||
return Listing{Items: items, Total: total, Limit: p.Limit, Offset: p.Offset}, nil
|
||||
}
|
||||
|
||||
// Listing is a page of playlists.
|
||||
type Listing struct {
|
||||
Items []Playlist
|
||||
Total int
|
||||
Limit int
|
||||
Offset int
|
||||
}
|
||||
|
||||
// Get returns a playlist.
|
||||
func (s *Service) Get(ctx context.Context, userID, id int64) (Playlist, error) {
|
||||
if id <= 0 {
|
||||
return Playlist{}, ErrNotFound
|
||||
}
|
||||
return s.store.Get(ctx, userID, id)
|
||||
}
|
||||
|
||||
// Update changes the name and/or the description. An empty description clears it.
|
||||
func (s *Service) Update(ctx context.Context, userID, id int64, name, description *string) (Playlist, error) {
|
||||
if id <= 0 {
|
||||
return Playlist{}, ErrNotFound
|
||||
}
|
||||
if name == nil && description == nil {
|
||||
return Playlist{}, invalid("nothing to change: give a name or a description")
|
||||
}
|
||||
if name != nil {
|
||||
n, err := cleanName(*name)
|
||||
if err != nil {
|
||||
return Playlist{}, err
|
||||
}
|
||||
name = &n
|
||||
}
|
||||
if description != nil {
|
||||
d, err := cleanDescription(*description)
|
||||
if err != nil {
|
||||
return Playlist{}, err
|
||||
}
|
||||
description = &d
|
||||
}
|
||||
return s.store.Update(ctx, userID, id, name, description, time.Now())
|
||||
}
|
||||
|
||||
// Delete removes a playlist and its items; the tracks stay.
|
||||
func (s *Service) Delete(ctx context.Context, userID, id int64) error {
|
||||
if id <= 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return s.store.Delete(ctx, userID, id)
|
||||
}
|
||||
|
||||
// ItemsListing is a page of the items of a playlist.
|
||||
type ItemsListing struct {
|
||||
Items []Item
|
||||
Total int
|
||||
Limit int
|
||||
Offset int
|
||||
}
|
||||
|
||||
// Items returns a page of the playlist, in order.
|
||||
func (s *Service) Items(ctx context.Context, userID, id int64, p Page) (ItemsListing, error) {
|
||||
if id <= 0 {
|
||||
return ItemsListing{}, ErrNotFound
|
||||
}
|
||||
p, err := cleanPage(p)
|
||||
if err != nil {
|
||||
return ItemsListing{}, err
|
||||
}
|
||||
items, total, err := s.store.Items(ctx, userID, id, p.Limit, p.Offset)
|
||||
if err != nil {
|
||||
return ItemsListing{}, err
|
||||
}
|
||||
return ItemsListing{Items: items, Total: total, Limit: p.Limit, Offset: p.Offset}, nil
|
||||
}
|
||||
|
||||
// AddTracks puts tracks in a playlist, at the end or at position, in the order given.
|
||||
func (s *Service) AddTracks(ctx context.Context, userID, id int64, trackIDs []int64, position *int) (Playlist, error) {
|
||||
if id <= 0 {
|
||||
return Playlist{}, ErrNotFound
|
||||
}
|
||||
if len(trackIDs) == 0 || len(trackIDs) > MaxAddAtOnce {
|
||||
return Playlist{}, invalid("give 1 to %d track ids", MaxAddAtOnce)
|
||||
}
|
||||
for _, t := range trackIDs {
|
||||
if t <= 0 {
|
||||
return Playlist{}, invalid("a track id must be positive")
|
||||
}
|
||||
}
|
||||
if position != nil && *position < 0 {
|
||||
return Playlist{}, invalid("the position cannot be negative")
|
||||
}
|
||||
return s.store.AddTracks(ctx, userID, id, trackIDs, position, time.Now())
|
||||
}
|
||||
|
||||
// RemoveItem takes an item out of a playlist.
|
||||
func (s *Service) RemoveItem(ctx context.Context, userID, id, itemID int64) error {
|
||||
if id <= 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
if itemID <= 0 {
|
||||
return ErrItemNotFound
|
||||
}
|
||||
return s.store.RemoveItem(ctx, userID, id, itemID, time.Now())
|
||||
}
|
||||
|
||||
// MoveItem puts an item at another place of its playlist.
|
||||
func (s *Service) MoveItem(ctx context.Context, userID, id, itemID int64, position int) error {
|
||||
if id <= 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
if itemID <= 0 {
|
||||
return ErrItemNotFound
|
||||
}
|
||||
if position < 0 {
|
||||
return invalid("the position cannot be negative")
|
||||
}
|
||||
return s.store.MoveItem(ctx, userID, id, itemID, position, time.Now())
|
||||
}
|
||||
188
internal/playlists/playlists_test.go
Normal file
188
internal/playlists/playlists_test.go
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
package playlists
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// fakeStore records what the service asks and answers what the test sets.
|
||||
type fakeStore struct {
|
||||
created []string // name|description
|
||||
updated [][2]*string
|
||||
listLimit int
|
||||
listOffset int
|
||||
itemsLimit int
|
||||
itemsOffset int
|
||||
addIDs []int64
|
||||
addPos *int
|
||||
movedTo int
|
||||
err error
|
||||
}
|
||||
|
||||
func (f *fakeStore) Create(_ context.Context, _ int64, name, description string, _ time.Time) (Playlist, error) {
|
||||
f.created = append(f.created, name+"|"+description)
|
||||
return Playlist{ID: 1, Name: name, Description: description}, f.err
|
||||
}
|
||||
|
||||
func (f *fakeStore) List(_ context.Context, _ int64, limit, offset int) ([]Playlist, int, error) {
|
||||
f.listLimit, f.listOffset = limit, offset
|
||||
return nil, 0, f.err
|
||||
}
|
||||
|
||||
func (f *fakeStore) Get(context.Context, int64, int64) (Playlist, error) { return Playlist{}, f.err }
|
||||
|
||||
func (f *fakeStore) Update(_ context.Context, _, _ int64, name, description *string, _ time.Time) (Playlist, error) {
|
||||
f.updated = append(f.updated, [2]*string{name, description})
|
||||
return Playlist{}, f.err
|
||||
}
|
||||
|
||||
func (f *fakeStore) Delete(context.Context, int64, int64) error { return f.err }
|
||||
|
||||
func (f *fakeStore) Items(_ context.Context, _, _ int64, limit, offset int) ([]Item, int, error) {
|
||||
f.itemsLimit, f.itemsOffset = limit, offset
|
||||
return nil, 0, f.err
|
||||
}
|
||||
|
||||
func (f *fakeStore) AddTracks(_ context.Context, _, _ int64, ids []int64, pos *int, _ time.Time) (Playlist, error) {
|
||||
f.addIDs, f.addPos = ids, pos
|
||||
return Playlist{}, f.err
|
||||
}
|
||||
|
||||
func (f *fakeStore) RemoveItem(context.Context, int64, int64, int64, time.Time) error { return f.err }
|
||||
|
||||
func (f *fakeStore) MoveItem(_ context.Context, _, _, _ int64, pos int, _ time.Time) error {
|
||||
f.movedTo = pos
|
||||
return f.err
|
||||
}
|
||||
|
||||
func newSvc() (*Service, *fakeStore) {
|
||||
f := &fakeStore{}
|
||||
return NewService(f), f
|
||||
}
|
||||
|
||||
func TestCreateTrimsTheNameAndChecksItsSize(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
if _, err := s.Create(context.Background(), 1, " Road trip ", " for the car "); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(f.created) != 1 || f.created[0] != "Road trip|for the car" {
|
||||
t.Errorf("created = %q", f.created)
|
||||
}
|
||||
for name, tt := range map[string]struct{ name, desc string }{
|
||||
"empty": {"", ""},
|
||||
"only spaces": {" ", ""},
|
||||
"name too long": {strings.Repeat("a", MaxNameLen+1), ""},
|
||||
"too long, accent": {strings.Repeat("é", MaxNameLen+1), ""},
|
||||
"description long": {"ok", strings.Repeat("a", MaxDescriptionLen+1)},
|
||||
} {
|
||||
if _, err := s.Create(context.Background(), 1, tt.name, tt.desc); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("%s: err = %v, want ErrInvalidInput", name, err)
|
||||
}
|
||||
}
|
||||
// 200 letters with an accent are 200 characters, not 400 bytes.
|
||||
if _, err := s.Create(context.Background(), 1, strings.Repeat("é", MaxNameLen), ""); err != nil {
|
||||
t.Errorf("a name of %d characters: %v", MaxNameLen, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdateNeedsSomethingToChangeAndAValidValue(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
ctx := context.Background()
|
||||
name, empty := " New ", " "
|
||||
if _, err := s.Update(ctx, 1, 2, nil, nil); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("nothing to change: err = %v", err)
|
||||
}
|
||||
if _, err := s.Update(ctx, 1, 2, &empty, nil); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("an empty name: err = %v", err)
|
||||
}
|
||||
if _, err := s.Update(ctx, 1, 2, &name, &empty); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := f.updated[0]; *got[0] != "New" || *got[1] != "" {
|
||||
t.Errorf("updated = %q %q: the name is trimmed and an empty description clears it", *got[0], *got[1])
|
||||
}
|
||||
}
|
||||
|
||||
func TestListsArePagedWithDefaultsAndACap(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
ctx := context.Background()
|
||||
if _, err := s.List(ctx, 1, Page{}); err != nil || f.listLimit != DefaultLimit {
|
||||
t.Errorf("default: limit = %d err = %v", f.listLimit, err)
|
||||
}
|
||||
if _, err := s.List(ctx, 1, Page{Limit: 100000, Offset: 5}); err != nil || f.listLimit != MaxLimit || f.listOffset != 5 {
|
||||
t.Errorf("cap: limit = %d offset = %d err = %v", f.listLimit, f.listOffset, err)
|
||||
}
|
||||
if _, err := s.Items(ctx, 1, 2, Page{Limit: 100000}); err != nil || f.itemsLimit != MaxLimit {
|
||||
t.Errorf("items cap: limit = %d err = %v", f.itemsLimit, err)
|
||||
}
|
||||
for _, p := range []Page{{Limit: -1}, {Offset: -1}} {
|
||||
if _, err := s.List(ctx, 1, p); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("%+v: err = %v", p, err)
|
||||
}
|
||||
if _, err := s.Items(ctx, 1, 2, p); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("items %+v: err = %v", p, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddTracksChecksWhatIsAdded(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
ctx := context.Background()
|
||||
two := 2
|
||||
if _, err := s.AddTracks(ctx, 1, 2, []int64{5, 5, 6}, &two); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(f.addIDs) != 3 || f.addPos == nil || *f.addPos != 2 {
|
||||
t.Errorf("ids = %v pos = %v: repeated tracks are allowed", f.addIDs, f.addPos)
|
||||
}
|
||||
neg := -1
|
||||
big := make([]int64, MaxAddAtOnce+1)
|
||||
for i := range big {
|
||||
big[i] = int64(i + 1)
|
||||
}
|
||||
for name, tt := range map[string]struct {
|
||||
ids []int64
|
||||
pos *int
|
||||
}{
|
||||
"nothing": {nil, nil},
|
||||
"too many": {big, nil},
|
||||
"a zero id": {[]int64{1, 0}, nil},
|
||||
"a negative id": {[]int64{-3}, nil},
|
||||
"a negative place": {[]int64{1}, &neg},
|
||||
} {
|
||||
if _, err := s.AddTracks(ctx, 1, 2, tt.ids, tt.pos); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("%s: err = %v, want ErrInvalidInput", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMoveNeedsAPlaceFromZero(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
if err := s.MoveItem(context.Background(), 1, 2, 3, 4); err != nil || f.movedTo != 4 {
|
||||
t.Errorf("moved to %d err = %v", f.movedTo, err)
|
||||
}
|
||||
if err := s.MoveItem(context.Background(), 1, 2, 3, -1); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("err = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIdsThatCannotExistAreNotFoundWithoutAskingTheStore(t *testing.T) {
|
||||
s, f := newSvc()
|
||||
f.err = errors.New("the store must not be asked")
|
||||
ctx := context.Background()
|
||||
if _, err := s.Get(ctx, 1, 0); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("get: err = %v", err)
|
||||
}
|
||||
if err := s.Delete(ctx, 1, -1); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("delete: err = %v", err)
|
||||
}
|
||||
if err := s.RemoveItem(ctx, 1, 2, 0); !errors.Is(err, ErrItemNotFound) {
|
||||
t.Errorf("remove: err = %v", err)
|
||||
}
|
||||
if err := s.MoveItem(ctx, 1, 2, -5, 0); !errors.Is(err, ErrItemNotFound) {
|
||||
t.Errorf("move: err = %v", err)
|
||||
}
|
||||
}
|
||||
377
internal/storage/playlists.go
Normal file
377
internal/storage/playlists.go
Normal file
|
|
@ -0,0 +1,377 @@
|
|||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/uptrace/bun"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/catalog"
|
||||
"codeberg.org/squidd/sonda/internal/playlists"
|
||||
)
|
||||
|
||||
type playlistRow struct {
|
||||
bun.BaseModel `bun:"table:playlists"`
|
||||
|
||||
ID int64 `bun:"id,pk,autoincrement"`
|
||||
UserID int64 `bun:"user_id,notnull"`
|
||||
Name string `bun:"name,notnull"`
|
||||
Description string `bun:"description,notnull"`
|
||||
CreatedAt int64 `bun:"created_at,notnull"`
|
||||
UpdatedAt int64 `bun:"updated_at,notnull"`
|
||||
}
|
||||
|
||||
type playlistItemRow struct {
|
||||
bun.BaseModel `bun:"table:playlist_items"`
|
||||
|
||||
ID int64 `bun:"id,pk,autoincrement"`
|
||||
PlaylistID int64 `bun:"playlist_id,notnull"`
|
||||
TrackID int64 `bun:"track_id,notnull"`
|
||||
Position int `bun:"position,notnull"`
|
||||
AddedAt int64 `bun:"added_at,notnull"`
|
||||
}
|
||||
|
||||
// PlaylistRepo stores playlists. It implements playlists.Store.
|
||||
type PlaylistRepo struct {
|
||||
db *bun.DB
|
||||
cat *CatalogRepo // reads the tracks of the items
|
||||
}
|
||||
|
||||
// NewPlaylistRepo builds a PlaylistRepo.
|
||||
func NewPlaylistRepo(db *bun.DB) *PlaylistRepo { return &PlaylistRepo{db: db, cat: NewCatalogRepo(db)} }
|
||||
|
||||
// summarySelect reads playlists with the number of their items and how long they are, over all
|
||||
// the items, available or not.
|
||||
const summarySelect = `SELECT p.id, p.name, p.description, p.created_at, p.updated_at,
|
||||
COUNT(i.id), COALESCE(SUM(t.duration_ms), 0)
|
||||
FROM playlists p
|
||||
LEFT JOIN playlist_items i ON i.playlist_id = p.id
|
||||
LEFT JOIN tracks t ON t.id = i.track_id`
|
||||
|
||||
func scanSummary(rows interface{ Scan(...any) error }) (playlists.Playlist, error) {
|
||||
var (
|
||||
p playlists.Playlist
|
||||
created, updated int64
|
||||
count, durationSum int64
|
||||
)
|
||||
if err := rows.Scan(&p.ID, &p.Name, &p.Description, &created, &updated, &count, &durationSum); err != nil {
|
||||
return playlists.Playlist{}, err
|
||||
}
|
||||
p.CreatedAt, p.UpdatedAt = time.Unix(created, 0), time.Unix(updated, 0)
|
||||
p.TrackCount, p.DurationMs = int(count), durationSum
|
||||
return p, nil
|
||||
}
|
||||
|
||||
// summary reads one playlist of a user, or playlists.ErrNotFound.
|
||||
func summary(ctx context.Context, db bun.IDB, userID, id int64) (playlists.Playlist, error) {
|
||||
p, err := scanSummary(db.QueryRowContext(ctx, summarySelect+" WHERE p.id = ? AND p.user_id = ? GROUP BY p.id", id, userID))
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return playlists.Playlist{}, playlists.ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return playlists.Playlist{}, fmt.Errorf("read playlist: %w", err)
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
// touch sets the updated time of a playlist of the user and so takes its row lock, which is what
|
||||
// serialises two changes of the same playlist on PostgreSQL. It gives ErrNotFound when the
|
||||
// playlist is not the user's.
|
||||
func touch(ctx context.Context, tx bun.Tx, userID, id int64, now time.Time) error {
|
||||
res, err := tx.ExecContext(ctx, "UPDATE playlists SET updated_at = ? WHERE id = ? AND user_id = ?", now.Unix(), id, userID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("lock playlist: %w", err)
|
||||
}
|
||||
if n, _ := res.RowsAffected(); n == 0 {
|
||||
return playlists.ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func countItems(ctx context.Context, tx bun.Tx, id int64) (int, error) {
|
||||
var n int
|
||||
if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM playlist_items WHERE playlist_id = ?", id).Scan(&n); err != nil {
|
||||
return 0, fmt.Errorf("count items: %w", err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// Create makes an empty playlist.
|
||||
func (r *PlaylistRepo) Create(ctx context.Context, userID int64, name, description string, now time.Time) (playlists.Playlist, error) {
|
||||
var out playlists.Playlist
|
||||
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 playlists.ErrNotFound // the account is gone
|
||||
}
|
||||
var have int
|
||||
if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM playlists WHERE user_id = ?", userID).Scan(&have); err != nil {
|
||||
return fmt.Errorf("count playlists: %w", err)
|
||||
}
|
||||
if have >= playlists.MaxPlaylists {
|
||||
return fmt.Errorf("%w: a user can have %d playlists", playlists.ErrTooMany, playlists.MaxPlaylists)
|
||||
}
|
||||
row := &playlistRow{UserID: userID, Name: name, Description: description, CreatedAt: now.Unix(), UpdatedAt: now.Unix()}
|
||||
if _, err := tx.NewInsert().Model(row).Exec(ctx); err != nil {
|
||||
return fmt.Errorf("insert playlist: %w", err)
|
||||
}
|
||||
out, err = summary(ctx, tx, userID, row.ID)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
// List returns a page of the user's playlists, the one changed last first.
|
||||
func (r *PlaylistRepo) List(ctx context.Context, userID int64, limit, offset int) ([]playlists.Playlist, int, error) {
|
||||
var total int
|
||||
if err := r.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM playlists WHERE user_id = ?", userID).Scan(&total); err != nil {
|
||||
return nil, 0, fmt.Errorf("count playlists: %w", err)
|
||||
}
|
||||
out := []playlists.Playlist{}
|
||||
if offset >= total {
|
||||
return out, total, nil
|
||||
}
|
||||
rows, err := r.db.QueryContext(ctx,
|
||||
summarySelect+" WHERE p.user_id = ? GROUP BY p.id ORDER BY p.updated_at DESC, p.id DESC LIMIT ? OFFSET ?", userID, limit, offset)
|
||||
if err != nil {
|
||||
return nil, 0, fmt.Errorf("list playlists: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
p, err := scanSummary(rows)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
out = append(out, p)
|
||||
}
|
||||
return out, total, rows.Err()
|
||||
}
|
||||
|
||||
// Get returns a playlist of the user.
|
||||
func (r *PlaylistRepo) Get(ctx context.Context, userID, id int64) (playlists.Playlist, error) {
|
||||
return summary(ctx, r.db, userID, id)
|
||||
}
|
||||
|
||||
// Update changes the name and/or the description that are not nil.
|
||||
func (r *PlaylistRepo) Update(ctx context.Context, userID, id int64, name, description *string, now time.Time) (playlists.Playlist, error) {
|
||||
var out playlists.Playlist
|
||||
err := r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
|
||||
q := tx.NewUpdate().Model((*playlistRow)(nil)).Set("updated_at = ?", now.Unix()).Where("id = ?", id).Where("user_id = ?", userID)
|
||||
if name != nil {
|
||||
q = q.Set("name = ?", *name)
|
||||
}
|
||||
if description != nil {
|
||||
q = q.Set("description = ?", *description)
|
||||
}
|
||||
res, err := q.Exec(ctx)
|
||||
if err := affectedOrNotFoundPlaylist(res, err); err != nil {
|
||||
return err
|
||||
}
|
||||
out, err = summary(ctx, tx, userID, id)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
func affectedOrNotFoundPlaylist(res sql.Result, err error) error {
|
||||
if err != nil {
|
||||
return fmt.Errorf("change playlist: %w", err)
|
||||
}
|
||||
if n, _ := res.RowsAffected(); n == 0 {
|
||||
return playlists.ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Delete removes a playlist and, through the foreign key, its items.
|
||||
func (r *PlaylistRepo) Delete(ctx context.Context, userID, id int64) error {
|
||||
res, err := r.db.ExecContext(ctx, "DELETE FROM playlists WHERE id = ? AND user_id = ?", id, userID)
|
||||
return affectedOrNotFoundPlaylist(res, err)
|
||||
}
|
||||
|
||||
// Items returns a page of the playlist in order. The tracks are read with the same three queries
|
||||
// as any list of tracks, whatever the page size, and also when a track has no file to play.
|
||||
func (r *PlaylistRepo) Items(ctx context.Context, userID, id int64, limit, offset int) ([]playlists.Item, int, error) {
|
||||
p, err := summary(ctx, r.db, userID, id)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
items := []playlists.Item{}
|
||||
if offset >= p.TrackCount {
|
||||
return items, p.TrackCount, nil
|
||||
}
|
||||
rows, err := r.db.QueryContext(ctx,
|
||||
`SELECT i.id, i.position, i.added_at, t.id, t.title, COALESCE(t.duration_ms, 0), COALESCE(t.track_no, 0),
|
||||
COALESCE(t.disc_no, 0), t.album_id,
|
||||
EXISTS (SELECT 1 FROM audio_files f WHERE f.track_id = t.id AND f.missing_at IS NULL)
|
||||
FROM playlist_items i JOIN tracks t ON t.id = i.track_id
|
||||
WHERE i.playlist_id = ? ORDER BY i.position, i.id LIMIT ? OFFSET ?`, id, limit, offset)
|
||||
if err != nil {
|
||||
return nil, 0, fmt.Errorf("list items: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
albumOf := map[int64]int64{}
|
||||
page := catalog.Page[catalog.Track]{}
|
||||
var trackIDs []int64
|
||||
seen := map[int64]bool{}
|
||||
for rows.Next() {
|
||||
var (
|
||||
it playlists.Item
|
||||
added int64
|
||||
albumID sql.NullInt64
|
||||
)
|
||||
t := &it.Track
|
||||
if err := rows.Scan(&it.ID, &it.Position, &added, &t.ID, &t.Title, &t.DurationMs, &t.TrackNo, &t.DiscNo, &albumID, &it.Available); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
it.AddedAt = time.Unix(added, 0)
|
||||
t.Artists = []catalog.ArtistRef{}
|
||||
if albumID.Valid {
|
||||
albumOf[t.ID] = albumID.Int64
|
||||
}
|
||||
if !seen[t.ID] {
|
||||
seen[t.ID] = true
|
||||
trackIDs = append(trackIDs, t.ID)
|
||||
}
|
||||
items = append(items, it)
|
||||
page.Items = append(page.Items, *t)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
if err := r.cat.attachTrackDetails(ctx, &page, trackIDs, albumOf, 0); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
for i := range items {
|
||||
items[i].Track = page.Items[i]
|
||||
}
|
||||
return items, p.TrackCount, nil
|
||||
}
|
||||
|
||||
// AddTracks puts the tracks at position (at the end when nil), in the order given.
|
||||
func (r *PlaylistRepo) AddTracks(ctx context.Context, userID, id int64, trackIDs []int64, position *int, now time.Time) (playlists.Playlist, error) {
|
||||
var out playlists.Playlist
|
||||
err := r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
|
||||
if err := touch(ctx, tx, userID, id, now); err != nil {
|
||||
return err
|
||||
}
|
||||
have, err := countItems(ctx, tx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
at := have
|
||||
if position != nil {
|
||||
at = *position
|
||||
}
|
||||
if at > have {
|
||||
return fmt.Errorf("%w: the playlist has %d tracks", playlists.ErrPosition, have)
|
||||
}
|
||||
if have+len(trackIDs) > playlists.MaxItems {
|
||||
return fmt.Errorf("%w: a playlist can have %d tracks", playlists.ErrTooMany, playlists.MaxItems)
|
||||
}
|
||||
distinct := map[int64]bool{}
|
||||
var ids []int64
|
||||
for _, t := range trackIDs {
|
||||
if !distinct[t] {
|
||||
distinct[t] = true
|
||||
ids = append(ids, t)
|
||||
}
|
||||
}
|
||||
var known int
|
||||
if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM tracks WHERE id IN (?)", bun.In(ids)).Scan(&known); err != nil {
|
||||
return fmt.Errorf("check tracks: %w", err)
|
||||
}
|
||||
if known != len(ids) {
|
||||
return playlists.ErrTrackNotFound
|
||||
}
|
||||
if at < have {
|
||||
if _, err := tx.ExecContext(ctx, "UPDATE playlist_items SET position = position + ? WHERE playlist_id = ? AND position >= ?", len(trackIDs), id, at); err != nil {
|
||||
return fmt.Errorf("make room: %w", err)
|
||||
}
|
||||
}
|
||||
rows := make([]playlistItemRow, len(trackIDs))
|
||||
for i, t := range trackIDs {
|
||||
rows[i] = playlistItemRow{PlaylistID: id, TrackID: t, Position: at + i, AddedAt: now.Unix()}
|
||||
}
|
||||
if _, err := tx.NewInsert().Model(&rows).Exec(ctx); err != nil {
|
||||
return fmt.Errorf("insert items: %w", err)
|
||||
}
|
||||
out, err = summary(ctx, tx, userID, id)
|
||||
return err
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
// RemoveItem takes an item out and closes the gap.
|
||||
func (r *PlaylistRepo) RemoveItem(ctx context.Context, userID, id, itemID int64, now time.Time) error {
|
||||
return r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
|
||||
if err := touch(ctx, tx, userID, id, now); err != nil {
|
||||
return err
|
||||
}
|
||||
at, err := itemPosition(ctx, tx, id, itemID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, "DELETE FROM playlist_items WHERE id = ?", itemID); err != nil {
|
||||
return fmt.Errorf("delete item: %w", err)
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, "UPDATE playlist_items SET position = position - 1 WHERE playlist_id = ? AND position > ?", id, at); err != nil {
|
||||
return fmt.Errorf("close the gap: %w", err)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func itemPosition(ctx context.Context, tx bun.Tx, id, itemID int64) (int, error) {
|
||||
var at int
|
||||
err := tx.QueryRowContext(ctx, "SELECT position FROM playlist_items WHERE id = ? AND playlist_id = ?", itemID, id).Scan(&at)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return 0, playlists.ErrItemNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("read item: %w", err)
|
||||
}
|
||||
return at, nil
|
||||
}
|
||||
|
||||
// MoveItem puts an item at a position.
|
||||
func (r *PlaylistRepo) MoveItem(ctx context.Context, userID, id, itemID int64, position int, now time.Time) error {
|
||||
return r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
|
||||
if err := touch(ctx, tx, userID, id, now); err != nil {
|
||||
return err
|
||||
}
|
||||
from, err := itemPosition(ctx, tx, id, itemID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
have, err := countItems(ctx, tx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if position >= have {
|
||||
return fmt.Errorf("%w: the playlist has %d tracks", playlists.ErrPosition, have)
|
||||
}
|
||||
switch {
|
||||
case from < position:
|
||||
_, err = tx.ExecContext(ctx, "UPDATE playlist_items SET position = position - 1 WHERE playlist_id = ? AND position > ? AND position <= ?", id, from, position)
|
||||
case from > position:
|
||||
_, err = tx.ExecContext(ctx, "UPDATE playlist_items SET position = position + 1 WHERE playlist_id = ? AND position >= ? AND position < ?", id, position, from)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("shift items: %w", err)
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, "UPDATE playlist_items SET position = ? WHERE id = ?", position, itemID); err != nil {
|
||||
return fmt.Errorf("move item: %w", err)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
449
internal/storage/playlists_test.go
Normal file
449
internal/storage/playlists_test.go
Normal file
|
|
@ -0,0 +1,449 @@
|
|||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"slices"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/uptrace/bun"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/playlists"
|
||||
)
|
||||
|
||||
// plEnv is two users and four tracks (a, b, c, d), each 60 seconds long.
|
||||
type plEnv struct {
|
||||
t *testing.T
|
||||
db *bun.DB
|
||||
repo *PlaylistRepo
|
||||
alice int64
|
||||
bob int64
|
||||
tracks map[string]int64
|
||||
now time.Time
|
||||
}
|
||||
|
||||
func newPlEnv(t *testing.T, db *bun.DB) *plEnv {
|
||||
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 := &plEnv{t: t, db: db, repo: NewPlaylistRepo(db), alice: a.ID, bob: b.ID, tracks: map[string]int64{}, now: time.Unix(1_700_000_000, 0)}
|
||||
for i, title := range []string{"a", "b", "c", "d"} {
|
||||
if _, err := lib.SaveFile(ctx, l.ID, pf("x/"+title+".flac", title, "Album", "Band", i+1, 1, "flac", "Band"), 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var id int64
|
||||
if err := db.QueryRow("SELECT id FROM tracks WHERE title = ?", title).Scan(&id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
e.tracks[title] = id
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
// tick moves the clock on, so "changed last" has an order.
|
||||
func (e *plEnv) tick() time.Time { e.now = e.now.Add(time.Minute); return e.now }
|
||||
|
||||
func (e *plEnv) create(user int64, name string) playlists.Playlist {
|
||||
e.t.Helper()
|
||||
p, err := e.repo.Create(context.Background(), user, name, "", e.tick())
|
||||
if err != nil {
|
||||
e.t.Fatal(err)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// add puts tracks by name (at the end when pos < 0).
|
||||
func (e *plEnv) add(user, id int64, pos int, names ...string) (playlists.Playlist, error) {
|
||||
e.t.Helper()
|
||||
ids := make([]int64, len(names))
|
||||
for i, n := range names {
|
||||
ids[i] = e.tracks[n]
|
||||
}
|
||||
var p *int
|
||||
if pos >= 0 {
|
||||
p = &pos
|
||||
}
|
||||
return e.repo.AddTracks(context.Background(), user, id, ids, p, e.tick())
|
||||
}
|
||||
|
||||
// order is the titles of a playlist in order.
|
||||
func (e *plEnv) order(user, id int64) []string {
|
||||
e.t.Helper()
|
||||
items, total, err := e.repo.Items(context.Background(), user, id, 1000, 0)
|
||||
if err != nil {
|
||||
e.t.Fatal(err)
|
||||
}
|
||||
if total != len(items) {
|
||||
e.t.Fatalf("total = %d, items = %d", total, len(items))
|
||||
}
|
||||
out := make([]string, len(items))
|
||||
for i, it := range items {
|
||||
if it.Position != i {
|
||||
e.t.Fatalf("item %d has position %d: positions must count from 0 without gaps", i, it.Position)
|
||||
}
|
||||
out[i] = it.Track.Title
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (e *plEnv) itemIDs(id int64) []int64 {
|
||||
e.t.Helper()
|
||||
items, _, err := e.repo.Items(context.Background(), e.alice, id, 1000, 0)
|
||||
if err != nil {
|
||||
e.t.Fatal(err)
|
||||
}
|
||||
ids := make([]int64, len(items))
|
||||
for i, it := range items {
|
||||
ids[i] = it.ID
|
||||
}
|
||||
return ids
|
||||
}
|
||||
|
||||
func plBackends(t *testing.T, fn func(t *testing.T, e *plEnv)) {
|
||||
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) { fn(t, newPlEnv(t, db)) })
|
||||
}
|
||||
|
||||
func TestPlaylistsAreCreatedListedAndKeptApartPerUser(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
first := e.create(e.alice, "First")
|
||||
second := e.create(e.alice, "Second")
|
||||
other := e.create(e.bob, "Bobs")
|
||||
if first.ID == 0 || first.Name != "First" || first.TrackCount != 0 || first.DurationMs != 0 || first.CreatedAt.IsZero() {
|
||||
t.Errorf("first = %+v", first)
|
||||
}
|
||||
got, total, err := e.repo.List(ctx, e.alice, 10, 0)
|
||||
if err != nil || total != 2 || len(got) != 2 || got[0].ID != second.ID || got[1].ID != first.ID {
|
||||
t.Fatalf("list = %+v total %d err %v: the one changed last comes first", got, total, err)
|
||||
}
|
||||
// Changing the first one puts it on top.
|
||||
if _, err := e.add(e.alice, first.ID, -1, "a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got, _, _ = e.repo.List(ctx, e.alice, 10, 0)
|
||||
if got[0].ID != first.ID || got[0].TrackCount != 1 || got[0].DurationMs != 60000 {
|
||||
t.Errorf("after adding: %+v", got[0])
|
||||
}
|
||||
if page, total, _ := e.repo.List(ctx, e.alice, 1, 1); len(page) != 1 || total != 2 || page[0].ID != second.ID {
|
||||
t.Errorf("page 2 = %+v total %d", page, total)
|
||||
}
|
||||
if _, err := e.repo.Get(ctx, e.alice, other.ID); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user's playlist: err = %v, want ErrNotFound", err)
|
||||
}
|
||||
if _, err := e.repo.Get(ctx, e.alice, 99999); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("unknown playlist: err = %v", err)
|
||||
}
|
||||
if mine, total, _ := e.repo.List(ctx, e.bob, 10, 0); total != 1 || mine[0].ID != other.ID {
|
||||
t.Errorf("bob sees %+v", mine)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAddingAtTheEndAndInTheMiddleKeepsTheOrderWithoutGaps(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
p := e.create(e.alice, "P")
|
||||
got, err := e.add(e.alice, p.ID, -1, "a", "b", "a")
|
||||
if err != nil || got.TrackCount != 3 || got.DurationMs != 180000 {
|
||||
t.Fatalf("playlist = %+v err %v", got, err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); !slices.Equal(o, []string{"a", "b", "a"}) {
|
||||
t.Fatalf("order = %v: a track can be there twice", o)
|
||||
}
|
||||
if ids := e.itemIDs(p.ID); ids[0] == ids[2] {
|
||||
t.Error("the same track twice must be two items")
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, 1, "c", "d"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); !slices.Equal(o, []string{"a", "c", "d", "b", "a"}) {
|
||||
t.Errorf("order = %v, want c and d at 1 and 2", o)
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, 0, "d"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); !slices.Equal(o, []string{"d", "a", "c", "d", "b", "a"}) {
|
||||
t.Errorf("order = %v, want d first", o)
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, 6, "b"); err != nil { // the end, as a position
|
||||
t.Errorf("a position at the end: %v", err)
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, 8, "b"); !errors.Is(err, playlists.ErrPosition) {
|
||||
t.Errorf("a position beyond the end: err = %v, want ErrPosition", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAddingAnUnknownTrackOrToAnotherUsersPlaylistChangesNothing(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
if _, err := e.repo.AddTracks(ctx, e.alice, p.ID, []int64{e.tracks["a"], 99999}, nil, e.tick()); !errors.Is(err, playlists.ErrTrackNotFound) {
|
||||
t.Errorf("unknown track: err = %v", err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); len(o) != 0 {
|
||||
t.Errorf("order = %v: nothing must be added when one track is unknown", o)
|
||||
}
|
||||
if _, err := e.add(e.bob, p.ID, -1, "a"); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user's playlist: err = %v", err)
|
||||
}
|
||||
if _, err := e.add(e.alice, 99999, -1, "a"); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("unknown playlist: err = %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestRemovingAnItemClosesTheGap(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
other := e.create(e.alice, "Other")
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a", "b", "c", "d"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := e.add(e.alice, other.ID, -1, "a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ids := e.itemIDs(p.ID)
|
||||
if err := e.repo.RemoveItem(ctx, e.alice, p.ID, ids[1], e.tick()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); !slices.Equal(o, []string{"a", "c", "d"}) {
|
||||
t.Errorf("order = %v", o)
|
||||
}
|
||||
if err := e.repo.RemoveItem(ctx, e.alice, p.ID, ids[1], e.tick()); !errors.Is(err, playlists.ErrItemNotFound) {
|
||||
t.Errorf("a second time: err = %v", err)
|
||||
}
|
||||
if err := e.repo.RemoveItem(ctx, e.alice, other.ID, ids[0], e.tick()); !errors.Is(err, playlists.ErrItemNotFound) {
|
||||
t.Errorf("an item of another playlist: err = %v", err)
|
||||
}
|
||||
if err := e.repo.RemoveItem(ctx, e.bob, p.ID, ids[0], e.tick()); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user: err = %v", err)
|
||||
}
|
||||
if got, _ := e.repo.Get(ctx, e.alice, p.ID); got.TrackCount != 3 || got.DurationMs != 180000 {
|
||||
t.Errorf("after removing: %+v", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestMovingAnItem(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a", "b", "c", "d"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
move := func(from, to int) error {
|
||||
return e.repo.MoveItem(ctx, e.alice, p.ID, e.itemIDs(p.ID)[from], to, e.tick())
|
||||
}
|
||||
for _, step := range []struct {
|
||||
from, to int
|
||||
want []string
|
||||
}{
|
||||
{0, 2, []string{"b", "c", "a", "d"}},
|
||||
{3, 0, []string{"d", "b", "c", "a"}},
|
||||
{1, 1, []string{"d", "b", "c", "a"}},
|
||||
{2, 3, []string{"d", "b", "a", "c"}},
|
||||
{3, 2, []string{"d", "b", "c", "a"}},
|
||||
{0, 3, []string{"b", "c", "a", "d"}},
|
||||
} {
|
||||
if err := move(step.from, step.to); err != nil {
|
||||
t.Fatalf("move %d to %d: %v", step.from, step.to, err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); !slices.Equal(o, step.want) {
|
||||
t.Fatalf("after %d to %d: order = %v, want %v", step.from, step.to, o, step.want)
|
||||
}
|
||||
}
|
||||
if err := move(0, 4); !errors.Is(err, playlists.ErrPosition) {
|
||||
t.Errorf("beyond the end: err = %v", err)
|
||||
}
|
||||
if err := e.repo.MoveItem(ctx, e.alice, p.ID, 99999, 0, e.tick()); !errors.Is(err, playlists.ErrItemNotFound) {
|
||||
t.Errorf("unknown item: err = %v", err)
|
||||
}
|
||||
if err := e.repo.MoveItem(ctx, e.bob, p.ID, e.itemIDs(p.ID)[0], 0, e.tick()); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user: err = %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestATrackWithoutFilesStaysAndIsListedAsNotAvailable(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a", "b"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := e.db.ExecContext(ctx, "UPDATE audio_files SET missing_at = ? WHERE track_id = ?", 1_700_000_100, e.tracks["a"]); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
items, total, err := e.repo.Items(ctx, e.alice, p.ID, 10, 0)
|
||||
if err != nil || total != 2 || len(items) != 2 {
|
||||
t.Fatalf("items = %+v total %d err %v: the track must stay", items, total, err)
|
||||
}
|
||||
if items[0].Available || items[0].Track.Title != "a" || items[0].Track.Album == nil || len(items[0].Track.Artists) != 1 {
|
||||
t.Errorf("the missing one = %+v", items[0])
|
||||
}
|
||||
if !items[1].Available || items[1].Track.Format != "flac" {
|
||||
t.Errorf("the other = %+v", items[1])
|
||||
}
|
||||
if got, _ := e.repo.Get(ctx, e.alice, p.ID); got.TrackCount != 2 {
|
||||
t.Errorf("track count = %d, want both", got.TrackCount)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestItemsArePaged(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a", "b", "c", "d"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
items, total, err := e.repo.Items(ctx, e.alice, p.ID, 2, 1)
|
||||
if err != nil || total != 4 || len(items) != 2 || items[0].Track.Title != "b" || items[1].Position != 2 {
|
||||
t.Errorf("page = %+v total %d err %v", items, total, err)
|
||||
}
|
||||
if items, total, _ := e.repo.Items(ctx, e.alice, p.ID, 2, 10); len(items) != 0 || total != 4 {
|
||||
t.Errorf("beyond the end = %+v total %d", items, total)
|
||||
}
|
||||
if _, _, err := e.repo.Items(ctx, e.bob, p.ID, 2, 0); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user: err = %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestUpdatingAndDeletingAPlaylist(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p, err := e.repo.Create(ctx, e.alice, "Old", "about it", e.tick())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a", "b"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
name, empty := "New", ""
|
||||
got, err := e.repo.Update(ctx, e.alice, p.ID, &name, nil, e.tick())
|
||||
if err != nil || got.Name != "New" || got.Description != "about it" || got.TrackCount != 2 {
|
||||
t.Errorf("name only: %+v err %v", got, err)
|
||||
}
|
||||
got, err = e.repo.Update(ctx, e.alice, p.ID, nil, &empty, e.tick())
|
||||
if err != nil || got.Name != "New" || got.Description != "" {
|
||||
t.Errorf("description only: %+v err %v", got, err)
|
||||
}
|
||||
if _, err := e.repo.Update(ctx, e.bob, p.ID, &name, nil, e.tick()); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user updates: err = %v", err)
|
||||
}
|
||||
if err := e.repo.Delete(ctx, e.bob, p.ID); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("another user deletes: err = %v", err)
|
||||
}
|
||||
if err := e.repo.Delete(ctx, e.alice, p.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := e.repo.Delete(ctx, e.alice, p.ID); !errors.Is(err, playlists.ErrNotFound) {
|
||||
t.Errorf("a second time: err = %v", err)
|
||||
}
|
||||
if n := count(t, e.db, "SELECT COUNT(*) FROM playlist_items"); n != 0 {
|
||||
t.Errorf("%d items left", n)
|
||||
}
|
||||
if n := count(t, e.db, "SELECT COUNT(*) FROM tracks"); n != 4 {
|
||||
t.Errorf("%d tracks left, want all 4", n)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestDeletingAUserDeletesTheirPlaylists(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
p := e.create(e.alice, "P")
|
||||
keep := e.create(e.bob, "Keep")
|
||||
if _, err := e.add(e.alice, p.ID, -1, "a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := NewUserRepo(e.db).DeleteUser(context.Background(), e.alice); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if n := count(t, e.db, "SELECT COUNT(*) FROM playlists"); n != 1 {
|
||||
t.Errorf("%d playlists, want only bob's", n)
|
||||
}
|
||||
if _, err := e.repo.Get(context.Background(), e.bob, keep.ID); err != nil {
|
||||
t.Errorf("bob's: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestThereAreLimitsOnPlaylistsAndOnTheirSize(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "Big")
|
||||
// Fill the playlist up to the limit with a direct insert, 1,000 rows at a time.
|
||||
for start := 0; start < playlists.MaxItems; start += 1000 {
|
||||
rows := make([]playlistItemRow, 0, 1000)
|
||||
for i := start; i < start+1000; i++ {
|
||||
rows = append(rows, playlistItemRow{PlaylistID: p.ID, TrackID: e.tracks["a"], Position: i, AddedAt: 1})
|
||||
}
|
||||
if _, err := e.db.NewInsert().Model(&rows).Exec(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if _, err := e.add(e.alice, p.ID, -1, "b"); !errors.Is(err, playlists.ErrTooMany) {
|
||||
t.Errorf("one more than %d: err = %v, want ErrTooMany", playlists.MaxItems, err)
|
||||
}
|
||||
if got, _ := e.repo.Get(ctx, e.alice, p.ID); got.TrackCount != playlists.MaxItems {
|
||||
t.Errorf("track count = %d", got.TrackCount)
|
||||
}
|
||||
for i := 1; i < playlists.MaxPlaylists; i++ {
|
||||
if _, err := e.repo.Create(ctx, e.alice, "x", "", e.tick()); err != nil {
|
||||
t.Fatalf("playlist %d: %v", i+1, err)
|
||||
}
|
||||
}
|
||||
if _, err := e.repo.Create(ctx, e.alice, "one more", "", e.tick()); !errors.Is(err, playlists.ErrTooMany) {
|
||||
t.Errorf("one more than %d playlists: err = %v", playlists.MaxPlaylists, err)
|
||||
}
|
||||
if _, err := e.repo.Create(ctx, e.bob, "bobs", "", e.tick()); err != nil {
|
||||
t.Errorf("the limit is per user: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAddingAtTheSameTimeKeepsEveryPositionUnique(t *testing.T) {
|
||||
plBackends(t, func(t *testing.T, e *plEnv) {
|
||||
ctx := context.Background()
|
||||
p := e.create(e.alice, "P")
|
||||
var wg sync.WaitGroup
|
||||
errs := make(chan error, 8)
|
||||
for g := 0; g < 8; g++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for i := 0; i < 3; i++ {
|
||||
if _, err := e.repo.AddTracks(ctx, e.alice, p.ID, []int64{e.tracks["a"], e.tracks["b"]}, nil, time.Now()); err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(errs)
|
||||
for err := range errs {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if o := e.order(e.alice, p.ID); len(o) != 48 {
|
||||
t.Errorf("%d items, want 48", len(o))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
@ -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 != 18 {
|
||||
t.Errorf("applied migrations = %d, want 18", applied)
|
||||
if applied != 19 {
|
||||
t.Errorf("applied migrations = %d, want 19", applied)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue