Skip to content

🎧 Your Personal Streaming Service

Add tests to `/scrobble` endpoint

Deluan94533e585cf8
diff --git a/server/subsonic/media_annotation.go b/server/subsonic/media_annotation.go
index a5aa106a2..da6951416 100644
--- a/server/subsonic/media_annotation.go
+++ b/server/subsonic/media_annotation.go
@@ -17,13 +17,13 @@ import (
)
type MediaAnnotationController struct {
- ds model.DataStore
- scrobbler scrobbler.PlayTracker
- broker events.Broker
+ ds model.DataStore
+ playTracker scrobbler.PlayTracker
+ broker events.Broker
}
-func NewMediaAnnotationController(ds model.DataStore, scrobbler scrobbler.PlayTracker, broker events.Broker) *MediaAnnotationController {
- return &MediaAnnotationController{ds: ds, scrobbler: scrobbler, broker: broker}
+func NewMediaAnnotationController(ds model.DataStore, playTracker scrobbler.PlayTracker, broker events.Broker) *MediaAnnotationController {
+ return &MediaAnnotationController{ds: ds, playTracker: playTracker, broker: broker}
}
func (c *MediaAnnotationController) SetRating(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
@@ -115,6 +115,63 @@ func (c *MediaAnnotationController) Unstar(w http.ResponseWriter, r *http.Reques
return newResponse(), nil
}
+func (c *MediaAnnotationController) setStar(ctx context.Context, star bool, ids ...string) error {
+ if len(ids) == 0 {
+ return nil
+ }
+ log.Debug(ctx, "Changing starred", "ids", ids, "starred", star)
+ if len(ids) == 0 {
+ log.Warn(ctx, "Cannot star/unstar an empty list of ids")
+ return nil
+ }
+ event := &events.RefreshResource{}
+ err := c.ds.WithTx(func(tx model.DataStore) error {
+ for _, id := range ids {
+ exist, err := tx.Album(ctx).Exists(id)
+ if err != nil {
+ return err
+ }
+ if exist {
+ err = tx.Album(ctx).SetStar(star, id)
+ if err != nil {
+ return err
+ }
+ event = event.With("album", id)
+ continue
+ }
+ exist, err = tx.Artist(ctx).Exists(id)
+ if err != nil {
+ return err
+ }
+ if exist {
+ err = tx.Artist(ctx).SetStar(star, id)
+ if err != nil {
+ return err
+ }
+ event = event.With("artist", id)
+ continue
+ }
+ err = tx.MediaFile(ctx).SetStar(star, id)
+ if err != nil {
+ return err
+ }
+ event = event.With("song", id)
+ }
+ c.broker.SendMessage(ctx, event)
+ return nil
+ })
+
+ switch {
+ case err == model.ErrNotFound:
+ log.Error(ctx, err)
+ return newError(responses.ErrorDataNotFound, "ID not found")
+ case err != nil:
+ log.Error(ctx, err)
+ return err
+ }
+ return nil
+}
+
func (c *MediaAnnotationController) Scrobble(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
ids, err := requiredParamStrings(r, "id")
if err != nil {
@@ -155,7 +212,7 @@ func (c *MediaAnnotationController) scrobblerSubmit(ctx context.Context, ids []s
submissions = append(submissions, scrobbler.Submission{TrackID: id, Timestamp: t})
}
- return c.scrobbler.Submit(ctx, submissions)
+ return c.playTracker.Submit(ctx, submissions)
}
func (c *MediaAnnotationController) scrobblerNowPlaying(ctx context.Context, trackId string) error {
@@ -176,63 +233,6 @@ func (c *MediaAnnotationController) scrobblerNowPlaying(ctx context.Context, tra
}
log.Info("Now Playing", "title", mf.Title, "artist", mf.Artist, "user", username, "player", player.Name)
- err = c.scrobbler.NowPlaying(ctx, clientId, client, trackId)
+ err = c.playTracker.NowPlaying(ctx, clientId, client, trackId)
return err
}
-
-func (c *MediaAnnotationController) setStar(ctx context.Context, star bool, ids ...string) error {
- if len(ids) == 0 {
- return nil
- }
- log.Debug(ctx, "Changing starred", "ids", ids, "starred", star)
- if len(ids) == 0 {
- log.Warn(ctx, "Cannot star/unstar an empty list of ids")
- return nil
- }
- event := &events.RefreshResource{}
- err := c.ds.WithTx(func(tx model.DataStore) error {
- for _, id := range ids {
- exist, err := tx.Album(ctx).Exists(id)
- if err != nil {
- return err
- }
- if exist {
- err = tx.Album(ctx).SetStar(star, id)
- if err != nil {
- return err
- }
- event = event.With("album", id)
- continue
- }
- exist, err = tx.Artist(ctx).Exists(id)
- if err != nil {
- return err
- }
- if exist {
- err = tx.Artist(ctx).SetStar(star, id)
- if err != nil {
- return err
- }
- event = event.With("artist", id)
- continue
- }
- err = tx.MediaFile(ctx).SetStar(star, id)
- if err != nil {
- return err
- }
- event = event.With("song", id)
- }
- c.broker.SendMessage(ctx, event)
- return nil
- })
-
- switch {
- case err == model.ErrNotFound:
- log.Error(ctx, err)
- return newError(responses.ErrorDataNotFound, "ID not found")
- case err != nil:
- log.Error(ctx, err)
- return err
- }
- return nil
-}
diff --git a/server/subsonic/media_annotation_test.go b/server/subsonic/media_annotation_test.go
new file mode 100644
index 000000000..ea7fc723e
--- /dev/null
+++ b/server/subsonic/media_annotation_test.go
@@ -0,0 +1,146 @@
+package subsonic
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "time"
+
+ "github.com/navidrome/navidrome/model/request"
+
+ "github.com/navidrome/navidrome/core/scrobbler"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils"
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("MediaAnnotationController", func() {
+ var controller *MediaAnnotationController
+ var w *httptest.ResponseRecorder
+ var ds model.DataStore
+ var playTracker *fakePlayTracker
+ var eventBroker *fakeEventBroker
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ ds = &tests.MockDataStore{}
+ playTracker = &fakePlayTracker{}
+ eventBroker = &fakeEventBroker{}
+ controller = NewMediaAnnotationController(ds, playTracker, eventBroker)
+ w = httptest.NewRecorder()
+ })
+
+ Describe("Scrobble", func() {
+ It("submit all scrobbles with only the id", func() {
+ submissionTime := time.Now()
+ r := newGetRequest("id=12", "id=34")
+
+ _, err := controller.Scrobble(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(playTracker.Submissions).To(HaveLen(2))
+ Expect(playTracker.Submissions[0].Timestamp).To(BeTemporally(">", submissionTime))
+ Expect(playTracker.Submissions[0].TrackID).To(Equal("12"))
+ Expect(playTracker.Submissions[1].Timestamp).To(BeTemporally(">", submissionTime))
+ Expect(playTracker.Submissions[1].TrackID).To(Equal("34"))
+ })
+
+ It("submit all scrobbles with respective times", func() {
+ time1 := time.Now().Add(-20 * time.Minute)
+ t1 := utils.ToMillis(time1)
+ time2 := time.Now().Add(-10 * time.Minute)
+ t2 := utils.ToMillis(time2)
+ r := newGetRequest("id=12", "id=34", fmt.Sprintf("time=%d", t1), fmt.Sprintf("time=%d", t2))
+
+ _, err := controller.Scrobble(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(playTracker.Submissions).To(HaveLen(2))
+ Expect(playTracker.Submissions[0].Timestamp).To(BeTemporally("~", time1))
+ Expect(playTracker.Submissions[0].TrackID).To(Equal("12"))
+ Expect(playTracker.Submissions[1].Timestamp).To(BeTemporally("~", time2))
+ Expect(playTracker.Submissions[1].TrackID).To(Equal("34"))
+ })
+
+ It("checks if number of ids match number of times", func() {
+ r := newGetRequest("id=12", "id=34", "time=1111")
+
+ _, err := controller.Scrobble(w, r)
+
+ Expect(err).To(HaveOccurred())
+ Expect(playTracker.Submissions).To(BeEmpty())
+ })
+
+ Context("submission=false", func() {
+ var req *http.Request
+ BeforeEach(func() {
+ _ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "12"})
+ ctx = request.WithPlayer(ctx, model.Player{ID: "player-1"})
+ req = newGetRequest("id=12", "submission=false")
+ req = req.WithContext(ctx)
+ })
+
+ It("does not scrobble", func() {
+ _, err := controller.Scrobble(w, req)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(playTracker.Submissions).To(BeEmpty())
+ })
+
+ It("registers a NowPlaying", func() {
+ _, err := controller.Scrobble(w, req)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(playTracker.Playing).To(HaveLen(1))
+ Expect(playTracker.Playing).To(HaveKey("player-1"))
+ })
+ })
+ })
+})
+
+type fakePlayTracker struct {
+ Submissions []scrobbler.Submission
+ Playing map[string]string
+ Error error
+}
+
+func (f *fakePlayTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error {
+ if f.Error != nil {
+ return f.Error
+ }
+ if f.Playing == nil {
+ f.Playing = make(map[string]string)
+ }
+ f.Playing[playerId] = trackId
+ return nil
+}
+
+func (f *fakePlayTracker) GetNowPlaying(ctx context.Context) ([]scrobbler.NowPlayingInfo, error) {
+ return nil, f.Error
+}
+
+func (f *fakePlayTracker) Submit(ctx context.Context, submissions []scrobbler.Submission) error {
+ if f.Error != nil {
+ return f.Error
+ }
+ f.Submissions = append(f.Submissions, submissions...)
+ return nil
+}
+
+var _ scrobbler.PlayTracker = (*fakePlayTracker)(nil)
+
+type fakeEventBroker struct {
+ http.Handler
+ Events []events.Event
+}
+
+func (f *fakeEventBroker) SendMessage(ctx context.Context, event events.Event) {
+ f.Events = append(f.Events, event)
+}
+
+var _ events.Broker = (*fakeEventBroker)(nil)