363 lines
11 KiB
Go
363 lines
11 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ponzischeme89/memby/server/internal/emby"
|
|
"github.com/ponzischeme89/memby/server/internal/recommend"
|
|
"github.com/ponzischeme89/memby/server/internal/store"
|
|
)
|
|
|
|
func TestBearerTokenSources(t *testing.T) {
|
|
t.Run("authorization header", func(t *testing.T) {
|
|
r := httptest.NewRequest(http.MethodGet, "/v1/home", nil)
|
|
r.Header.Set("Authorization", "Bearer abc123")
|
|
if got := bearerToken(r); got != "abc123" {
|
|
t.Fatalf("got %q, want abc123", got)
|
|
}
|
|
})
|
|
|
|
t.Run("query parameter for image urls", func(t *testing.T) {
|
|
r := httptest.NewRequest(http.MethodGet, "/v1/images/1/backdrop?t=abc123", nil)
|
|
if got := bearerToken(r); got != "abc123" {
|
|
t.Fatalf("got %q, want abc123", got)
|
|
}
|
|
})
|
|
|
|
t.Run("absent", func(t *testing.T) {
|
|
r := httptest.NewRequest(http.MethodGet, "/v1/home", nil)
|
|
if got := bearerToken(r); got != "" {
|
|
t.Fatalf("got %q, want empty", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestHashTokenIsStable(t *testing.T) {
|
|
a, b := hashToken("token"), hashToken("token")
|
|
if string(a) != string(b) {
|
|
t.Fatal("hashing the same token produced different digests")
|
|
}
|
|
if string(a) == string(hashToken("other")) {
|
|
t.Fatal("different tokens hashed to the same digest")
|
|
}
|
|
}
|
|
|
|
func TestNewTokenIsUnique(t *testing.T) {
|
|
seen := map[string]bool{}
|
|
for range 100 {
|
|
token, err := newToken()
|
|
if err != nil {
|
|
t.Fatalf("newToken: %v", err)
|
|
}
|
|
if seen[token] {
|
|
t.Fatal("newToken repeated a value")
|
|
}
|
|
seen[token] = true
|
|
}
|
|
}
|
|
|
|
func TestRenameDeviceRejectsBlankName(t *testing.T) {
|
|
s := &Server{}
|
|
req := httptest.NewRequest(http.MethodPut, "/v1/auth/devices/tv-1", strings.NewReader(`{"deviceName":" "}`))
|
|
req.SetPathValue("deviceID", "tv-1")
|
|
rec := httptest.NewRecorder()
|
|
|
|
s.handleRenameDevice(rec, req, store.Session{EmbyUserID: "user-1"})
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400", rec.Code)
|
|
}
|
|
}
|
|
|
|
func TestRecommendationOnboardingCandidatesMixMoviesAndSeries(t *testing.T) {
|
|
items := []recommend.Item{
|
|
{ID: "m1", Name: "Movie 1", Type: "Movie", CommunityRating: 9, Genres: []string{"Drama"}},
|
|
{ID: "m2", Name: "Movie 2", Type: "Movie", CommunityRating: 8.9, Genres: []string{"Comedy"}},
|
|
{ID: "s1", Name: "Series 1", Type: "Series", CommunityRating: 8.8, Genres: []string{"Drama"}},
|
|
{ID: "s2", Name: "Series 2", Type: "Series", CommunityRating: 8.7, Genres: []string{"Comedy"}},
|
|
{ID: "e1", Name: "Episode", Type: "Episode", CommunityRating: 10},
|
|
}
|
|
|
|
got := recommendationOnboardingCandidates(items, 4)
|
|
|
|
if len(got) != 4 {
|
|
t.Fatalf("candidate count = %d, want 4", len(got))
|
|
}
|
|
for i, kind := range []string{"Movie", "Series", "Movie", "Series"} {
|
|
if got[i].Type != kind {
|
|
t.Fatalf("candidate %d type = %q, want %q", i, got[i].Type, kind)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEpisodeCodeFormatsPlaybackMetadata(t *testing.T) {
|
|
item := emby.Summary{Type: "Episode", ParentIndexNumber: 2, IndexNumber: 4}
|
|
if got := episodeCode(item); got != "S02E04" {
|
|
t.Fatalf("episode code = %q, want S02E04", got)
|
|
}
|
|
if got := episodeCode(emby.Summary{Type: "Movie", IndexNumber: 4}); got != "" {
|
|
t.Fatalf("movie episode code = %q, want empty", got)
|
|
}
|
|
}
|
|
|
|
func TestSonarrScheduleRequiresCapableClient(t *testing.T) {
|
|
tests := map[string]bool{
|
|
"": false,
|
|
"0.1.53": false,
|
|
"0.1.54": true,
|
|
"0.2.0": true,
|
|
}
|
|
for version, want := range tests {
|
|
req := httptest.NewRequest(http.MethodGet, "/v1/home", nil)
|
|
req.Header.Set("X-Memby-Version", version)
|
|
if got := supportsSonarrSchedule(req); got != want {
|
|
t.Errorf("supportsSonarrSchedule(%q) = %v, want %v", version, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRadarrScheduleRequiresMovieScheduleClient(t *testing.T) {
|
|
tests := map[string]bool{
|
|
"": false,
|
|
"0.1.78": false,
|
|
"0.1.79": true,
|
|
"0.2.0": true,
|
|
}
|
|
for version, want := range tests {
|
|
req := httptest.NewRequest(http.MethodGet, "/v1/home", nil)
|
|
req.Header.Set("X-Memby-Version", version)
|
|
if got := supportsRadarrSchedule(req); got != want {
|
|
t.Errorf("supportsRadarrSchedule(%q) = %v, want %v", version, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPlaybackHintAvoidsAnUpstreamItemLookup(t *testing.T) {
|
|
req := httptest.NewRequest(
|
|
http.MethodGet,
|
|
"/v1/items/42/playback?type=Movie&title=Arrival&resumePositionMs=12000",
|
|
nil,
|
|
)
|
|
item, ok := playbackHint(req, "42")
|
|
if !ok {
|
|
t.Fatal("valid hint was rejected")
|
|
}
|
|
if item.ID != "42" || item.Type != "Movie" || item.Name != "Arrival" {
|
|
t.Fatalf("unexpected hinted item: %+v", item)
|
|
}
|
|
if item.UserData.PlaybackPositionTicks != 12_000*ticksPerMillisecond {
|
|
t.Fatalf("resume ticks = %d", item.UserData.PlaybackPositionTicks)
|
|
}
|
|
|
|
bad := httptest.NewRequest(http.MethodGet, "/v1/items/42/playback?type=Playlist", nil)
|
|
if _, ok := playbackHint(bad, "42"); ok {
|
|
t.Fatal("unsupported type should fall back to Emby")
|
|
}
|
|
}
|
|
|
|
func TestEpisodeAfterUsesPositionNotListLength(t *testing.T) {
|
|
episode := func(id string) json.RawMessage {
|
|
return json.RawMessage(`{"Id":"` + id + `","Name":"Episode ` + id + `","SeriesName":"Westworld"}`)
|
|
}
|
|
|
|
t.Run("middle of a season", func(t *testing.T) {
|
|
items := []json.RawMessage{episode("1"), episode("2"), episode("3")}
|
|
raw, next, ok := episodeAfter(items, "2")
|
|
if !ok {
|
|
t.Fatal("expected an episode after 2")
|
|
}
|
|
if next.ID != "3" {
|
|
t.Fatalf("next = %q, want 3", next.ID)
|
|
}
|
|
if got := seriesNameOf(raw); got != "Westworld" {
|
|
t.Fatalf("series name = %q, want Westworld", got)
|
|
}
|
|
})
|
|
|
|
// Emby drops the leading entry for the first episode, so a two-item list can mean
|
|
// either "first, second" or "second-to-last, last" depending on where we are.
|
|
t.Run("first episode has no previous", func(t *testing.T) {
|
|
items := []json.RawMessage{episode("1"), episode("2")}
|
|
if _, next, ok := episodeAfter(items, "1"); !ok || next.ID != "2" {
|
|
t.Fatalf("next = %+v, ok = %v, want episode 2", next, ok)
|
|
}
|
|
})
|
|
|
|
t.Run("series finale has nothing after it", func(t *testing.T) {
|
|
items := []json.RawMessage{episode("1"), episode("2")}
|
|
if _, _, ok := episodeAfter(items, "2"); ok {
|
|
t.Fatal("the last episode must not resolve a next one")
|
|
}
|
|
})
|
|
|
|
t.Run("current episode missing from the result", func(t *testing.T) {
|
|
items := []json.RawMessage{episode("7"), episode("8")}
|
|
if _, _, ok := episodeAfter(items, "42"); ok {
|
|
t.Fatal("an unrelated result must not resolve a next episode")
|
|
}
|
|
})
|
|
|
|
t.Run("empty result", func(t *testing.T) {
|
|
if _, _, ok := episodeAfter(nil, "1"); ok {
|
|
t.Fatal("no episodes must not resolve a next one")
|
|
}
|
|
})
|
|
}
|
|
|
|
// Empty rows must serialise as [] so kotlinx.serialization can decode them into the
|
|
// client's non-null List fields.
|
|
func TestHomeResponseEncodesEmptyRowsAsArrays(t *testing.T) {
|
|
var resp homeResponse
|
|
ensureSlices(&resp)
|
|
|
|
body, err := json.Marshal(resp)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
var decoded map[string]any
|
|
if err := json.Unmarshal(body, &decoded); err != nil {
|
|
t.Fatalf("unmarshal: %v", err)
|
|
}
|
|
for _, row := range []string{"continueWatching", "nextUp", "favorites", "latestMovies"} {
|
|
if _, ok := decoded[row].([]any); !ok {
|
|
t.Fatalf("row %q encoded as %T, want array", row, decoded[row])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSearchHistoryResponseEncodesEmptyQueriesAsArray(t *testing.T) {
|
|
resp := searchHistoryResponse{Queries: []string{}}
|
|
body, err := json.Marshal(resp)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
var decoded map[string]any
|
|
if err := json.Unmarshal(body, &decoded); err != nil {
|
|
t.Fatalf("unmarshal: %v", err)
|
|
}
|
|
if _, ok := decoded["queries"].([]any); !ok {
|
|
t.Fatalf("queries encoded as %T, want array", decoded["queries"])
|
|
}
|
|
}
|
|
|
|
// The fixed rows must keep their order, ids and kinds: the client maps kinds onto
|
|
// card shapes and uses ids as Compose keys.
|
|
func TestBaseRowsShape(t *testing.T) {
|
|
rows := baseRows(homeResponse{
|
|
ContinueWatching: []json.RawMessage{json.RawMessage(`{"Id":"1"}`)},
|
|
Favorites: []json.RawMessage{json.RawMessage(`{"Id":"2"}`)},
|
|
})
|
|
|
|
if len(rows) != 4 {
|
|
t.Fatalf("expected 4 base rows, got %d", len(rows))
|
|
}
|
|
wantIDs := []string{"continue", "next-up", "favorites", "latest-movies"}
|
|
wantKinds := []string{"continue", "nextup", "favorites", "latest"}
|
|
for i, row := range rows {
|
|
if row.ID != wantIDs[i] {
|
|
t.Fatalf("row %d id = %q, want %q", i, row.ID, wantIDs[i])
|
|
}
|
|
if row.Kind != wantKinds[i] {
|
|
t.Fatalf("row %d kind = %q, want %q", i, row.Kind, wantKinds[i])
|
|
}
|
|
if row.Title == "" {
|
|
t.Fatalf("row %d has no title", i)
|
|
}
|
|
}
|
|
|
|
// The favourites row carries the items the client used to assemble itself.
|
|
if len(rows[2].Items) != 1 {
|
|
t.Fatalf("favourites row lost its items: %+v", rows[2])
|
|
}
|
|
}
|
|
|
|
func TestHomeForYouWindowAt(t *testing.T) {
|
|
tests := []struct {
|
|
hour int
|
|
id string
|
|
minutes int
|
|
}{
|
|
{hour: 4, id: "late-night", minutes: 60},
|
|
{hour: 5, id: "morning", minutes: 30},
|
|
{hour: 11, id: "morning", minutes: 30},
|
|
{hour: 12, id: "afternoon", minutes: 60},
|
|
{hour: 16, id: "afternoon", minutes: 60},
|
|
{hour: 17, id: "evening", minutes: 120},
|
|
{hour: 22, id: "evening", minutes: 120},
|
|
{hour: 23, id: "late-night", minutes: 60},
|
|
}
|
|
for _, test := range tests {
|
|
got := homeForYouWindowAt(time.Date(2026, time.July, 29, test.hour, 0, 0, 0, time.UTC))
|
|
if got.ID != test.id || got.Minutes != test.minutes {
|
|
t.Errorf("hour %d: got %#v, want id=%q minutes=%d", test.hour, got, test.id, test.minutes)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRecommendationBuildsAreDeduplicatedPerUser(t *testing.T) {
|
|
var builds recommendationBuilds
|
|
|
|
if !builds.begin("user-1") {
|
|
t.Fatal("first build should be allowed to start")
|
|
}
|
|
if builds.begin("user-1") {
|
|
t.Fatal("a second concurrent build for the same user must be skipped")
|
|
}
|
|
if !builds.begin("user-2") {
|
|
t.Fatal("a different user must not be blocked")
|
|
}
|
|
|
|
builds.done("user-1")
|
|
if !builds.begin("user-1") {
|
|
t.Fatal("a build should be allowed again once the previous one finished")
|
|
}
|
|
}
|
|
|
|
func TestSummariseReadsResumePosition(t *testing.T) {
|
|
raw := json.RawMessage(`{"Id":"42","Name":"Arrival","Type":"Movie","UserData":{"PlaybackPositionTicks":36000000000}}`)
|
|
summary, err := emby.Summarise(raw)
|
|
if err != nil {
|
|
t.Fatalf("summarise: %v", err)
|
|
}
|
|
if summary.ID != "42" || summary.Name != "Arrival" {
|
|
t.Fatalf("unexpected summary: %+v", summary)
|
|
}
|
|
if got := summary.UserData.PlaybackPositionTicks / ticksPerMillisecond; got != 3_600_000 {
|
|
t.Fatalf("resume position = %d ms, want 3600000", got)
|
|
}
|
|
}
|
|
|
|
func TestMergeClientIdentityPersistsReportedHeaders(t *testing.T) {
|
|
req := httptest.NewRequest(http.MethodGet, "/v1/status", nil)
|
|
req.Header.Set("X-Memby-Version", "0.1.60")
|
|
req.Header.Set("X-Memby-Protocol", "1")
|
|
sess := store.Session{}
|
|
|
|
if changed := mergeClientIdentity(req, &sess); !changed {
|
|
t.Fatal("reported identity should update the session")
|
|
}
|
|
if sess.ClientVersion != "0.1.60" || sess.ClientProtocol != "1" {
|
|
t.Fatalf("session identity = %q/%q", sess.ClientVersion, sess.ClientProtocol)
|
|
}
|
|
}
|
|
|
|
func TestMergeClientIdentityAttributesHeaderlessAuthenticatedRequest(t *testing.T) {
|
|
req := httptest.NewRequest(http.MethodGet, "/v1/images/42/primary?t=token", nil)
|
|
sess := store.Session{ClientVersion: "0.1.60", ClientProtocol: "1"}
|
|
|
|
if changed := mergeClientIdentity(req, &sess); changed {
|
|
t.Fatal("inheriting identity should not write the session again")
|
|
}
|
|
if got := clientVersion(req); got != "0.1.60" {
|
|
t.Fatalf("inherited client version = %q", got)
|
|
}
|
|
if got := clientProtocol(req); got != "1" {
|
|
t.Fatalf("inherited client protocol = %q", got)
|
|
}
|
|
}
|