mirror of
https://github.com/navidrome/navidrome.git
synced 2025-04-03 20:47:35 +03:00
116 lines
3.4 KiB
Go
116 lines
3.4 KiB
Go
package persistence
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/Masterminds/squirrel"
|
|
"github.com/google/uuid"
|
|
"github.com/navidrome/navidrome/db"
|
|
"github.com/navidrome/navidrome/log"
|
|
"github.com/navidrome/navidrome/model"
|
|
"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(context.TODO())
|
|
ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "userid", IsAdmin: true})
|
|
repo = NewPlayQueueRepository(ctx, NewDBXBuilder(db.Db()))
|
|
})
|
|
|
|
Describe("PlayQueues", func() {
|
|
It("returns notfound error if there's no playqueue for the user", func() {
|
|
_, err := repo.Retrieve("user999")
|
|
Expect(err).To(MatchError(model.ErrNotFound))
|
|
})
|
|
|
|
It("stores and retrieves the playqueue for the user", func() {
|
|
By("Storing a playqueue for the user")
|
|
|
|
expected := aPlayQueue("userid", songDayInALife.ID, 123, songComeTogether, songDayInALife)
|
|
Expect(repo.Store(expected)).To(Succeed())
|
|
|
|
actual, err := repo.Retrieve("userid")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
AssertPlayQueue(expected, actual)
|
|
|
|
By("Storing a new playqueue for the same user")
|
|
|
|
another := aPlayQueue("userid", songRadioactivity.ID, 321, songAntenna, songRadioactivity)
|
|
Expect(repo.Store(another)).To(Succeed())
|
|
|
|
actual, err = repo.Retrieve("userid")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
AssertPlayQueue(another, actual)
|
|
Expect(countPlayQueues(repo, "userid")).To(Equal(1))
|
|
})
|
|
|
|
It("does not return tracks if they don't exist in the DB", func() {
|
|
// Add a new song to the DB
|
|
newSong := songRadioactivity
|
|
newSong.ID = "temp-track"
|
|
mfRepo := NewMediaFileRepository(ctx, NewDBXBuilder(db.Db()))
|
|
|
|
Expect(mfRepo.Put(&newSong)).To(Succeed())
|
|
|
|
// Create a playqueue with the new song
|
|
pq := aPlayQueue("userid", newSong.ID, 0, newSong, songAntenna)
|
|
Expect(repo.Store(pq)).To(Succeed())
|
|
|
|
// Delete the new song
|
|
Expect(mfRepo.Delete("temp-track")).To(Succeed())
|
|
|
|
// Retrieve the playqueue
|
|
actual, err := repo.Retrieve("userid")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// The playqueue should not contain the deleted track
|
|
Expect(actual.Items).To(HaveLen(1))
|
|
Expect(actual.Items[0].ID).To(Equal(songAntenna.ID))
|
|
})
|
|
})
|
|
})
|
|
|
|
func countPlayQueues(repo model.PlayQueueRepository, userId string) int {
|
|
r := repo.(*playQueueRepository)
|
|
c, err := r.count(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, current string, position int64, items ...model.MediaFile) *model.PlayQueue {
|
|
createdAt := time.Now()
|
|
updatedAt := createdAt.Add(time.Minute)
|
|
return &model.PlayQueue{
|
|
ID: uuid.NewString(),
|
|
UserID: userId,
|
|
Current: current,
|
|
Position: position,
|
|
ChangedBy: "test",
|
|
Items: items,
|
|
CreatedAt: createdAt,
|
|
UpdatedAt: updatedAt,
|
|
}
|
|
}
|