284 lines
8.4 KiB
Go
284 lines
8.4 KiB
Go
package foryou
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ponzischeme89/memby/server/internal/recommend"
|
|
"github.com/ponzischeme89/memby/server/internal/store"
|
|
"github.com/ponzischeme89/memby/server/internal/tracearr"
|
|
)
|
|
|
|
func TestRankPreparedForTimeMovesTypicalPosterAheadWithinRelevantPool(t *testing.T) {
|
|
location := time.UTC
|
|
contextProfile := recommend.NewContextAffinityProfile()
|
|
comedyHistory := recommend.Item{Genres: []string{"Comedy"}}
|
|
for i := 0; i < 5; i++ {
|
|
contextProfile.Add(
|
|
comedyHistory,
|
|
time.Date(2026, 6, 29+i*7, 20, 0, 0, 0, location),
|
|
1,
|
|
i,
|
|
location,
|
|
)
|
|
}
|
|
rawContext, err := json.Marshal(contextProfile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items := []store.PreparedForYouItem{
|
|
{
|
|
ItemID: "drama", BaseRank: 1, BaseScore: 5,
|
|
Payload: json.RawMessage(`{"Id":"drama","Genres":["Drama"]}`),
|
|
ContextAffinity: rawContext,
|
|
},
|
|
{
|
|
ItemID: "comedy", BaseRank: 2, BaseScore: 4.8,
|
|
Payload: json.RawMessage(`{"Id":"comedy","Genres":["Comedy"]}`),
|
|
RecommendationReason: "Matches your viewing",
|
|
ContextAffinity: rawContext,
|
|
},
|
|
}
|
|
|
|
ranked := rankPreparedForTime(
|
|
items,
|
|
time.Date(2026, 7, 27, 20, 0, 0, 0, location),
|
|
location,
|
|
)
|
|
if ranked[0].ItemID != "comedy" {
|
|
t.Fatalf("first contextual poster = %q, want comedy", ranked[0].ItemID)
|
|
}
|
|
if ranked[0].RecommendationReason !=
|
|
"Matches your viewing · fits what you watch around this time" {
|
|
t.Fatalf("context reason = %q", ranked[0].RecommendationReason)
|
|
}
|
|
}
|
|
|
|
func TestImportedSessionUsesStableKeyAndRecommendationFingerprint(t *testing.T) {
|
|
session := tracearr.Session{
|
|
ID: "session-1", MediaType: "movie", MediaTitle: "Arrival",
|
|
ProgressMs: 500, TotalDurationMs: 1000,
|
|
}
|
|
session.User.ID = "user-1"
|
|
session.User.Username = "Matt"
|
|
|
|
first, ok := importedSession(session, "configured-server")
|
|
if !ok {
|
|
t.Fatal("session was rejected")
|
|
}
|
|
if first.ServerID != "configured-server" || first.SessionID != "session-1" {
|
|
t.Fatalf("key = %q/%q", first.ServerID, first.SessionID)
|
|
}
|
|
second, _ := importedSession(session, "configured-server")
|
|
if !bytes.Equal(first.SourceFingerprint, second.SourceFingerprint) {
|
|
t.Fatal("unchanged session did not produce a stable fingerprint")
|
|
}
|
|
session.ProgressMs = 750
|
|
updated, _ := importedSession(session, "configured-server")
|
|
if bytes.Equal(first.SourceFingerprint, updated.SourceFingerprint) {
|
|
t.Fatal("updated progress was not detected by the fingerprint")
|
|
}
|
|
}
|
|
|
|
func TestTracearrSessionTerminalRequiresCompletedState(t *testing.T) {
|
|
active := store.TracearrSession{State: "playing"}
|
|
if tracearrSessionTerminal(active) {
|
|
t.Fatal("active session was terminal")
|
|
}
|
|
stopped := active
|
|
stopped.State = "stopped"
|
|
if !tracearrSessionTerminal(stopped) {
|
|
t.Fatal("stopped session was not terminal")
|
|
}
|
|
watched := active
|
|
watched.Watched = true
|
|
if !tracearrSessionTerminal(watched) {
|
|
t.Fatal("watched session was not terminal")
|
|
}
|
|
}
|
|
|
|
func TestImportDueMeasuresElapsedTimeRatherThanProcessUptime(t *testing.T) {
|
|
now := time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC)
|
|
at := func(d time.Duration) *time.Time {
|
|
value := now.Add(-d)
|
|
return &value
|
|
}
|
|
const incremental = 5 * time.Minute
|
|
const full = 24 * time.Hour
|
|
|
|
for _, testCase := range []struct {
|
|
name string
|
|
state store.TracearrImportState
|
|
wantFull bool
|
|
wantDue bool
|
|
wantSkip bool
|
|
}{
|
|
{
|
|
name: "never imported runs a full pass",
|
|
state: store.TracearrImportState{}, wantFull: true, wantDue: true,
|
|
},
|
|
{
|
|
// The restart case: without persisted stamps every boot re-imported.
|
|
name: "recent import is not repeated after a restart",
|
|
state: store.TracearrImportState{
|
|
LastIncrementalAt: at(30 * time.Second), LastFullAt: at(2 * time.Hour),
|
|
},
|
|
wantSkip: true,
|
|
},
|
|
{
|
|
name: "elapsed incremental interval is due",
|
|
state: store.TracearrImportState{
|
|
LastIncrementalAt: at(6 * time.Minute), LastFullAt: at(2 * time.Hour),
|
|
},
|
|
wantDue: true,
|
|
},
|
|
{
|
|
// A gateway restarted daily never reconciled: the full ticker restarted too.
|
|
name: "elapsed full interval wins over the incremental one",
|
|
state: store.TracearrImportState{
|
|
LastIncrementalAt: at(6 * time.Minute), LastFullAt: at(25 * time.Hour),
|
|
},
|
|
wantFull: true, wantDue: true,
|
|
},
|
|
{
|
|
name: "a stamp in the future does not strand the importer",
|
|
state: store.TracearrImportState{
|
|
LastIncrementalAt: at(-time.Hour), LastFullAt: at(-time.Hour),
|
|
},
|
|
wantFull: true, wantDue: true,
|
|
},
|
|
} {
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
gotFull, gotDue := importDue(testCase.state, now, incremental, full)
|
|
if testCase.wantSkip {
|
|
if gotDue {
|
|
t.Fatal("import ran when none was owed")
|
|
}
|
|
return
|
|
}
|
|
if gotDue != testCase.wantDue || gotFull != testCase.wantFull {
|
|
t.Fatalf("full=%v due=%v, want full=%v due=%v",
|
|
gotFull, gotDue, testCase.wantFull, testCase.wantDue)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestImportDueRespectsDisabledIntervals(t *testing.T) {
|
|
now := time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC)
|
|
if _, due := importDue(store.TracearrImportState{}, now, 0, 0); due {
|
|
t.Fatal("import was due with scheduling turned off")
|
|
}
|
|
stale := now.Add(-48 * time.Hour)
|
|
state := store.TracearrImportState{LastIncrementalAt: &stale, LastFullAt: &stale}
|
|
full, due := importDue(state, now, 5*time.Minute, 0)
|
|
if !due || full {
|
|
t.Fatalf("full=%v due=%v, want an incremental pass with full reconciliation off",
|
|
full, due)
|
|
}
|
|
}
|
|
func TestStoredResultCapsCandidatePoolAndPersistsAlgorithmVersion(t *testing.T) {
|
|
result := recommend.PreparedResult{
|
|
Candidates: make([]recommend.PreparedCandidate, maxPreparedCandidates+50),
|
|
}
|
|
for i := range result.Candidates {
|
|
result.Candidates[i].ItemID = itoaForTest(i + 1)
|
|
}
|
|
profile, candidates, err := storedResult("user", time.Now(), result)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(candidates) != maxPreparedCandidates {
|
|
t.Fatalf("candidate count = %d, want %d", len(candidates), maxPreparedCandidates)
|
|
}
|
|
if profile.AlgorithmVersion != preparedAlgorithmVersion {
|
|
t.Fatalf("algorithm version = %q", profile.AlgorithmVersion)
|
|
}
|
|
}
|
|
|
|
func TestBuildPreparedRowsUsesMultipleSourcesAndDeduplicatesTitles(t *testing.T) {
|
|
items := make([]store.PreparedForYouItem, 0, 120)
|
|
for i := 0; i < 120; i++ {
|
|
sourceID, sourceTitle := "six-feet-under", "Six Feet Under"
|
|
genre := "Drama"
|
|
if i%2 == 1 {
|
|
sourceID, sourceTitle = "arrival", "Arrival"
|
|
genre = "Science Fiction"
|
|
}
|
|
id := "item-" + itoaForTest(i)
|
|
items = append(items, store.PreparedForYouItem{
|
|
ItemID: id, BaseRank: i + 1,
|
|
Payload: json.RawMessage(`{"Id":"` + id + `"}`),
|
|
CompatibilityScore: 0.8,
|
|
CompatibilityLabel: "Direct plays well on this TV",
|
|
RecommendationReason: "Because you finished " + sourceTitle,
|
|
ReasonGenre: genre, ReasonSourceItemID: sourceID,
|
|
ReasonSourceTitle: sourceTitle,
|
|
})
|
|
}
|
|
|
|
rows := buildPreparedRows(items, 0, 4)
|
|
if len(rows) < 4 {
|
|
t.Fatalf("expected several prepared rows, got %d", len(rows))
|
|
}
|
|
titles := map[string]bool{}
|
|
itemIDs := map[string]bool{}
|
|
for _, row := range rows {
|
|
titles[row.Title] = true
|
|
for _, raw := range row.Items {
|
|
var item struct {
|
|
ID string `json:"Id"`
|
|
}
|
|
if err := json.Unmarshal(raw, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if itemIDs[item.ID] {
|
|
t.Fatalf("item %q appeared in more than one row", item.ID)
|
|
}
|
|
itemIDs[item.ID] = true
|
|
}
|
|
}
|
|
if !titles["Because you finished Six Feet Under"] ||
|
|
!titles["Because you finished Arrival"] {
|
|
t.Fatalf("completed-title rows = %+v", titles)
|
|
}
|
|
}
|
|
|
|
func TestBuildPreparedRowsKeepsASingleGenuinePickup(t *testing.T) {
|
|
rows := buildPreparedRows([]store.PreparedForYouItem{
|
|
{
|
|
ItemID: "show-1", BaseRank: 1,
|
|
Payload: json.RawMessage(`{"Id":"show-1"}`),
|
|
ReasonKind: "pick-up",
|
|
RecommendationReason: "You left this in season 1 · pick it up again",
|
|
},
|
|
{
|
|
ItemID: "show-2", BaseRank: 2,
|
|
Payload: json.RawMessage(`{"Id":"show-2"}`),
|
|
ReasonKind: "pick-up",
|
|
RecommendationReason: "You made it through season 2 · season 3 is waiting",
|
|
},
|
|
}, 0, 4)
|
|
|
|
if len(rows) != 1 || rows[0].ID != "for-you:pick-up" ||
|
|
rows[0].Title != "Pick this show up again" || len(rows[0].Items) != 1 {
|
|
t.Fatalf("pickup rows = %+v", rows)
|
|
}
|
|
}
|
|
|
|
func itoaForTest(value int) string {
|
|
if value == 0 {
|
|
return "0"
|
|
}
|
|
var digits [20]byte
|
|
position := len(digits)
|
|
for value > 0 {
|
|
position--
|
|
digits[position] = byte('0' + value%10)
|
|
value /= 10
|
|
}
|
|
return string(digits[position:])
|
|
}
|