feat(playlists): a user keeps playlists of tracks
Each user can make playlists: a name (1 to 200 characters), an optional description and an ordered list of tracks, where a track may appear more than once (each place has its own item id). The API makes, lists, renames and deletes playlists, and adds tracks (at the end or at a position), lists them, moves one and removes one; positions count from 0 without gaps. A playlist is its owner's alone: somebody else's answers playlist_not_found (404), as one that does not exist. A track whose files were deleted or moved stays in the playlist and is listed with available false. Deleting a user deletes their playlists. Limits: 1,000 playlists per user, 10,000 tracks per playlist, 500 tracks per request. Changes of one playlist are serialised by locking its row, so two requests at once keep the positions unique on PostgreSQL too. Migration 0019, OpenAPI spec, contract test, README and the web API types follow. The web app comes separately. Closes #89
This commit is contained in:
parent
bbb1e9847b
commit
f900a22904
11 changed files with 2732 additions and 2 deletions
|
|
@ -25,6 +25,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"
|
||||
|
|
@ -103,6 +104,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
|
||||
|
|
|
|||
|
|
@ -275,6 +275,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.
|
||||
|
|
@ -735,6 +744,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)
|
||||
}
|
||||
}
|
||||
|
|
@ -23,6 +23,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"
|
||||
|
|
@ -84,6 +85,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
|
||||
|
|
@ -151,6 +165,7 @@ type Deps struct {
|
|||
Taste tasteService
|
||||
Discover discoverService
|
||||
Feedback feedbackService
|
||||
Playlists playlistService
|
||||
Images coverService
|
||||
CoversJob jobService
|
||||
ArtistImagesJob jobService
|
||||
|
|
@ -218,6 +233,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
|
||||
|
|
@ -1038,6 +1040,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]
|
||||
|
|
@ -2092,6 +2298,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:
|
||||
|
|
@ -2677,6 +2893,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