Publish current app and server

2026-08-02 22:10:19 +12:00
parent a265636139
commit 1ed180c739
203 changed files with 23933 additions and 2788 deletions
@@ -0,0 +1,278 @@
+package api
+
+import (
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ponzischeme89/memby/server/internal/config"
+)
+
+func importPayload(movieID, fileID int, title string, year int) radarrWebhookPayload {
+	var payload radarrWebhookPayload
+	payload.EventType = "Download"
+	payload.Movie.ID = movieID
+	payload.Movie.Title = title
+	payload.Movie.Year = year
+	payload.MovieFile.ID = fileID
+	return payload
+}
+
+func TestRadarrImportAlertAnnouncesANewFilm(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+
+	alert, ok := radarrImportAlert(importPayload(412, 9001, "Mr. Smith Goes to Washington", 1939), now)
+	if !ok {
+		t.Fatal("expected an import to be announced")
+	}
+	if alert.ID != "radarr:412:file:9001" {
+		t.Errorf("alert id = %q, want it keyed on the imported file", alert.ID)
+	}
+	if alert.Kind != alertKindRadarrImport {
+		t.Errorf("kind = %q, want %q", alert.Kind, alertKindRadarrImport)
+	}
+	if alert.Label == "" {
+		t.Error("want a label: the app cannot know the wording for a kind it predates")
+	}
+	if alert.Title != "Mr. Smith Goes to Washington (1939)" {
+		t.Errorf("title = %q, want the year alongside it", alert.Title)
+	}
+	if !strings.Contains(alert.Message, "available in Emby shortly") {
+		t.Errorf("message = %q, want it to say the film is on its way", alert.Message)
+	}
+	// The image proxy serves Radarr covers under this pair, so the banner has a poster
+	// before Emby has scanned the film in.
+	if alert.ItemID != "radarr:412" || alert.ImageTag != "radarr" {
+		t.Errorf("artwork = %q/%q, want the radarr media cover", alert.ItemID, alert.ImageTag)
+	}
+	if alert.AiredAt != now.Format(time.RFC3339) {
+		t.Errorf("airedAt = %q, want the import time so it sorts with the rest", alert.AiredAt)
+	}
+}
+
+func TestRadarrImportAlertIgnoresEventsThatAreNotANewFilm(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+
+	upgrade := importPayload(412, 9002, "Mr. Smith Goes to Washington", 1939)
+	upgrade.IsUpgrade = true
+
+	grab := importPayload(413, 0, "Some Film", 2024)
+	grab.EventType = "Grab"
+
+	untitled := importPayload(414, 9003, "   ", 2024)
+
+	unknownMovie := importPayload(0, 9004, "No Id", 2024)
+
+	for name, payload := range map[string]radarrWebhookPayload{
+		"quality upgrade of a film already there": upgrade,
+		"grabbed but not imported":                grab,
+		"no title":                                untitled,
+		"no movie id":                             unknownMovie,
+	} {
+		if _, ok := radarrImportAlert(payload, now); ok {
+			t.Errorf("%s: expected no alert", name)
+		}
+	}
+}
+
+func TestRadarrImportAlertAcceptsTheNewerEventName(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	payload := importPayload(415, 9005, "Rear Window", 1954)
+	payload.EventType = "MovieFileImported"
+
+	if _, ok := radarrImportAlert(payload, now); !ok {
+		t.Error("expected the alternate import event name to be announced")
+	}
+}
+
+// A file id is what makes a repeated notification the same news; without one the id
+// falls back to the clock so a re-import is not silently swallowed.
+func TestRadarrImportAlertWithoutAFileIDIsStillAnnounced(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	alert, ok := radarrImportAlert(importPayload(416, 0, "Sabotage", 1936), now)
+	if !ok {
+		t.Fatal("expected an alert")
+	}
+	if !strings.HasPrefix(alert.ID, "radarr:416:imported:") {
+		t.Errorf("alert id = %q, want a time-keyed fallback", alert.ID)
+	}
+}
+
+func TestAppendAlertPrunesExpiredAndDeduplicates(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	existing := []storedAlert{
+		{
+			Alert:     clientAlert{ID: "radarr:1:file:1", AiredAt: now.Add(-4 * time.Hour).Format(time.RFC3339)},
+			ExpiresAt: now.Add(-time.Minute),
+		},
+		{
+			Alert:     clientAlert{ID: "radarr:2:file:2", AiredAt: now.Add(-time.Hour).Format(time.RFC3339)},
+			ExpiresAt: now.Add(2 * time.Hour),
+		},
+		{
+			Alert:     clientAlert{ID: "radarr:3:file:3", AiredAt: now.Add(-2 * time.Hour).Format(time.RFC3339)},
+			ExpiresAt: now.Add(time.Hour),
+		},
+	}
+	// Radarr delivering the same import twice must not stack two banners.
+	repeat := clientAlert{ID: "radarr:3:file:3", AiredAt: now.Format(time.RFC3339)}
+
+	stored := appendAlert(existing, repeat, now.Add(3*time.Hour), now)
+
+	if len(stored) != 2 {
+		t.Fatalf("expected 2 stored alerts, got %d: %+v", len(stored), stored)
+	}
+	if stored[0].Alert.ID != "radarr:3:file:3" {
+		t.Errorf("newest first: got %q", stored[0].Alert.ID)
+	}
+	if stored[1].Alert.ID != "radarr:2:file:2" {
+		t.Errorf("expected the unexpired older alert to survive, got %q", stored[1].Alert.ID)
+	}
+}
+
+func TestAppendAlertKeepsOnlyTheNewestFew(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	var stored []storedAlert
+	// A bulk import: many films land at once and every one of them is current.
+	for i := 0; i < maxStoredAlerts+5; i++ {
+		alert := clientAlert{
+			ID:      "radarr:" + time.Duration(i).String(),
+			AiredAt: now.Add(time.Duration(i) * time.Minute).Format(time.RFC3339),
+		}
+		stored = appendAlert(stored, alert, now.Add(3*time.Hour), now)
+	}
+	if len(stored) != maxStoredAlerts {
+		t.Fatalf("stored %d alerts, want a cap of %d", len(stored), maxStoredAlerts)
+	}
+}
+
+func TestLiveAlertsDropsClosedWindows(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	alerts := liveAlerts([]storedAlert{
+		{Alert: clientAlert{ID: "current"}, ExpiresAt: now.Add(time.Minute)},
+		{Alert: clientAlert{ID: "stale"}, ExpiresAt: now.Add(-time.Second)},
+	}, now)
+
+	if len(alerts) != 1 || alerts[0].ID != "current" {
+		t.Fatalf("expected only the current alert, got %+v", alerts)
+	}
+}
+
+func TestMergeAlertsOrdersNewestFirstAcrossSources(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	at := func(d time.Duration) string { return now.Add(d).Format(time.RFC3339) }
+
+	merged := mergeAlerts(
+		[]clientAlert{{ID: "movie-recent", AiredAt: at(-10 * time.Minute)}},
+		[]clientAlert{
+			{ID: "episode-older", AiredAt: at(-2 * time.Hour)},
+			{ID: "episode-newest", AiredAt: at(-time.Minute)},
+		},
+	)
+
+	want := []string{"episode-newest", "movie-recent", "episode-older"}
+	for i, id := range want {
+		if merged[i].ID != id {
+			t.Fatalf("merged[%d] = %q, want %q (%+v)", i, merged[i].ID, id, merged)
+		}
+	}
+}
+
+func TestMergeAlertsCapsWhatOneTVIsShown(t *testing.T) {
+	now := time.Date(2026, 7, 31, 19, 4, 0, 0, time.UTC)
+	var many []clientAlert
+	for i := 0; i < maxAlerts+3; i++ {
+		many = append(many, clientAlert{
+			ID:      "alert-" + time.Duration(i).String(),
+			AiredAt: now.Add(-time.Duration(i) * time.Minute).Format(time.RFC3339),
+		})
+	}
+	if got := len(mergeAlerts(many)); got != maxAlerts {
+		t.Fatalf("merged %d alerts, want a cap of %d", got, maxAlerts)
+	}
+}
+
+func TestWebhookTokenIsReadFromEveryFormRadarrCanSend(t *testing.T) {
+	for name, build := range map[string]func() *http.Request{
+		"header": func() *http.Request {
+			r := newWebhookRequest("/hooks/radarr")
+			r.Header.Set("X-Memby-Token", "secret")
+			return r
+		},
+		"bearer": func() *http.Request {
+			r := newWebhookRequest("/hooks/radarr")
+			r.Header.Set("Authorization", "Bearer secret")
+			return r
+		},
+		"basic auth": func() *http.Request {
+			r := newWebhookRequest("/hooks/radarr")
+			r.SetBasicAuth("memby", "secret")
+			return r
+		},
+		"query": func() *http.Request {
+			return newWebhookRequest("/hooks/radarr?token=secret")
+		},
+	} {
+		if got := webhookToken(build()); got != "secret" {
+			t.Errorf("%s: token = %q, want %q", name, got, "secret")
+		}
+	}
+}
+
+func newWebhookRequest(target string) *http.Request {
+	return httptest.NewRequest(http.MethodPost, target, strings.NewReader("{}"))
+}
+
+func TestRadarrWebhookIsHiddenUntilATokenIsConfigured(t *testing.T) {
+	s := &Server{cfg: config.Config{}, log: discardLogger()}
+	rec := httptest.NewRecorder()
+
+	s.handleRadarrWebhook(rec, newWebhookRequest("/hooks/radarr?token=anything"))
+
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("got %d, want 404 for an unconfigured hook", rec.Code)
+	}
+}
+
+func TestRadarrWebhookRejectsAWrongToken(t *testing.T) {
+	s := &Server{
+		cfg: config.Config{RadarrWebhookToken: "hook-secret", RadarrAlertWindow: time.Hour},
+		log: discardLogger(),
+	}
+	rec := httptest.NewRecorder()
+
+	s.handleRadarrWebhook(rec, newWebhookRequest("/hooks/radarr?token=guess"))
+
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("got %d, want 401", rec.Code)
+	}
+}
+
+// Radarr's Test button has to succeed without putting a film that does not exist on
+// every television in the house.
+func TestRadarrWebhookTestEventAnnouncesNothing(t *testing.T) {
+	s := &Server{
+		cfg: config.Config{RadarrWebhookToken: "hook-secret", RadarrAlertWindow: time.Hour},
+		log: discardLogger(),
+	}
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(
+		http.MethodPost, "/hooks/radarr?token=hook-secret",
+		strings.NewReader(`{"eventType":"Test","movie":{"id":1,"title":"Test Title"}}`),
+	)
+
+	// A nil cache would panic if this reached the store, which is the assertion.
+	s.handleRadarrWebhook(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("got %d, want 200", rec.Code)
+	}
+}
+
+func discardLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(io.Discard, nil))
+}