navidrome/persistence/scrobble_buffer_repository_test.go
Deluan Quintão e9c0efa446
chore(lint): enable staticcheck (#6485)
Enforces the default staticcheck SA, S, ST and QF checks; fixed 76 sites (54 autofixed quick fixes, 22 by hand).
Dot imports are allowed only for squirrel, the established query builder style in persistence.
SA1019 is excluded for the deprecated plugins/types.SongRef wire fields the host still reads and writes for older plugins.
Also fixes an off-by-one in the redactrus test levelThreshold helper that panicked one level past TraceLevel.
2026-11-16 22:48:42 -05:00

230 lines
6.8 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("ScrobbleBufferRepository", func() {
var scrobble model.ScrobbleBufferRepository
var rawRepo sqlRepository
var ctx context.Context
enqueueTime := time.Date(2025, 01, 01, 00, 00, 00, 00, time.Local)
var ids []string
var insertManually = func(service, userId, mediaFileId string, playTime time.Time) {
id := id.NewRandom()
ids = append(ids, id)
ins := squirrel.Insert("scrobble_buffer").SetMap(map[string]any{
"id": id,
"user_id": userId,
"service": service,
"media_file_id": mediaFileId,
"play_time": playTime,
"enqueue_time": enqueueTime,
})
_, err := rawRepo.executeSQL(ctx, ins)
Expect(err).ToNot(HaveOccurred())
}
BeforeEach(func() {
ctx = request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "johndoe", IsAdmin: true})
db := GetDBXBuilder()
scrobble = NewScrobbleBufferRepository(db)
rawRepo = sqlRepository{
tableName: "scrobble_buffer",
db: db,
}
ids = []string{}
})
AfterEach(func() {
del := squirrel.Delete(rawRepo.tableName)
_, err := rawRepo.executeSQL(ctx, del)
Expect(err).ToNot(HaveOccurred())
})
Describe("Without data", func() {
Describe("Count", func() {
It("returns zero when empty", func() {
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(BeZero())
})
})
Describe("Dequeue", func() {
It("is a no-op when deleting a nonexistent item", func() {
err := scrobble.Dequeue(ctx, &model.ScrobbleEntry{ID: "fake"})
Expect(err).ToNot(HaveOccurred())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(0)))
})
})
Describe("Next", func() {
It("should not fail with no item for the service", func() {
entry, err := scrobble.Next(ctx, "fake", "userid")
Expect(entry).To(BeNil())
Expect(err).ToNot(HaveOccurred())
})
})
Describe("UserIds", func() {
It("should return empty list with no data", func() {
ids, err := scrobble.UserIDs(ctx, "service")
Expect(err).ToNot(HaveOccurred())
Expect(ids).To(BeEmpty())
})
})
})
Describe("With data", func() {
timeA := enqueueTime.Add(24 * time.Hour)
timeB := enqueueTime.Add(48 * time.Hour)
timeC := enqueueTime.Add(72 * time.Hour)
timeD := enqueueTime.Add(96 * time.Hour)
BeforeEach(func() {
insertManually("a", "userid", "1001", timeB)
insertManually("a", "userid", "1002", timeA)
insertManually("a", "2222", "1003", timeC)
insertManually("b", "2222", "1004", timeD)
})
Describe("Count", func() {
It("Returns count when populated", func() {
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(4)))
})
})
Describe("Dequeue", func() {
It("is a no-op when deleting a nonexistent item", func() {
err := scrobble.Dequeue(ctx, &model.ScrobbleEntry{ID: "fake"})
Expect(err).ToNot(HaveOccurred())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(4)))
})
It("deletes an item when specified properly", func() {
err := scrobble.Dequeue(ctx, &model.ScrobbleEntry{ID: ids[3]})
Expect(err).ToNot(HaveOccurred())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(3)))
entry, err := scrobble.Next(ctx, "b", "2222")
Expect(err).ToNot(HaveOccurred())
Expect(entry).To(BeNil())
})
})
Describe("Enqueue", func() {
DescribeTable("enqueues an item properly",
func(service, userId, fileId string, playTime time.Time) {
now := time.Now()
err := scrobble.Enqueue(ctx, service, userId, fileId, playTime)
Expect(err).ToNot(HaveOccurred())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(5)))
entry, err := scrobble.Next(ctx, service, userId)
Expect(err).ToNot(HaveOccurred())
Expect(entry).ToNot(BeNil())
Expect(entry.EnqueueTime).To(BeTemporally("~", now, 100*time.Millisecond))
Expect(entry.MediaFileID).To(Equal(fileId))
Expect(entry.PlayTime).To(BeTemporally("==", playTime))
},
Entry("to an existing service with multiple values", "a", "userid", "1004", enqueueTime),
Entry("to a new service", "c", "2222", "1001", timeD),
Entry("to an existing service as new user", "b", "userid", "1003", timeC),
)
})
Describe("Next", func() {
DescribeTable("Returns the next item when populated",
func(service, id string, playTime time.Time, fileId, artistId string) {
entry, err := scrobble.Next(ctx, service, id)
Expect(err).ToNot(HaveOccurred())
Expect(entry).ToNot(BeNil())
Expect(entry.Service).To(Equal(service))
Expect(entry.UserID).To(Equal(id))
Expect(entry.PlayTime).To(BeTemporally("==", playTime))
Expect(entry.EnqueueTime).To(BeTemporally("==", enqueueTime))
Expect(entry.MediaFileID).To(Equal(fileId))
Expect(entry.MediaFile.Participants).To(HaveLen(1))
artists, ok := entry.Participants[model.RoleArtist]
Expect(ok).To(BeTrue(), "no artist role in participants")
Expect(artists).To(HaveLen(1))
Expect(artists[0].ID).To(Equal(artistId))
},
Entry("Service with multiple values for one user", "a", "userid", timeA, "1002", "3"),
Entry("Service with users", "a", "2222", timeC, "1003", "2"),
Entry("Service with one user", "b", "2222", timeD, "1004", "2"),
)
})
Describe("Discard", func() {
It("deletes all entries for a service, keeping other services intact", func() {
Expect(scrobble.Discard(ctx, "a")).To(Succeed())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(1)))
entry, err := scrobble.Next(ctx, "b", "2222")
Expect(err).ToNot(HaveOccurred())
Expect(entry).ToNot(BeNil())
})
It("is a no-op for a service without entries", func() {
Expect(scrobble.Discard(ctx, "nonexistent")).To(Succeed())
count, err := scrobble.Length(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(count).To(Equal(int64(4)))
})
})
Describe("UserIds", func() {
It("should return ordered list for services", func() {
ids, err := scrobble.UserIDs(ctx, "a")
Expect(err).ToNot(HaveOccurred())
Expect(ids).To(Equal([]string{"2222", "userid"}))
})
It("should return for a different service", func() {
ids, err := scrobble.UserIDs(ctx, "b")
Expect(err).ToNot(HaveOccurred())
Expect(ids).To(Equal([]string{"2222"}))
})
})
})
})