Metadaten ohne Einrichtung — mit Lese-Token statt API-Schlüssel

Halo bringt einen TMDB-Zugang mit. Wer den Server startet, bekommt Titel,
Beschreibungen und Plakate, ohne irgendwo ein Konto anzulegen. Am echten
Dienst nachgewiesen: „Der Untergang" (2004) mit deutscher Beschreibung,
„Blade Runner 2049" (2017), Plakate als JPEG aus Halos eigener Ablage.

**Warum überhaupt die Frage stand.** Jellyfin liefert ebenfalls einen
Schlüssel mit — fest im Quellcode, offen im Repository, Konstante `ApiKey` in
`TmdbUtils.cs`. Ein Abkommen mit TMDB dazu liess sich nicht belegen: deren
Bedingungen erwähnen das Teilen von Schlüsseln mit keinem Wort, und die
einzige Äusserung eines Moderators zu genau dieser Frage im TMDB-Forum ging
nicht darauf ein, sondern wies nur darauf hin, dass Missbrauch zur Sperrung
führt. Geduldet also, nicht gesegnet.

Deshalb **mit Ausweg**: wer einen eigenen Zugang hinterlegt, benutzt den. Würde
der mitgelieferte je gesperrt, steht damit nicht jede Installation still.

**Ein Lese-Token, kein API-Schlüssel.** TMDBs eigene Dokumentation bestätigt,
dass er auch an den v3-Endpunkten gilt. Zwei Gründe, und beide zählen bei
einem Zugang, der öffentlich im Repo steht: er kann nur lesen, und er geht als
`Authorization`-Kopfzeile hinaus statt als `?api_key=` in der Adresse — und
eine Adresse steht in jedem Zugriffsprotokoll und jedem Reverse Proxy. Der
ältere Schlüssel wird weiterhin angenommen; er kann nur in die Adresse.

**Der Hinweis auf TMDB ist Bedingung.** Logo und ein fester Satz, so verlangt
es deren Lizenz. `system/info` liefert beides ohne Anmeldung, damit ein Client
es auch auf dem Anmeldebildschirm zeigen kann. Das fehlte bisher.

---

**Zwei Funde, beide nur durch einen echten Lauf sichtbar:**

*„Dark" wurde zu „Dark Shadows" von 1966.* TMDB sortiert nach Beliebtheit, und
ohne Jahresangabe führt das in die Irre. Jetzt sticht ein Treffer mit genau
diesem Namen den beliebteren — danach: „Dark" (2017), deutsche Beschreibung,
Folgentitel „Geheimnisse" und „Lügen". Nur bei Gleichheit, nicht bei
Ähnlichkeit: eine eigene Bewertung wäre TMDBs Rangfolge nachgebaut, mit
weniger Daten.

*Die Tests griffen plötzlich übers Netz zu.* Sobald ein Schlüssel mitgeliefert
wird, fragt jeder Scan wirklich bei TMDB nach — und prompt hiess „Der
Untergang" im Test „Downfall", weil die Voreinstellung Englisch ist. Genau
das, was ein Testwerk nicht tun darf: am WLAN hängen und an fremden Daten.
Der Anbieter ist jetzt für alle Tests abgeschaltet, ausser ein Test schiebt
ausdrücklich einen eigenen nach.

238 Tests grün, keiner davon geht ins Netz.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/tests/Halo.Api.Tests/AbgeschalteterAnbieter.cs

@@ -0,0 +1,24 @@
+using Halo.Core.Metadata;
+
+namespace Halo.Api.Tests;
+
+/// <summary>Ein Anbieter, der nichts weiss und nichts fragt.</summary>
+///
+/// <remarks>
+/// Die Voreinstellung für alle Tests, die sich nicht um Metadaten kümmern.
+/// Ohne ihn liefe bei jedem Scan eine echte Anfrage hinaus — und ein Projekt,
+/// dessen Tests einen fremden Dienst brauchen, hat am Ende keine Tests.
+/// </remarks>
+public sealed class AbgeschalteterAnbieter : IMetadataProvider
+{
+    public Task<bool> IsConfiguredAsync(CancellationToken ct = default) => Task.FromResult(false);
+
+    public Task<MovieMetadata?> FindMovieAsync(string t, int? j, CancellationToken ct = default) =>
+        throw new InvalidOperationException("In diesem Test darf nichts nachgeschlagen werden.");
+
+    public Task<SeriesMetadata?> FindSeriesAsync(string t, int? j, CancellationToken ct = default) =>
+        throw new InvalidOperationException("In diesem Test darf nichts nachgeschlagen werden.");
+
+    public Task<EpisodeMetadata?> FindEpisodeAsync(int s, int st, int f, CancellationToken ct = default) =>
+        throw new InvalidOperationException("In diesem Test darf nichts nachgeschlagen werden.");
+}

server/tests/Halo.Api.Tests/HaloServer.cs

@@ -4,6 +4,7 @@ using Halo.Api.Endpoints;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Halo.Core.Metadata;
 
 namespace Halo.Api.Tests;
 
@@ -43,6 +44,17 @@ public sealed class HaloServer : IDisposable
             // als sämtliche Prüfungen zusammen brauchen. Hier gibt es nichts,
             // worauf zu warten wäre.
             sammlung.Configure<HostOptions>(o => o.ShutdownTimeout = TimeSpan.FromMilliseconds(50));
+
+            // **Keine Anfragen nach draussen, solange ein Test es nicht
+            // ausdrücklich will.** Seit ein Schlüssel mitgeliefert wird, würde
+            // jeder Scan sonst wirklich bei TMDB nachfragen: die Tests hingen
+            // am WLAN, und ihre Erwartungen an fremden Daten. „Der Untergang"
+            // hiess prompt „Downfall", weil die Voreinstellung Englisch ist.
+            //
+            // Vor `dienste`, damit ein Test seinen eigenen Anbieter
+            // nachschieben kann — die spätere Eintragung gewinnt.
+            sammlung.AddScoped<IMetadataProvider, AbgeschalteterAnbieter>();
+
             dienste?.Invoke(sammlung);
         }));
         Client = _fabrik.CreateClient();

server/tests/Halo.Api.Tests/MetadataTests.cs

@@ -272,18 +272,54 @@ public class MetadataSettingsTests
         Assert.That(stand.Language, Is.EqualTo("de-DE"));
     }
 
+    /// <summary>Ohne eigenen Schlüssel greift der mitgelieferte.</summary>
+    ///
+    /// <remarks>
+    /// <c>UsingProjectKey</c> ist der Unterschied, den die Oberfläche zeigen
+    /// muss: „es läuft, aber über das gemeinsame Kontingent" ist etwas anderes
+    /// als „du hast einen eigenen hinterlegt".
+    /// </remarks>
     [Test]
-    public async Task Ohne_Schluessel_sagt_der_Server_das_auch()
+    public async Task Ohne_eigenen_Schluessel_greift_der_mitgelieferte()
     {
         using var server = new HaloServer();
         var admin = await server.SetUpAndSignIn();
         var stand = await server.AlsAngemeldeter(admin.Token)
             .GetFromJsonAsync<MetadataSettingsResponse>("/api/v1/settings/metadata");
 
-        Assert.That(stand!.HasApiKey, Is.False);
+        var mitgeliefert = Halo.Metadata.TmdbSettings.ProjectApiKey.Length > 0;
+        Assert.That(stand!.HasApiKey, Is.EqualTo(mitgeliefert));
+        Assert.That(stand.UsingProjectKey, Is.EqualTo(mitgeliefert));
         Assert.That(stand.Language, Is.EqualTo("en-US"));
     }
 
+    [Test]
+    public async Task Ein_eigener_Schluessel_loest_den_mitgelieferten_ab()
+    {
+        using var server = new HaloServer();
+        var admin = await server.SetUpAndSignIn();
+        var client = server.AlsAngemeldeter(admin.Token);
+
+        await client.PutAsJsonAsync("/api/v1/settings/metadata",
+            new MetadataSettingsRequest("mein-eigener-schluessel", "de-DE"));
+
+        var stand = await client.GetFromJsonAsync<MetadataSettingsResponse>("/api/v1/settings/metadata");
+        Assert.That(stand!.HasApiKey, Is.True);
+        Assert.That(stand.UsingProjectKey, Is.False);
+    }
+
+    /// <summary>TMDB verlangt den Hinweis — und zwar ohne Anmeldung abrufbar.</summary>
+    [Test]
+    public async Task Der_Pflichthinweis_zu_TMDB_steht_in_der_Systemauskunft()
+    {
+        using var server = new HaloServer();
+        var info = await server.Client.GetFromJsonAsync<SystemInfo>("/api/v1/system/info");
+
+        var tmdb = info!.Attributions.Single();
+        Assert.That(tmdb.Text, Does.Contain("TMDB").And.Contain("not endorsed"));
+        Assert.That(tmdb.LogoUrl, Does.StartWith("https://"));
+    }
+
     [TestCase("deutsch")]
     [TestCase("de_DE")]
     [TestCase("DE")]

server/tests/Halo.Metadata.Tests/Attrappe.cs

@@ -15,12 +15,16 @@ public sealed class Attrappe(Func<HttpRequestMessage, HttpResponseMessage> antwo
 {
     public List<string> Aufrufe { get; } = [];
 
+    /// <summary>Die Authorization-Kopfzeile je Aufruf — oder <c>null</c>.</summary>
+    public List<string?> Kopfzeilen { get; } = [];
+
     protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage anfrage, CancellationToken ct)
     {
         // AbsoluteUri und nicht ToString(): Letzteres entschlüsselt zur
         // Anzeige wieder, und dann sähe eine richtig kodierte Anfrage falsch
         // aus — der Test prüfte eine Darstellung statt dessen, was hinausgeht.
         Aufrufe.Add(anfrage.RequestUri!.AbsoluteUri);
+        Kopfzeilen.Add(anfrage.Headers.Authorization?.ToString());
         return Task.FromResult(antwort(anfrage));
     }
 

server/tests/Halo.Metadata.Tests/TmdbClientTests.cs

@@ -161,3 +161,62 @@ public class TmdbClientTests
         Assert.That(film.Poster, Is.Null);
     }
 }
+
+/// <summary>Welcher Treffer gewinnt, wenn mehrere in Frage kommen.</summary>
+public class TrefferwahlTests
+{
+    private static TmdbClient Client(Attrappe attrappe) =>
+        new(new HttpClient(attrappe) { BaseAddress = new Uri(TmdbClient.BaseAddress) },
+            FesteEinstellungen.MitSchluessel(), NullLogger<TmdbClient>.Instance);
+
+    /// <summary>Am echten Dienst gemessen, nicht vermutet.</summary>
+    ///
+    /// <remarks>
+    /// <b>Die Suche nach „Dark" lieferte „Dark Shadows" von 1966.</b> TMDB
+    /// sortiert nach Beliebtheit, und ohne Jahresangabe führt das in die Irre.
+    /// Ein Treffer mit genau diesem Namen ist gemeint, auch wenn er weiter
+    /// unten steht.
+    /// </remarks>
+    [Test]
+    public async Task Ein_genau_passender_Name_sticht_den_beliebteren()
+    {
+        var attrappe = Attrappe.MitJson("""
+            {"results":[
+              {"id":1,"name":"Dark Shadows","first_air_date":"1966-06-27"},
+              {"id":2,"name":"Dark","first_air_date":"2017-12-01"}
+            ]}
+            """);
+
+        var serie = await Client(attrappe).FindSeriesAsync("Dark", null);
+        Assert.That(serie!.ProviderId, Is.EqualTo(2));
+        Assert.That(serie.Year, Is.EqualTo(2017));
+    }
+
+    [Test]
+    public async Task Gross_und_Kleinschreibung_spielt_dabei_keine_Rolle()
+    {
+        var attrappe = Attrappe.MitJson("""
+            {"results":[{"id":1,"title":"Irgendwas"},{"id":2,"title":"DER UNTERGANG"}]}
+            """);
+
+        var film = await Client(attrappe).FindMovieAsync("Der Untergang", null);
+        Assert.That(film!.ProviderId, Is.EqualTo(2));
+    }
+
+    /// <summary>Ohne genaue Entsprechung bleibt es beim beliebtesten.</summary>
+    ///
+    /// <remarks>
+    /// Eine eigene Ähnlichkeitsbewertung zu bauen hiesse, TMDBs Rangfolge
+    /// nachzubauen — mit weniger Daten.
+    /// </remarks>
+    [Test]
+    public async Task Ohne_genaue_Entsprechung_gewinnt_der_erste()
+    {
+        var attrappe = Attrappe.MitJson("""
+            {"results":[{"id":1,"title":"Der Untergang des Hauses Usher"},{"id":2,"title":"Untergang"}]}
+            """);
+
+        var film = await Client(attrappe).FindMovieAsync("Der Untergang", null);
+        Assert.That(film!.ProviderId, Is.EqualTo(1));
+    }
+}

server/tests/Halo.Metadata.Tests/ZugangTests.cs

@@ -0,0 +1,125 @@
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Halo.Metadata.Tests;
+
+/// <summary>Womit sich Halo bei TMDB ausweist.</summary>
+public class ZugangTests
+{
+    private const string LeseToken = "eyJhbGciOiJIUzI1NiJ9.beispiel.unterschrift";
+    private const string AelterSchluessel = "0123456789abcdef0123456789abcdef";
+
+    private static (TmdbClient Client, Attrappe Attrappe) Mit(string zugang)
+    {
+        var attrappe = Attrappe.MitJson("""{"results":[{"id":1,"title":"Egal"}]}""");
+        return (new TmdbClient(
+            new HttpClient(attrappe) { BaseAddress = new Uri(TmdbClient.BaseAddress) },
+            new FesteEinstellungen(new TmdbSettings(zugang, "de-DE")),
+            NullLogger<TmdbClient>.Instance), attrappe);
+    }
+
+    /// <summary>Ein Lese-Token gehört in die Kopfzeile, nicht in die Adresse.</summary>
+    ///
+    /// <remarks>
+    /// <b>Eine Adresse steht in jedem Zugriffsprotokoll.</b> In jedem Reverse
+    /// Proxy, in jeder Fehlermeldung, die eine URL zitiert. Eine Kopfzeile tut
+    /// das nicht — und bei einem Schlüssel, der in einem offenen Projekt
+    /// mitgeliefert wird, zählt jede Stelle, an der er nicht auftaucht.
+    /// </remarks>
+    [Test]
+    public async Task Der_Lese_Token_geht_als_Bearer_und_nicht_in_die_Adresse()
+    {
+        var (client, attrappe) = Mit(LeseToken);
+        await client.FindMovieAsync("Egal", null);
+
+        Assert.That(attrappe.Kopfzeilen.Single(), Is.EqualTo($"Bearer {LeseToken}"));
+        Assert.That(attrappe.Aufrufe.Single(), Does.Not.Contain("api_key"));
+        Assert.That(attrappe.Aufrufe.Single(), Does.Not.Contain(LeseToken));
+    }
+
+    /// <summary>Der ältere Schlüssel kann nur in die Adresse — also tut er das.</summary>
+    [Test]
+    public async Task Der_aeltere_Schluessel_geht_weiterhin_als_Abfrageteil()
+    {
+        var (client, attrappe) = Mit(AelterSchluessel);
+        await client.FindMovieAsync("Egal", null);
+
+        Assert.That(attrappe.Kopfzeilen.Single(), Is.Null);
+        Assert.That(attrappe.Aufrufe.Single(), Does.Contain($"api_key={AelterSchluessel}"));
+    }
+
+    [Test]
+    public async Task Auch_bei_Folgen_wird_der_Bearer_mitgeschickt()
+    {
+        var (client, attrappe) = Mit(LeseToken);
+        await client.FindEpisodeAsync(70523, 1, 1);
+
+        Assert.That(attrappe.Kopfzeilen.Single(), Does.StartWith("Bearer "));
+        Assert.That(attrappe.Aufrufe.Single(), Does.Not.Contain("api_key"));
+    }
+}
+
+/// <summary>Welcher Schlüssel gilt, wenn mehrere in Frage kommen.</summary>
+public class SchluesselwahlTests
+{
+    [Test]
+    public void Ein_eigener_Schluessel_sticht_den_mitgelieferten()
+    {
+        var gewählt = TmdbSettings.Resolve("mein-eigener", "de-DE");
+
+        Assert.That(gewählt.ApiKey, Is.EqualTo("mein-eigener"));
+        Assert.That(gewählt.UsingProjectKey, Is.False);
+    }
+
+    [Test]
+    public void Ohne_eigenen_greift_der_mitgelieferte()
+    {
+        var gewählt = TmdbSettings.Resolve(null, null);
+
+        if (TmdbSettings.ProjectApiKey.Length == 0)
+        {
+            Assert.That(gewählt.ApiKey, Is.Null, "Ohne mitgelieferten Schlüssel bleibt es dabei");
+            Assert.That(gewählt.UsingProjectKey, Is.False);
+            return;
+        }
+
+        Assert.That(gewählt.ApiKey, Is.EqualTo(TmdbSettings.ProjectApiKey));
+        Assert.That(gewählt.UsingProjectKey, Is.True);
+    }
+
+    [TestCase("")]
+    [TestCase("   ")]
+    public void Ein_leerer_eigener_Schluessel_zaehlt_als_keiner(string leer)
+    {
+        Assert.That(TmdbSettings.Resolve(leer, null).UsingProjectKey,
+            Is.EqualTo(TmdbSettings.ProjectApiKey.Length > 0));
+    }
+
+    [Test]
+    public void Leerraum_um_den_Schluessel_wird_abgeschnitten()
+    {
+        Assert.That(TmdbSettings.Resolve("  meiner  ", "  de-DE  ").ApiKey, Is.EqualTo("meiner"));
+        Assert.That(TmdbSettings.Resolve("meiner", "  de-DE  ").Language, Is.EqualTo("de-DE"));
+    }
+
+    [Test]
+    public void Ohne_Sprachangabe_gilt_Englisch()
+    {
+        Assert.That(TmdbSettings.Resolve("meiner", null).Language, Is.EqualTo("en-US"));
+    }
+
+    /// <summary>Der mitgelieferte Schlüssel darf nur lesen dürfen.</summary>
+    ///
+    /// <remarks>
+    /// Er steht öffentlich im Quellcode. Ein Lese-Token kann nichts ändern —
+    /// ein älterer API-Schlüssel schon. Diese Prüfung hält fest, dass hier
+    /// keiner der falschen Art hineingerät.
+    /// </remarks>
+    [Test]
+    public void Der_mitgelieferte_Schluessel_ist_ein_Lese_Token()
+    {
+        if (TmdbSettings.ProjectApiKey.Length == 0) Assert.Pass("Kein Schlüssel mitgeliefert.");
+
+        Assert.That(TmdbSettings.ProjectApiKey, Does.StartWith("eyJ"),
+            "Erwartet wird ein API Read Access Token, kein älterer API-Schlüssel");
+    }
+}