Files
navidrome/persistence/playqueue_repository_test.go
T
Deluan d4eecb2785 fix(playqueue): refuse queue index updates when tracks fail to load
RetrieveWithMediaFiles now returns ErrIncompleteQueue when it reads the queue but a track query fails. Before, it returned the partially loaded list with no error, and a current-only PUT /api/queue could validate and map an index against that list and store the wrong track.

updateQueue already fails on any retrieval error, so it now returns 500 and writes nothing. The GET handlers (getPlayQueue, getPlayQueueByIndex and GET /api/queue) treat ErrIncompleteQueue like before and still return the tracks that loaded.
2026-11-14 19:46:18 -05:00

465 lines
17 KiB
Go

package persistence
import (
"context"
"time"
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
"github.com/navidrome/navidrome/model/request"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
var _ = Describe("PlayQueueRepository", func() {
var repo model.PlayQueueRepository
var ctx context.Context
BeforeEach(func() {
ctx = log.NewContext(GinkgoT().Context())
ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "userid", IsAdmin: true})
repo = NewPlayQueueRepository(GetDBXBuilder())
})
Describe("Store", func() {
It("stores a complete playqueue", func() {
expected := aPlayQueue("userid", 1, 123, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, expected)).To(Succeed())
actual, err := repo.RetrieveWithMediaFiles(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
AssertPlayQueue(expected, actual)
Expect(countPlayQueues(repo, "userid")).To(Equal(1))
})
It("replaces existing playqueue when storing without column names", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Storing replacement playqueue")
replacement := aPlayQueue("userid", 1, 200, songDayInALife, songAntenna)
Expect(repo.Store(ctx, replacement)).To(Succeed())
actual, err := repo.RetrieveWithMediaFiles(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
AssertPlayQueue(replacement, actual)
Expect(countPlayQueues(repo, "userid")).To(Equal(1))
})
It("clears playqueue when storing empty items", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Storing empty playqueue")
empty := aPlayQueue("userid", 0, 0)
Expect(repo.Store(ctx, empty)).To(Succeed())
By("Verifying playqueue is cleared")
_, err := repo.Retrieve(ctx, "userid")
Expect(err).To(MatchError(model.ErrNotFound))
})
It("updates only current field when specified", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Getting the existing playqueue to obtain its ID")
existing, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
By("Updating only current field")
update := &model.PlayQueue{
ID: existing.ID, // Use existing ID for partial update
UserID: "userid",
Current: 1,
ChangedBy: "test-update",
}
Expect(repo.Store(ctx, update, "current")).To(Succeed())
By("Verifying only current was updated")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Current).To(Equal(1))
Expect(actual.Position).To(Equal(int64(100))) // Should remain unchanged
Expect(actual.Items).To(HaveLen(2)) // Should remain unchanged
})
It("updates only position field when specified", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 1, 100, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Getting the existing playqueue to obtain its ID")
existing, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
By("Updating only position field")
update := &model.PlayQueue{
ID: existing.ID, // Use existing ID for partial update
UserID: "userid",
Position: 500,
ChangedBy: "test-update",
}
Expect(repo.Store(ctx, update, "position")).To(Succeed())
By("Verifying only position was updated")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Position).To(Equal(int64(500)))
Expect(actual.Current).To(Equal(1)) // Should remain unchanged
Expect(actual.Items).To(HaveLen(2)) // Should remain unchanged
})
It("updates multiple specified fields", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Getting the existing playqueue to obtain its ID")
existing, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
By("Updating current and position fields")
update := &model.PlayQueue{
ID: existing.ID, // Use existing ID for partial update
UserID: "userid",
Current: 1,
Position: 300,
ChangedBy: "test-update",
}
Expect(repo.Store(ctx, update, "current", "position")).To(Succeed())
By("Verifying both fields were updated")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Current).To(Equal(1))
Expect(actual.Position).To(Equal(int64(300)))
Expect(actual.Items).To(HaveLen(1)) // Should remain unchanged
})
It("preserves existing data when updating with empty items list and column names", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, initial)).To(Succeed())
By("Getting the existing playqueue to obtain its ID")
existing, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
By("Updating only position with empty items")
update := &model.PlayQueue{
ID: existing.ID, // Use existing ID for partial update
UserID: "userid",
Position: 200,
ChangedBy: "test-update",
Items: []model.MediaFile{}, // Empty items
}
Expect(repo.Store(ctx, update, "position")).To(Succeed())
By("Verifying items are preserved")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Position).To(Equal(int64(200)))
Expect(actual.Items).To(HaveLen(2)) // Should remain unchanged
})
It("ensures only one record per user by reusing existing record ID", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether)
Expect(repo.Store(ctx, initial)).To(Succeed())
initialCount := countPlayQueues(repo, "userid")
Expect(initialCount).To(Equal(1))
By("Storing another playqueue with different ID but same user")
different := aPlayQueue("userid", 1, 200, songDayInALife)
different.ID = "different-id" // Force a different ID
Expect(repo.Store(ctx, different)).To(Succeed())
By("Verifying only one record exists for the user")
finalCount := countPlayQueues(repo, "userid")
Expect(finalCount).To(Equal(1))
By("Verifying the record was updated, not duplicated")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Current).To(Equal(1)) // Should be updated value
Expect(actual.Position).To(Equal(int64(200))) // Should be updated value
Expect(actual.Items).To(HaveLen(1)) // Should be new items
Expect(actual.Items[0].ID).To(Equal(songDayInALife.ID))
})
It("ensures only one record per user even with partial updates", func() {
By("Storing initial playqueue")
initial := aPlayQueue("userid", 0, 100, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, initial)).To(Succeed())
initialCount := countPlayQueues(repo, "userid")
Expect(initialCount).To(Equal(1))
By("Storing partial update with different ID but same user")
partialUpdate := &model.PlayQueue{
ID: "completely-different-id", // Use a completely different ID
UserID: "userid",
Current: 1,
ChangedBy: "test-partial",
}
Expect(repo.Store(ctx, partialUpdate, "current")).To(Succeed())
By("Verifying only one record still exists for the user")
finalCount := countPlayQueues(repo, "userid")
Expect(finalCount).To(Equal(1))
By("Verifying the existing record was updated with new current value")
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
Expect(actual.Current).To(Equal(1)) // Should be updated value
Expect(actual.Position).To(Equal(int64(100))) // Should remain unchanged
Expect(actual.Items).To(HaveLen(2)) // Should remain unchanged
})
})
Describe("Retrieve", func() {
It("returns notfound error if there's no playqueue for the user", func() {
_, err := repo.Retrieve(ctx, "user999")
Expect(err).To(MatchError(model.ErrNotFound))
})
It("retrieves the playqueue with only track IDs (no full MediaFile data)", func() {
By("Storing a playqueue for the user")
expected := aPlayQueue("userid", 1, 123, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, expected)).To(Succeed())
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
// Basic playqueue properties should match
Expect(actual.ID).To(Equal(expected.ID))
Expect(actual.UserID).To(Equal(expected.UserID))
Expect(actual.Current).To(Equal(expected.Current))
Expect(actual.Position).To(Equal(expected.Position))
Expect(actual.ChangedBy).To(Equal(expected.ChangedBy))
Expect(actual.Items).To(HaveLen(len(expected.Items)))
// Items should only contain IDs, not full MediaFile data
for i, item := range actual.Items {
Expect(item.ID).To(Equal(expected.Items[i].ID))
// These fields should be empty since we're not loading full MediaFiles
Expect(item.Title).To(BeEmpty())
Expect(item.Path).To(BeEmpty())
Expect(item.Album).To(BeEmpty())
Expect(item.Artist).To(BeEmpty())
}
})
It("returns items with IDs even when some tracks don't exist in the DB", func() {
// Add a new song to the DB
newSong := songRadioactivity
newSong.ID = "temp-track"
newSong.Path = "/new-path"
mfRepo := NewMediaFileRepository(GetDBXBuilder())
Expect(mfRepo.Put(ctx, &newSong)).To(Succeed())
// Create a playqueue with the new song
pq := aPlayQueue("userid", 0, 0, newSong, songAntenna)
Expect(repo.Store(ctx, pq)).To(Succeed())
// Delete the new song from the database
Expect(mfRepo.Delete(ctx, "temp-track")).To(Succeed())
// Retrieve the playqueue with Retrieve method
actual, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
// The playqueue should still contain both track IDs (including the deleted one)
Expect(actual.Items).To(HaveLen(2))
Expect(actual.Items[0].ID).To(Equal("temp-track"))
Expect(actual.Items[1].ID).To(Equal(songAntenna.ID))
// Items should only contain IDs, no other data
for _, item := range actual.Items {
Expect(item.Title).To(BeEmpty())
Expect(item.Path).To(BeEmpty())
Expect(item.Album).To(BeEmpty())
Expect(item.Artist).To(BeEmpty())
}
})
})
Describe("RetrieveWithMediaFiles", func() {
It("returns notfound error if there's no playqueue for the user", func() {
_, err := repo.RetrieveWithMediaFiles(ctx, "user999")
Expect(err).To(MatchError(model.ErrNotFound))
})
It("retrieves the playqueue with full MediaFile data", func() {
By("Storing a playqueue for the user")
expected := aPlayQueue("userid", 1, 123, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, expected)).To(Succeed())
actual, err := repo.RetrieveWithMediaFiles(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
AssertPlayQueue(expected, actual)
})
It("returns ErrIncompleteQueue with the queue as stored when the tracks fail to load", func() {
Expect(repo.Store(ctx, aPlayQueue("userid", 1, 45, songComeTogether, songDayInALife))).To(Succeed())
tx, err := GetDBXBuilder().Begin()
Expect(err).ToNot(HaveOccurred())
DeferCleanup(func() { _ = tx.Rollback() })
_, err = tx.NewQuery("ALTER TABLE media_file RENAME TO media_file_unavailable").Execute()
Expect(err).ToNot(HaveOccurred())
actual, err := NewPlayQueueRepository(tx).RetrieveWithMediaFiles(ctx, "userid")
Expect(err).To(MatchError(model.ErrIncompleteQueue))
Expect(actual.Items).To(BeEmpty())
Expect(actual.Current).To(Equal(1))
Expect(actual.Position).To(Equal(int64(45)))
})
Context("when tracks are no longer in the library", func() {
var mfRepo model.MediaFileRepository
gone := songRadioactivity
gone.ID = "gone-track"
gone.Path = "/gone-track"
BeforeEach(func() {
mfRepo = NewMediaFileRepository(GetDBXBuilder())
Expect(mfRepo.Put(ctx, &gone)).To(Succeed())
DeferCleanup(func() { _ = mfRepo.Delete(ctx, gone.ID) })
})
retrieveAfterRemoval := func(current int, position int64, items ...model.MediaFile) *model.PlayQueue {
Expect(repo.Store(ctx, aPlayQueue("userid", current, position, items...))).To(Succeed())
Expect(mfRepo.Delete(ctx, gone.ID)).To(Succeed())
actual, err := repo.RetrieveWithMediaFiles(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
return actual
}
DescribeTable("points to the right current track",
func(current int, items []model.MediaFile, expectedID string, expectedPosition int64) {
actual := retrieveAfterRemoval(current, 45, items...)
Expect(actual.Items).To(HaveLen(len(items) - 1))
Expect(actual.Items[actual.Current].ID).To(Equal(expectedID))
Expect(actual.Position).To(Equal(expectedPosition))
},
Entry("when an earlier track is removed", 1, []model.MediaFile{gone, songComeTogether, songDayInALife}, songComeTogether.ID, int64(45)),
Entry("when a later track is removed", 0, []model.MediaFile{songComeTogether, gone}, songComeTogether.ID, int64(45)),
Entry("moving to the next track from the start when the current one is removed", 1, []model.MediaFile{songComeTogether, gone, songDayInALife}, songDayInALife.ID, int64(0)),
Entry("moving to the last track when the removed current one was the last", 1, []model.MediaFile{songComeTogether, gone}, songComeTogether.ID, int64(0)),
)
It("leaves the stored queue untouched", func() {
retrieveAfterRemoval(1, 45, gone, songComeTogether, songDayInALife)
Consistently(func(g Gomega) {
stored, err := repo.Retrieve(ctx, "userid")
g.Expect(err).ToNot(HaveOccurred())
g.Expect(stored.Items).To(HaveLen(3))
g.Expect(stored.Items[0].ID).To(Equal(gone.ID))
g.Expect(stored.Current).To(Equal(1))
g.Expect(stored.Position).To(Equal(int64(45)))
}).Should(Succeed())
})
})
})
Describe("Clear", func() {
It("clears an existing playqueue", func() {
By("Storing a playqueue")
expected := aPlayQueue("userid", 1, 123, songComeTogether, songDayInALife)
Expect(repo.Store(ctx, expected)).To(Succeed())
By("Verifying playqueue exists")
_, err := repo.Retrieve(ctx, "userid")
Expect(err).ToNot(HaveOccurred())
By("Clearing the playqueue")
Expect(repo.Clear(ctx, "userid")).To(Succeed())
By("Verifying playqueue is cleared")
_, err = repo.Retrieve(ctx, "userid")
Expect(err).To(MatchError(model.ErrNotFound))
})
It("does not error when clearing non-existent playqueue", func() {
// Clear should not error even if no playqueue exists
Expect(repo.Clear(ctx, "nonexistent-user")).To(Succeed())
})
It("only clears the specified user's playqueue", func() {
By("Creating users in the database to avoid foreign key constraints")
userRepo := NewUserRepository(GetDBXBuilder())
user1 := &model.User{ID: "user1", UserName: "user1", Name: "User 1", Email: "user1@test.com"}
user2 := &model.User{ID: "user2", UserName: "user2", Name: "User 2", Email: "user2@test.com"}
Expect(userRepo.Put(ctx, user1)).To(Succeed())
Expect(userRepo.Put(ctx, user2)).To(Succeed())
By("Storing playqueues for two users")
user1Queue := aPlayQueue("user1", 0, 100, songComeTogether)
user2Queue := aPlayQueue("user2", 1, 200, songDayInALife)
Expect(repo.Store(ctx, user1Queue)).To(Succeed())
Expect(repo.Store(ctx, user2Queue)).To(Succeed())
By("Clearing only user1's playqueue")
Expect(repo.Clear(ctx, "user1")).To(Succeed())
By("Verifying user1's playqueue is cleared")
_, err := repo.Retrieve(ctx, "user1")
Expect(err).To(MatchError(model.ErrNotFound))
By("Verifying user2's playqueue still exists")
actual, err := repo.Retrieve(ctx, "user2")
Expect(err).ToNot(HaveOccurred())
Expect(actual.UserID).To(Equal("user2"))
Expect(actual.Current).To(Equal(1))
Expect(actual.Position).To(Equal(int64(200)))
})
})
})
func countPlayQueues(repo model.PlayQueueRepository, userId string) int {
r := repo.(*playQueueRepository)
c, err := r.count(GinkgoT().Context(), squirrel.Select().Where(squirrel.Eq{"user_id": userId}))
if err != nil {
panic(err)
}
return int(c)
}
func AssertPlayQueue(expected, actual *model.PlayQueue) {
Expect(actual.ID).To(Equal(expected.ID))
Expect(actual.UserID).To(Equal(expected.UserID))
Expect(actual.Current).To(Equal(expected.Current))
Expect(actual.Position).To(Equal(expected.Position))
Expect(actual.ChangedBy).To(Equal(expected.ChangedBy))
Expect(actual.Items).To(HaveLen(len(expected.Items)))
for i, item := range actual.Items {
Expect(item.Title).To(Equal(expected.Items[i].Title))
}
}
func aPlayQueue(userId string, current int, position int64, items ...model.MediaFile) *model.PlayQueue {
createdAt := time.Now()
updatedAt := createdAt.Add(time.Minute)
return &model.PlayQueue{
ID: id.NewRandom(),
UserID: userId,
Current: current,
Position: position,
ChangedBy: "test",
Items: items,
CreatedAt: createdAt,
UpdatedAt: updatedAt,
}
}