Move engine package under subsonic, as it should only be used by the Subsonic API.master

The idea is to move reusable code from `engine` to `core`, in future refactorings

server/subsonic/engine/browser.go

@@ -0,0 +1,213 @@
+package engine
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/utils"
+)
+
+type Browser interface {
+	MediaFolders(ctx context.Context) (model.MediaFolders, error)
+	Indexes(ctx context.Context, mediaFolderId string, ifModifiedSince time.Time) (model.ArtistIndexes, time.Time, error)
+	Directory(ctx context.Context, id string) (*DirectoryInfo, error)
+	Artist(ctx context.Context, id string) (*DirectoryInfo, error)
+	Album(ctx context.Context, id string) (*DirectoryInfo, error)
+	GetSong(ctx context.Context, id string) (*Entry, error)
+	GetGenres(ctx context.Context) (model.Genres, error)
+}
+
+func NewBrowser(ds model.DataStore) Browser {
+	return &browser{ds}
+}
+
+type browser struct {
+	ds model.DataStore
+}
+
+func (b *browser) MediaFolders(ctx context.Context) (model.MediaFolders, error) {
+	return b.ds.MediaFolder(ctx).GetAll()
+}
+
+func (b *browser) Indexes(ctx context.Context, mediaFolderId string, ifModifiedSince time.Time) (model.ArtistIndexes, time.Time, error) {
+	// TODO Proper handling of mediaFolderId param
+	folder, _ := b.ds.MediaFolder(ctx).Get(mediaFolderId)
+
+	l, err := b.ds.Property(ctx).DefaultGet(model.PropLastScan+"-"+folder.Path, "-1")
+	ms, _ := strconv.ParseInt(l, 10, 64)
+	lastModified := utils.ToTime(ms)
+
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("error retrieving LastScan property: %v", err)
+	}
+
+	if lastModified.After(ifModifiedSince) {
+		indexes, err := b.ds.Artist(ctx).GetIndex()
+		return indexes, lastModified, err
+	}
+
+	return nil, lastModified, nil
+}
+
+type DirectoryInfo struct {
+	Id         string
+	Name       string
+	Entries    Entries
+	Parent     string
+	Starred    time.Time
+	PlayCount  int64
+	UserRating int
+	AlbumCount int
+	CoverArt   string
+	Artist     string
+	ArtistId   string
+	SongCount  int
+	Duration   int
+	Created    time.Time
+	Year       int
+	Genre      string
+}
+
+func (b *browser) Artist(ctx context.Context, id string) (*DirectoryInfo, error) {
+	a, albums, err := b.retrieveArtist(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(ctx, "Found Artist", "id", id, "name", a.Name)
+	return b.buildArtistDir(a, albums), nil
+}
+
+func (b *browser) Album(ctx context.Context, id string) (*DirectoryInfo, error) {
+	al, tracks, err := b.retrieveAlbum(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(ctx, "Found Album", "id", id, "name", al.Name)
+	return b.buildAlbumDir(al, tracks), nil
+}
+
+func (b *browser) Directory(ctx context.Context, id string) (*DirectoryInfo, error) {
+	switch {
+	case b.isArtist(ctx, id):
+		return b.Artist(ctx, id)
+	case b.isAlbum(ctx, id):
+		return b.Album(ctx, id)
+	default:
+		log.Debug(ctx, "Directory not found", "id", id)
+		return nil, model.ErrNotFound
+	}
+}
+
+func (b *browser) GetSong(ctx context.Context, id string) (*Entry, error) {
+	mf, err := b.ds.MediaFile(ctx).Get(id)
+	if err != nil {
+		return nil, err
+	}
+
+	entry := FromMediaFile(mf)
+	return &entry, nil
+}
+
+func (b *browser) GetGenres(ctx context.Context) (model.Genres, error) {
+	genres, err := b.ds.Genre(ctx).GetAll()
+	for i, g := range genres {
+		if strings.TrimSpace(g.Name) == "" {
+			genres[i].Name = "<Empty>"
+		}
+	}
+	sort.Slice(genres, func(i, j int) bool {
+		return genres[i].Name < genres[j].Name
+	})
+	return genres, err
+}
+
+func (b *browser) buildArtistDir(a *model.Artist, albums model.Albums) *DirectoryInfo {
+	dir := &DirectoryInfo{
+		Id:         a.ID,
+		Name:       a.Name,
+		AlbumCount: a.AlbumCount,
+	}
+
+	dir.Entries = make(Entries, len(albums))
+	for i := range albums {
+		al := albums[i]
+		dir.Entries[i] = FromAlbum(&al)
+		dir.PlayCount += al.PlayCount
+	}
+	return dir
+}
+
+func (b *browser) buildAlbumDir(al *model.Album, tracks model.MediaFiles) *DirectoryInfo {
+	dir := &DirectoryInfo{
+		Id:         al.ID,
+		Name:       al.Name,
+		Parent:     al.AlbumArtistID,
+		Artist:     al.AlbumArtist,
+		ArtistId:   al.AlbumArtistID,
+		SongCount:  al.SongCount,
+		Duration:   int(al.Duration),
+		Created:    al.CreatedAt,
+		Year:       al.MaxYear,
+		Genre:      al.Genre,
+		CoverArt:   al.CoverArtId,
+		PlayCount:  al.PlayCount,
+		UserRating: al.Rating,
+	}
+
+	if al.Starred {
+		dir.Starred = al.StarredAt
+	}
+
+	dir.Entries = FromMediaFiles(tracks)
+	return dir
+}
+
+func (b *browser) isArtist(ctx context.Context, id string) bool {
+	found, err := b.ds.Artist(ctx).Exists(id)
+	if err != nil {
+		log.Debug(ctx, "Error searching for Artist", "id", id, err)
+		return false
+	}
+	return found
+}
+
+func (b *browser) isAlbum(ctx context.Context, id string) bool {
+	found, err := b.ds.Album(ctx).Exists(id)
+	if err != nil {
+		log.Debug(ctx, "Error searching for Album", "id", id, err)
+		return false
+	}
+	return found
+}
+
+func (b *browser) retrieveArtist(ctx context.Context, id string) (a *model.Artist, as model.Albums, err error) {
+	a, err = b.ds.Artist(ctx).Get(id)
+	if err != nil {
+		err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err)
+		return
+	}
+
+	if as, err = b.ds.Album(ctx).FindByArtist(id); err != nil {
+		err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err)
+	}
+	return
+}
+
+func (b *browser) retrieveAlbum(ctx context.Context, id string) (al *model.Album, mfs model.MediaFiles, err error) {
+	al, err = b.ds.Album(ctx).Get(id)
+	if err != nil {
+		err = fmt.Errorf("Error reading Album %s from DB: %v", id, err)
+		return
+	}
+
+	if mfs, err = b.ds.MediaFile(ctx).FindByAlbum(id); err != nil {
+		err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err)
+	}
+	return
+}

server/subsonic/engine/browser_test.go

@@ -0,0 +1,52 @@
+package engine
+
+import (
+	"context"
+	"errors"
+
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Browser", func() {
+	var repo *mockGenreRepository
+	var b Browser
+
+	BeforeEach(func() {
+		repo = &mockGenreRepository{data: model.Genres{
+			{Name: "Rock", SongCount: 1000, AlbumCount: 100},
+			{Name: "", SongCount: 13, AlbumCount: 13},
+			{Name: "Electronic", SongCount: 4000, AlbumCount: 40},
+		}}
+		var ds = &persistence.MockDataStore{MockedGenre: repo}
+		b = &browser{ds: ds}
+	})
+
+	It("returns sorted data", func() {
+		Expect(b.GetGenres(context.TODO())).To(Equal(model.Genres{
+			{Name: "<Empty>", SongCount: 13, AlbumCount: 13},
+			{Name: "Electronic", SongCount: 4000, AlbumCount: 40},
+			{Name: "Rock", SongCount: 1000, AlbumCount: 100},
+		}))
+	})
+
+	It("bubbles up errors", func() {
+		repo.err = errors.New("generic error")
+		_, err := b.GetGenres(context.TODO())
+		Expect(err).ToNot(BeNil())
+	})
+})
+
+type mockGenreRepository struct {
+	data model.Genres
+	err  error
+}
+
+func (r *mockGenreRepository) GetAll() (model.Genres, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	return r.data, nil
+}

server/subsonic/engine/common.go

@@ -0,0 +1,152 @@
+package engine
+
+import (
+	"context"
+	"time"
+
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+)
+
+type Entry struct {
+	Id               string
+	Title            string
+	IsDir            bool
+	Parent           string
+	Album            string
+	Year             int
+	Artist           string
+	Genre            string
+	CoverArt         string
+	Starred          time.Time
+	Track            int
+	Duration         int
+	Size             int64
+	Suffix           string
+	BitRate          int
+	ContentType      string
+	Path             string
+	PlayCount        int32
+	DiscNumber       int
+	Created          time.Time
+	AlbumId          string
+	ArtistId         string
+	Type             string
+	UserRating       int
+	SongCount        int
+	UserName         string
+	MinutesAgo       int
+	PlayerId         int
+	PlayerName       string
+	AlbumCount       int
+	BookmarkPosition int64
+}
+
+type Entries []Entry
+
+func FromArtist(ar *model.Artist) Entry {
+	e := Entry{}
+	e.Id = ar.ID
+	e.Title = ar.Name
+	e.AlbumCount = ar.AlbumCount
+	e.IsDir = true
+	if ar.Starred {
+		e.Starred = ar.StarredAt
+	}
+	return e
+}
+
+func FromAlbum(al *model.Album) Entry {
+	e := Entry{}
+	e.Id = al.ID
+	e.Title = al.Name
+	e.IsDir = true
+	e.Parent = al.AlbumArtistID
+	e.Album = al.Name
+	e.Year = al.MaxYear
+	e.Artist = al.AlbumArtist
+	e.Genre = al.Genre
+	e.CoverArt = al.CoverArtId
+	e.Created = al.CreatedAt
+	e.AlbumId = al.ID
+	e.ArtistId = al.AlbumArtistID
+	e.Duration = int(al.Duration)
+	e.SongCount = al.SongCount
+	if al.Starred {
+		e.Starred = al.StarredAt
+	}
+	e.PlayCount = int32(al.PlayCount)
+	e.UserRating = al.Rating
+	return e
+}
+
+func FromMediaFile(mf *model.MediaFile) Entry {
+	e := Entry{}
+	e.Id = mf.ID
+	e.Title = mf.Title
+	e.IsDir = false
+	e.Parent = mf.AlbumID
+	e.Album = mf.Album
+	e.Year = mf.Year
+	e.Artist = mf.Artist
+	e.Genre = mf.Genre
+	e.Track = mf.TrackNumber
+	e.Duration = int(mf.Duration)
+	e.Size = mf.Size
+	e.Suffix = mf.Suffix
+	e.BitRate = mf.BitRate
+	if mf.HasCoverArt {
+		e.CoverArt = mf.ID
+	} else {
+		e.CoverArt = "al-" + mf.AlbumID
+	}
+	e.ContentType = mf.ContentType()
+	e.Path = mf.Path
+	e.DiscNumber = mf.DiscNumber
+	e.Created = mf.CreatedAt
+	e.AlbumId = mf.AlbumID
+	e.ArtistId = mf.ArtistID
+	e.Type = "music"
+	e.PlayCount = int32(mf.PlayCount)
+	if mf.Starred {
+		e.Starred = mf.StarredAt
+	}
+	e.UserRating = mf.Rating
+	e.BookmarkPosition = mf.BookmarkPosition
+	return e
+}
+
+func FromAlbums(albums model.Albums) Entries {
+	entries := make(Entries, len(albums))
+	for i := range albums {
+		al := albums[i]
+		entries[i] = FromAlbum(&al)
+	}
+	return entries
+}
+
+func FromMediaFiles(mfs model.MediaFiles) Entries {
+	entries := make(Entries, len(mfs))
+	for i := range mfs {
+		mf := mfs[i]
+		entries[i] = FromMediaFile(&mf)
+	}
+	return entries
+}
+
+func FromArtists(ars model.Artists) Entries {
+	entries := make(Entries, len(ars))
+	for i := range ars {
+		ar := ars[i]
+		entries[i] = FromArtist(&ar)
+	}
+	return entries
+}
+
+func userName(ctx context.Context) string {
+	if user, ok := request.UserFrom(ctx); !ok {
+		return "UNKNOWN"
+	} else {
+		return user.UserName
+	}
+}

server/subsonic/engine/engine_suite_test.go

@@ -0,0 +1,17 @@
+package engine
+
+import (
+	"testing"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestEngine(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Engine Suite")
+}

server/subsonic/engine/list_generator.go

@@ -0,0 +1,186 @@
+package engine
+
+import (
+	"context"
+	"time"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/deluan/navidrome/model"
+)
+
+type ListGenerator interface {
+	GetAllStarred(ctx context.Context) (artists Entries, albums Entries, mediaFiles Entries, err error)
+	GetNowPlaying(ctx context.Context) (Entries, error)
+	GetSongs(ctx context.Context, offset, size int, filter ListFilter) (Entries, error)
+	GetAlbums(ctx context.Context, offset, size int, filter ListFilter) (Entries, error)
+}
+
+func NewListGenerator(ds model.DataStore, npRepo NowPlayingRepository) ListGenerator {
+	return &listGenerator{ds, npRepo}
+}
+
+type ListFilter model.QueryOptions
+
+func ByNewest() ListFilter {
+	return ListFilter{Sort: "createdAt", Order: "desc"}
+}
+
+func ByRecent() ListFilter {
+	return ListFilter{Sort: "playDate", Order: "desc", Filters: squirrel.Gt{"play_date": time.Time{}}}
+}
+
+func ByFrequent() ListFilter {
+	return ListFilter{Sort: "playCount", Order: "desc", Filters: squirrel.Gt{"play_count": 0}}
+}
+
+func ByRandom() ListFilter {
+	return ListFilter{Sort: "random()"}
+}
+
+func ByName() ListFilter {
+	return ListFilter{Sort: "name"}
+}
+
+func ByArtist() ListFilter {
+	return ListFilter{Sort: "artist"}
+}
+
+func ByStarred() ListFilter {
+	return ListFilter{Sort: "starred_at", Order: "desc", Filters: squirrel.Eq{"starred": true}}
+}
+
+func ByRating() ListFilter {
+	return ListFilter{Sort: "Rating", Order: "desc", Filters: squirrel.Gt{"rating": 0}}
+}
+
+func ByGenre(genre string) ListFilter {
+	return ListFilter{
+		Sort:    "genre asc, name asc",
+		Filters: squirrel.Eq{"genre": genre},
+	}
+}
+
+func ByYear(fromYear, toYear int) ListFilter {
+	return ListFilter{
+		Sort: "max_year, name",
+		Filters: squirrel.Or{
+			squirrel.And{
+				squirrel.GtOrEq{"min_year": fromYear},
+				squirrel.LtOrEq{"min_year": toYear},
+			},
+			squirrel.And{
+				squirrel.GtOrEq{"max_year": fromYear},
+				squirrel.LtOrEq{"max_year": toYear},
+			},
+		},
+	}
+}
+
+func SongsByGenre(genre string) ListFilter {
+	return ListFilter{
+		Sort:    "genre asc, title asc",
+		Filters: squirrel.Eq{"genre": genre},
+	}
+}
+
+func SongsByRandom(genre string, fromYear, toYear int) ListFilter {
+	options := ListFilter{
+		Sort: "random()",
+	}
+	ff := squirrel.And{}
+	if genre != "" {
+		ff = append(ff, squirrel.Eq{"genre": genre})
+	}
+	if fromYear != 0 {
+		ff = append(ff, squirrel.GtOrEq{"year": fromYear})
+	}
+	if toYear != 0 {
+		ff = append(ff, squirrel.LtOrEq{"year": toYear})
+	}
+	options.Filters = ff
+	return options
+}
+
+type listGenerator struct {
+	ds     model.DataStore
+	npRepo NowPlayingRepository
+}
+
+func (g *listGenerator) GetSongs(ctx context.Context, offset, size int, filter ListFilter) (Entries, error) {
+	qo := model.QueryOptions(filter)
+	qo.Offset = offset
+	qo.Max = size
+	mediaFiles, err := g.ds.MediaFile(ctx).GetAll(qo)
+	if err != nil {
+		return nil, err
+	}
+
+	return FromMediaFiles(mediaFiles), nil
+}
+
+func (g *listGenerator) GetAlbums(ctx context.Context, offset, size int, filter ListFilter) (Entries, error) {
+	qo := model.QueryOptions(filter)
+	qo.Offset = offset
+	qo.Max = size
+	albums, err := g.ds.Album(ctx).GetAll(qo)
+	if err != nil {
+		return nil, err
+	}
+
+	return FromAlbums(albums), nil
+}
+
+func (g *listGenerator) GetStarred(ctx context.Context, offset int, size int) (Entries, error) {
+	qo := model.QueryOptions{Offset: offset, Max: size, Sort: "starred_at", Order: "desc"}
+	albums, err := g.ds.Album(ctx).GetStarred(qo)
+	if err != nil {
+		return nil, err
+	}
+
+	return FromAlbums(albums), nil
+}
+
+func (g *listGenerator) GetAllStarred(ctx context.Context) (artists Entries, albums Entries, mediaFiles Entries, err error) {
+	options := model.QueryOptions{Sort: "starred_at", Order: "desc"}
+
+	ars, err := g.ds.Artist(ctx).GetStarred(options)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	als, err := g.ds.Album(ctx).GetStarred(options)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	mfs, err := g.ds.MediaFile(ctx).GetStarred(options)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	artists = FromArtists(ars)
+	albums = FromAlbums(als)
+	mediaFiles = FromMediaFiles(mfs)
+
+	return
+}
+
+func (g *listGenerator) GetNowPlaying(ctx context.Context) (Entries, error) {
+	npInfo, err := g.npRepo.GetAll()
+	if err != nil {
+		return nil, err
+	}
+	entries := make(Entries, len(npInfo))
+	for i, np := range npInfo {
+		mf, err := g.ds.MediaFile(ctx).Get(np.TrackID)
+		if err != nil {
+			return nil, err
+		}
+		entries[i] = FromMediaFile(mf)
+		entries[i].UserName = np.Username
+		entries[i].MinutesAgo = int(time.Since(np.Start).Minutes())
+		entries[i].PlayerId = np.PlayerId
+		entries[i].PlayerName = np.PlayerName
+	}
+	return entries, nil
+}

server/subsonic/engine/mock_transcoding_repo_test.go

@@ -0,0 +1,22 @@
+package engine
+
+import "github.com/deluan/navidrome/model"
+
+type mockTranscodingRepository struct {
+	model.TranscodingRepository
+}
+
+func (m *mockTranscodingRepository) Get(id string) (*model.Transcoding, error) {
+	return &model.Transcoding{ID: id, TargetFormat: "mp3", DefaultBitRate: 160}, nil
+}
+
+func (m *mockTranscodingRepository) FindByFormat(format string) (*model.Transcoding, error) {
+	switch format {
+	case "mp3":
+		return &model.Transcoding{ID: "mp31", TargetFormat: "mp3", DefaultBitRate: 160}, nil
+	case "oga":
+		return &model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 128}, nil
+	default:
+		return nil, model.ErrNotFound
+	}
+}

server/subsonic/engine/nowplaying.go

@@ -0,0 +1,118 @@
+package engine
+
+import (
+	"container/list"
+	"sync"
+	"time"
+)
+
+const NowPlayingExpire = 60 * time.Minute
+
+type NowPlayingInfo struct {
+	TrackID    string
+	Start      time.Time
+	Username   string
+	PlayerId   int
+	PlayerName string
+}
+
+// This repo must have the semantics of a FIFO queue, for each playerId
+type NowPlayingRepository interface {
+	// Insert at the head of the queue
+	Enqueue(*NowPlayingInfo) error
+
+	// Removes and returns the element at the end of the queue
+	Dequeue(playerId int) (*NowPlayingInfo, error)
+
+	// Returns the element at the head of the queue (last inserted one)
+	Head(playerId int) (*NowPlayingInfo, error)
+
+	// Returns the element at the end of the queue (first inserted one)
+	Tail(playerId int) (*NowPlayingInfo, error)
+
+	// Size of the queue for the playerId
+	Count(playerId int) (int64, error)
+
+	// Returns all heads from all playerIds
+	GetAll() ([]*NowPlayingInfo, error)
+}
+
+var playerMap = sync.Map{}
+
+type nowPlayingRepository struct{}
+
+func NewNowPlayingRepository() NowPlayingRepository {
+	r := &nowPlayingRepository{}
+	return r
+}
+
+func (r *nowPlayingRepository) getList(id int) *list.List {
+	l, _ := playerMap.LoadOrStore(id, list.New())
+	return l.(*list.List)
+}
+
+func (r *nowPlayingRepository) Enqueue(info *NowPlayingInfo) error {
+	l := r.getList(info.PlayerId)
+	l.PushFront(info)
+	return nil
+}
+
+func (r *nowPlayingRepository) Dequeue(playerId int) (*NowPlayingInfo, error) {
+	l := r.getList(playerId)
+	e := checkExpired(l, l.Back)
+	if e == nil {
+		return nil, nil
+	}
+	l.Remove(e)
+	return e.Value.(*NowPlayingInfo), nil
+}
+
+func (r *nowPlayingRepository) Head(playerId int) (*NowPlayingInfo, error) {
+	l := r.getList(playerId)
+	e := checkExpired(l, l.Front)
+	if e == nil {
+		return nil, nil
+	}
+	return e.Value.(*NowPlayingInfo), nil
+}
+
+func (r *nowPlayingRepository) Tail(playerId int) (*NowPlayingInfo, error) {
+	l := r.getList(playerId)
+	e := checkExpired(l, l.Back)
+	if e == nil {
+		return nil, nil
+	}
+	return e.Value.(*NowPlayingInfo), nil
+}
+
+func (r *nowPlayingRepository) Count(playerId int) (int64, error) {
+	l := r.getList(playerId)
+	return int64(l.Len()), nil
+}
+
+func (r *nowPlayingRepository) GetAll() ([]*NowPlayingInfo, error) {
+	var all []*NowPlayingInfo
+	playerMap.Range(func(playerId, l interface{}) bool {
+		ll := l.(*list.List)
+		e := checkExpired(ll, ll.Front)
+		if e != nil {
+			all = append(all, e.Value.(*NowPlayingInfo))
+		}
+		return true
+	})
+	return all, nil
+}
+
+func checkExpired(l *list.List, f func() *list.Element) *list.Element {
+	for {
+		e := f()
+		if e == nil {
+			return nil
+		}
+		start := e.Value.(*NowPlayingInfo).Start
+		if time.Since(start) < NowPlayingExpire {
+			return e
+		}
+		l.Remove(e)
+	}
+}

server/subsonic/engine/nowplaying_test.go

@@ -0,0 +1,61 @@
+package engine
+
+import (
+	"sync"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("NowPlayingRepository", func() {
+	var repo NowPlayingRepository
+	var now = time.Now()
+	var past = time.Time{}
+
+	BeforeEach(func() {
+		playerMap = sync.Map{}
+		repo = NewNowPlayingRepository()
+	})
+
+	It("enqueues and dequeues records", func() {
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: now})).To(BeNil())
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB", Start: now})).To(BeNil())
+
+		Expect(repo.Tail(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: now}))
+		Expect(repo.Head(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB", Start: now}))
+
+		Expect(repo.Count(1)).To(Equal(int64(2)))
+
+		Expect(repo.Dequeue(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: now}))
+		Expect(repo.Count(1)).To(Equal(int64(1)))
+	})
+
+	It("handles multiple players", func() {
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: now})).To(BeNil())
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB", Start: now})).To(BeNil())
+
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 2, TrackID: "CCC", Start: now})).To(BeNil())
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 2, TrackID: "DDD", Start: now})).To(BeNil())
+
+		Expect(repo.GetAll()).To(ConsistOf([]*NowPlayingInfo{
+			{PlayerId: 1, TrackID: "BBB", Start: now},
+			{PlayerId: 2, TrackID: "DDD", Start: now},
+		}))
+
+		Expect(repo.Count(2)).To(Equal(int64(2)))
+		Expect(repo.Count(2)).To(Equal(int64(2)))
+
+		Expect(repo.Tail(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: now}))
+		Expect(repo.Head(2)).To(Equal(&NowPlayingInfo{PlayerId: 2, TrackID: "DDD", Start: now}))
+	})
+
+	It("handles expired items", func() {
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA", Start: past})).To(BeNil())
+		Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 2, TrackID: "BBB", Start: now})).To(BeNil())
+
+		Expect(repo.GetAll()).To(ConsistOf([]*NowPlayingInfo{
+			{PlayerId: 2, TrackID: "BBB", Start: now},
+		}))
+	})
+})

server/subsonic/engine/players.go

@@ -0,0 +1,68 @@
+package engine
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+	"github.com/google/uuid"
+)
+
+type Players interface {
+	Get(ctx context.Context, playerId string) (*model.Player, error)
+	Register(ctx context.Context, id, client, typ, ip string) (*model.Player, *model.Transcoding, error)
+}
+
+func NewPlayers(ds model.DataStore) Players {
+	return &players{ds}
+}
+
+type players struct {
+	ds model.DataStore
+}
+
+func (p *players) Register(ctx context.Context, id, client, typ, ip string) (*model.Player, *model.Transcoding, error) {
+	var plr *model.Player
+	var trc *model.Transcoding
+	var err error
+	userName, _ := request.UsernameFrom(ctx)
+	if id != "" {
+		plr, err = p.ds.Player(ctx).Get(id)
+		if err == nil && plr.Client != client {
+			id = ""
+		}
+	}
+	if err != nil || id == "" {
+		plr, err = p.ds.Player(ctx).FindByName(client, userName)
+		if err == nil {
+			log.Debug("Found player by name", "id", plr.ID, "client", client, "username", userName)
+		} else {
+			r, _ := uuid.NewRandom()
+			plr = &model.Player{
+				ID:       r.String(),
+				Name:     fmt.Sprintf("%s (%s)", client, userName),
+				UserName: userName,
+				Client:   client,
+			}
+			log.Info("Registering new player", "id", plr.ID, "client", client, "username", userName)
+		}
+	}
+	plr.LastSeen = time.Now()
+	plr.Type = typ
+	plr.IPAddress = ip
+	err = p.ds.Player(ctx).Put(plr)
+	if err != nil {
+		return nil, nil, err
+	}
+	if plr.TranscodingId != "" {
+		trc, err = p.ds.Transcoding(ctx).Get(plr.TranscodingId)
+	}
+	return plr, trc, err
+}
+
+func (p *players) Get(ctx context.Context, playerId string) (*model.Player, error) {
+	return p.ds.Player(ctx).Get(playerId)
+}

server/subsonic/engine/players_test.go

@@ -0,0 +1,140 @@
+package engine
+
+import (
+	"context"
+	"time"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Players", func() {
+	var players Players
+	var repo *mockPlayerRepository
+	ctx := log.NewContext(context.TODO())
+	ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "johndoe"})
+	ctx = request.WithUsername(ctx, "johndoe")
+	var beforeRegister time.Time
+
+	BeforeEach(func() {
+		repo = &mockPlayerRepository{}
+		ds := &persistence.MockDataStore{MockedPlayer: repo, MockedTranscoding: &mockTranscodingRepository{}}
+		players = NewPlayers(ds)
+		beforeRegister = time.Now()
+	})
+
+	Describe("Register", func() {
+		It("creates a new player when no ID is specified", func() {
+			p, trc, err := players.Register(ctx, "", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(p.Client).To(Equal("client"))
+			Expect(p.UserName).To(Equal("johndoe"))
+			Expect(p.Type).To(Equal("chrome"))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("creates a new player if it cannot find any matching player", func() {
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("creates a new player if client does not match the one in DB", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client1111", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client2222", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.ID).ToNot(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(p.Client).To(Equal("client2222"))
+			Expect(trc).To(BeNil())
+		})
+
+		It("finds players by ID", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("finds player by client and user names when ID is not found", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", UserName: "johndoe", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, _, err := players.Register(ctx, "999", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+		})
+
+		It("finds player by client and user names when not ID is provided", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", UserName: "johndoe", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, _, err := players.Register(ctx, "", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+		})
+
+		It("finds player by ID and return its transcoding", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", LastSeen: time.Time{}, TranscodingId: "1"}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc.ID).To(Equal("1"))
+		})
+	})
+})
+
+type mockPlayerRepository struct {
+	model.PlayerRepository
+	lastSaved *model.Player
+	data      map[string]model.Player
+}
+
+func (m *mockPlayerRepository) add(p *model.Player) {
+	if m.data == nil {
+		m.data = make(map[string]model.Player)
+	}
+	m.data[p.ID] = *p
+}
+
+func (m *mockPlayerRepository) Get(id string) (*model.Player, error) {
+	if p, ok := m.data[id]; ok {
+		return &p, nil
+	}
+	return nil, model.ErrNotFound
+}
+
+func (m *mockPlayerRepository) FindByName(client, userName string) (*model.Player, error) {
+	for _, p := range m.data {
+		if p.Client == client && p.UserName == userName {
+			return &p, nil
+		}
+	}
+	return nil, model.ErrNotFound
+}
+
+func (m *mockPlayerRepository) Put(p *model.Player) error {
+	m.lastSaved = p
+	return nil
+}

server/subsonic/engine/playlists.go

@@ -0,0 +1,151 @@
+package engine
+
+import (
+	"context"
+	"time"
+
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+	"github.com/deluan/navidrome/utils"
+)
+
+type Playlists interface {
+	GetAll(ctx context.Context) (model.Playlists, error)
+	Get(ctx context.Context, id string) (*PlaylistInfo, error)
+	Create(ctx context.Context, playlistId, name string, ids []string) error
+	Delete(ctx context.Context, playlistId string) error
+	Update(ctx context.Context, playlistId string, name *string, idsToAdd []string, idxToRemove []int) error
+}
+
+func NewPlaylists(ds model.DataStore) Playlists {
+	return &playlists{ds}
+}
+
+type playlists struct {
+	ds model.DataStore
+}
+
+func (p *playlists) Create(ctx context.Context, playlistId, name string, ids []string) error {
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		owner := p.getUser(ctx)
+		var pls *model.Playlist
+		var err error
+
+		// If playlistID is present, override tracks
+		if playlistId != "" {
+			pls, err = tx.Playlist(ctx).Get(playlistId)
+			if err != nil {
+				return err
+			}
+			if owner != pls.Owner {
+				return model.ErrNotAuthorized
+			}
+			pls.Tracks = nil
+		} else {
+			pls = &model.Playlist{
+				Name:  name,
+				Owner: owner,
+			}
+		}
+		for _, id := range ids {
+			pls.Tracks = append(pls.Tracks, model.MediaFile{ID: id})
+		}
+
+		return tx.Playlist(ctx).Put(pls)
+	})
+}
+
+func (p *playlists) getUser(ctx context.Context) string {
+	user, ok := request.UserFrom(ctx)
+	if ok {
+		return user.UserName
+	}
+	return ""
+}
+
+func (p *playlists) Delete(ctx context.Context, playlistId string) error {
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		pls, err := tx.Playlist(ctx).Get(playlistId)
+		if err != nil {
+			return err
+		}
+
+		owner := p.getUser(ctx)
+		if owner != pls.Owner {
+			return model.ErrNotAuthorized
+		}
+		return tx.Playlist(ctx).Delete(playlistId)
+	})
+}
+
+func (p *playlists) Update(ctx context.Context, playlistId string, name *string, idsToAdd []string, idxToRemove []int) error {
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		pls, err := tx.Playlist(ctx).Get(playlistId)
+		if err != nil {
+			return err
+		}
+
+		owner := p.getUser(ctx)
+		if owner != pls.Owner {
+			return model.ErrNotAuthorized
+		}
+
+		if name != nil {
+			pls.Name = *name
+		}
+		newTracks := model.MediaFiles{}
+		for i, t := range pls.Tracks {
+			if utils.IntInSlice(i, idxToRemove) {
+				continue
+			}
+			newTracks = append(newTracks, t)
+		}
+
+		for _, id := range idsToAdd {
+			newTracks = append(newTracks, model.MediaFile{ID: id})
+		}
+		pls.Tracks = newTracks
+
+		return tx.Playlist(ctx).Put(pls)
+	})
+}
+
+func (p *playlists) GetAll(ctx context.Context) (model.Playlists, error) {
+	return p.ds.Playlist(ctx).GetAll()
+}
+
+type PlaylistInfo struct {
+	Id        string
+	Name      string
+	Entries   Entries
+	SongCount int
+	Duration  int
+	Public    bool
+	Owner     string
+	Comment   string
+	Created   time.Time
+	Changed   time.Time
+}
+
+func (p *playlists) Get(ctx context.Context, id string) (*PlaylistInfo, error) {
+	pl, err := p.ds.Playlist(ctx).Get(id)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO Use model.Playlist when got rid of Entries
+	plsInfo := &PlaylistInfo{
+		Id:        pl.ID,
+		Name:      pl.Name,
+		SongCount: pl.SongCount,
+		Duration:  int(pl.Duration),
+		Public:    pl.Public,
+		Owner:     pl.Owner,
+		Comment:   pl.Comment,
+		Changed:   pl.UpdatedAt,
+		Created:   pl.CreatedAt,
+	}
+
+	plsInfo.Entries = FromMediaFiles(pl.Tracks)
+	return plsInfo, nil
+}

server/subsonic/engine/scrobbler.go

@@ -0,0 +1,70 @@
+package engine
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+)
+
+type Scrobbler interface {
+	Register(ctx context.Context, playerId int, trackId string, playDate time.Time) (*model.MediaFile, error)
+	NowPlaying(ctx context.Context, playerId int, playerName, trackId, username string) (*model.MediaFile, error)
+}
+
+func NewScrobbler(ds model.DataStore, npr NowPlayingRepository) Scrobbler {
+	return &scrobbler{ds: ds, npRepo: npr}
+}
+
+type scrobbler struct {
+	ds     model.DataStore
+	npRepo NowPlayingRepository
+}
+
+func (s *scrobbler) Register(ctx context.Context, playerId int, trackId string, playTime time.Time) (*model.MediaFile, error) {
+	var mf *model.MediaFile
+	var err error
+	err = s.ds.WithTx(func(tx model.DataStore) error {
+		mf, err = s.ds.MediaFile(ctx).Get(trackId)
+		if err != nil {
+			return err
+		}
+		err = s.ds.MediaFile(ctx).IncPlayCount(trackId, playTime)
+		if err != nil {
+			return err
+		}
+		err = s.ds.Album(ctx).IncPlayCount(mf.AlbumID, playTime)
+		if err != nil {
+			return err
+		}
+		err = s.ds.Artist(ctx).IncPlayCount(mf.ArtistID, playTime)
+		return err
+	})
+
+	if err != nil {
+		log.Error("Error while scrobbling", "trackId", trackId, err)
+	} else {
+		log.Info("Scrobbled", "title", mf.Title, "artist", mf.Artist, "user", userName(ctx))
+	}
+
+	return mf, err
+}
+
+// TODO Validate if NowPlaying still works after all refactorings
+func (s *scrobbler) NowPlaying(ctx context.Context, playerId int, playerName, trackId, username string) (*model.MediaFile, error) {
+	mf, err := s.ds.MediaFile(ctx).Get(trackId)
+	if err != nil {
+		return nil, err
+	}
+
+	if mf == nil {
+		return nil, fmt.Errorf(`ID "%s" not found`, trackId)
+	}
+
+	log.Info("Now Playing", "title", mf.Title, "artist", mf.Artist, "user", userName(ctx))
+
+	info := &NowPlayingInfo{TrackID: trackId, Username: username, Start: time.Now(), PlayerId: playerId, PlayerName: playerName}
+	return mf, s.npRepo.Enqueue(info)
+}

server/subsonic/engine/search.go

@@ -0,0 +1,68 @@
+package engine
+
+import (
+	"context"
+	"strings"
+
+	"github.com/deluan/navidrome/model"
+	"github.com/kennygrant/sanitize"
+)
+
+type Search interface {
+	SearchArtist(ctx context.Context, q string, offset int, size int) (Entries, error)
+	SearchAlbum(ctx context.Context, q string, offset int, size int) (Entries, error)
+	SearchSong(ctx context.Context, q string, offset int, size int) (Entries, error)
+}
+
+type search struct {
+	ds model.DataStore
+}
+
+func NewSearch(ds model.DataStore) Search {
+	s := &search{ds}
+	return s
+}
+
+func (s *search) SearchArtist(ctx context.Context, q string, offset int, size int) (Entries, error) {
+	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
+	artists, err := s.ds.Artist(ctx).Search(q, offset, size)
+	if len(artists) == 0 || err != nil {
+		return nil, nil
+	}
+
+	artistIds := make([]string, len(artists))
+	for i, al := range artists {
+		artistIds[i] = al.ID
+	}
+	return FromArtists(artists), nil
+}
+
+func (s *search) SearchAlbum(ctx context.Context, q string, offset int, size int) (Entries, error) {
+	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
+	albums, err := s.ds.Album(ctx).Search(q, offset, size)
+	if len(albums) == 0 || err != nil {
+		return nil, nil
+	}
+
+	albumIds := make([]string, len(albums))
+	for i, al := range albums {
+		albumIds[i] = al.ID
+	}
+
+	return FromAlbums(albums), nil
+}
+
+func (s *search) SearchSong(ctx context.Context, q string, offset int, size int) (Entries, error) {
+	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
+	mediaFiles, err := s.ds.MediaFile(ctx).Search(q, offset, size)
+	if len(mediaFiles) == 0 || err != nil {
+		return nil, nil
+	}
+
+	trackIds := make([]string, len(mediaFiles))
+	for i, mf := range mediaFiles {
+		trackIds[i] = mf.ID
+	}
+
+	return FromMediaFiles(mediaFiles), nil
+}

server/subsonic/engine/users.go

@@ -0,0 +1,63 @@
+package engine
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	"github.com/deluan/navidrome/core/auth"
+	"github.com/deluan/navidrome/model"
+)
+
+type Users interface {
+	Authenticate(ctx context.Context, username, password, token, salt, jwt string) (*model.User, error)
+}
+
+func NewUsers(ds model.DataStore) Users {
+	return &users{ds}
+}
+
+type users struct {
+	ds model.DataStore
+}
+
+func (u *users) Authenticate(ctx context.Context, username, pass, token, salt, jwt string) (*model.User, error) {
+	user, err := u.ds.User(ctx).FindByUsername(username)
+	if err == model.ErrNotFound {
+		return nil, model.ErrInvalidAuth
+	}
+	if err != nil {
+		return nil, err
+	}
+	valid := false
+
+	switch {
+	case jwt != "":
+		claims, err := auth.Validate(jwt)
+		valid = err == nil && claims["sub"] == username
+	case pass != "":
+		if strings.HasPrefix(pass, "enc:") {
+			if dec, err := hex.DecodeString(pass[4:]); err == nil {
+				pass = string(dec)
+			}
+		}
+		valid = pass == user.Password
+	case token != "":
+		t := fmt.Sprintf("%x", md5.Sum([]byte(user.Password+salt)))
+		valid = t == token
+	}
+
+	if !valid {
+		return nil, model.ErrInvalidAuth
+	}
+	// TODO: Find a way to update LastAccessAt without causing too much retention in the DB
+	//go func() {
+	//	err := u.ds.User(ctx).UpdateLastAccessAt(user.ID)
+	//	if err != nil {
+	//		log.Error(ctx, "Could not update user's lastAccessAt", "user", user.UserName)
+	//	}
+	//}()
+	return user, nil
+}

server/subsonic/engine/users_test.go

@@ -0,0 +1,83 @@
+package engine
+
+import (
+	"context"
+
+	"github.com/deluan/navidrome/core/auth"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Users", func() {
+	Describe("Authenticate", func() {
+		var users Users
+		BeforeEach(func() {
+			ds := &persistence.MockDataStore{}
+			users = NewUsers(ds)
+		})
+
+		Context("Plaintext password", func() {
+			It("authenticates with plaintext password ", func() {
+				usr, err := users.Authenticate(context.TODO(), "admin", "wordpass", "", "", "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
+			})
+
+			It("fails authentication with wrong password", func() {
+				_, err := users.Authenticate(context.TODO(), "admin", "INVALID", "", "", "")
+				Expect(err).To(MatchError(model.ErrInvalidAuth))
+			})
+		})
+
+		Context("Encoded password", func() {
+			It("authenticates with simple encoded password ", func() {
+				usr, err := users.Authenticate(context.TODO(), "admin", "enc:776f726470617373", "", "", "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
+			})
+		})
+
+		Context("Token based authentication", func() {
+			It("authenticates with token based authentication", func() {
+				usr, err := users.Authenticate(context.TODO(), "admin", "", "23b342970e25c7928831c3317edd0b67", "retnlmjetrymazgkt", "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
+			})
+
+			It("fails if salt is missing", func() {
+				_, err := users.Authenticate(context.TODO(), "admin", "", "23b342970e25c7928831c3317edd0b67", "", "")
+				Expect(err).To(MatchError(model.ErrInvalidAuth))
+			})
+		})
+
+		Context("JWT based authentication", func() {
+			var validToken string
+			BeforeEach(func() {
+				u := &model.User{UserName: "admin"}
+				var err error
+				validToken, err = auth.CreateToken(u)
+				if err != nil {
+					panic(err)
+				}
+			})
+			It("authenticates with JWT token based authentication", func() {
+				usr, err := users.Authenticate(context.TODO(), "admin", "", "", "", validToken)
+
+				Expect(err).NotTo(HaveOccurred())
+				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
+			})
+
+			It("fails if JWT token is invalid", func() {
+				_, err := users.Authenticate(context.TODO(), "admin", "", "", "", "invalid.token")
+				Expect(err).To(MatchError(model.ErrInvalidAuth))
+			})
+
+			It("fails if JWT token sub is different than username", func() {
+				_, err := users.Authenticate(context.TODO(), "not_admin", "", "", "", validToken)
+				Expect(err).To(MatchError(model.ErrInvalidAuth))
+			})
+		})
+	})
+})

server/subsonic/engine/wire_providers.go

@@ -0,0 +1,16 @@
+package engine
+
+import (
+	"github.com/google/wire"
+)
+
+var Set = wire.NewSet(
+	NewBrowser,
+	NewListGenerator,
+	NewPlaylists,
+	NewScrobbler,
+	NewSearch,
+	NewNowPlayingRepository,
+	NewUsers,
+	NewPlayers,
+)