Stufe 2b: Metadaten von TMDB — und ein Testlauf, der 19-mal schneller ist

Titel, Beschreibungen und Bilder kommen jetzt von TMDB. Dazu zwei Fehler, die
erst das Zusammenspiel zeigte.

**Der Anbieter steckt hinter einer Schnittstelle, und das ist kein Vorrat für
einen zweiten.** Es geht darum, dass alles, was darauf aufbaut, *ohne Netz und
ohne Schlüssel* prüfbar bleibt. Ein Projekt, dessen Tests einen fremden Dienst
brauchen, hat am Ende keine Tests: sie scheitern, wenn das WLAN hakt, und
irgendwann schaltet sie jemand ab.

**Ein Fehlschlag bei TMDB ist kein Abbruch.** Kein Netz, Kontingent erschöpft,
ein Anmeldeportal im Hotel-WLAN, das HTML mit Status 200 schickt — in allen
Fällen bleibt der Titel beim Dateinamen und der Scan läuft durch. Die eine
Ausnahme ist ein zurückgewiesener Schlüssel: „nichts gefunden" und „dein
Schlüssel ist falsch" sehen in der Mediathek gleich aus, und ohne diese
Unterscheidung sucht jemand stundenlang. Der Schlüssel steht im Scanbericht.

**Der Schlüssel kommt nie wieder heraus.** Abgefragt wird nur, ob einer da
ist — sonst gäbe die Oberfläche jedem Angemeldeten das TMDB-Kontingent des
Betreibers in die Hand. Geprüft, dass er nicht einmal versehentlich im
Antwortkörper steht.

**Bilder holt die App bei Halo, nicht bei TMDB.** Sonst bräuchte sie Internet
für ein Plakat, das zehn Zentimeter weiter auf der Platte liegt — und TMDB
erführe, wer wann was ansieht. Der Schlüssel ist der Hash der Quelladresse,
also lädt dasselbe Plakat nie zweimal. Dass daraus kein Weg ins Dateisystem
wird, ist eigens geprüft: ohne die Formprüfung wäre
`/api/v1/images/../../config/halo.db` ein Weg, die Datenbank samt aller
Token-Fingerabdrücke herunterzuladen.

---

**Der erste Fehler: nach dem Eintragen der Metadaten legte der nächste Scan
den Film erneut an.** Zugeordnet wurde über den Titel — und den hatte TMDB
gerade von „The Matrix" auf „Matrix" geändert. Beim übernächsten Lauf dasselbe
noch einmal. Das ist die Sorte Fehler, die man erst nach Wochen bemerkt, wenn
jeder Film fünfmal dasteht. Jetzt gibt es `ParsedTitle`: den Titel aus dem
Dateinamen, der sich nie ändert, und nur der entscheidet beim Zuordnen.

**Der zweite Fehler kostete 15 Minuten je Testlauf.** Zwei Tests löschen die
Pfadvariablen, um den Rückfall auf die Voreinstellung zu prüfen — und liessen
sie gelöscht zurück. Jeder danach gestartete Testserver fiel dann auf
`<Projektverzeichnis>/data` zurück, und Dutzende Server teilten sich **eine**
SQLite-Datei, auf die sie der Reihe nach warteten. Dazu wartete jeder Host
beim Herunterfahren die vollen fünf Sekunden.

Gefunden durch Halbieren, nicht durch Raten: einzeln war jede Testklasse
schnell, zusammen nicht. Der Beweis lag am Ende als leeres Verzeichnis
`src/Halo.Api/data` auf der Platte.

**15 Minuten 32 → 49 Sekunden.** 180 Tests grün.

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

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

@@ -0,0 +1,163 @@
+using System.Net;
+using Halo.Core.Metadata;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Halo.Metadata.Tests;
+
+public class TmdbClientTests
+{
+    private static TmdbClient Client(Attrappe attrappe, ITmdbSettingsSource? einstellungen = null) =>
+        new(new HttpClient(attrappe) { BaseAddress = new Uri(TmdbClient.BaseAddress) },
+            einstellungen ?? FesteEinstellungen.MitSchluessel(),
+            NullLogger<TmdbClient>.Instance);
+
+    private const string FilmTreffer = """
+        {"results":[{"id":603,"title":"Matrix","release_date":"1999-03-30",
+          "overview":"Neo zweifelt an der Wirklichkeit.",
+          "poster_path":"/abc.jpg","backdrop_path":"/def.jpg"}]}
+        """;
+
+    [Test]
+    public async Task Ohne_Schluessel_wird_nichts_gefragt()
+    {
+        var attrappe = Attrappe.MitJson(FilmTreffer);
+        var client = Client(attrappe, FesteEinstellungen.Ohne);
+
+        Assert.That(await client.IsConfiguredAsync(), Is.False);
+        Assert.That(await client.FindMovieAsync("Matrix", 1999), Is.Null);
+        Assert.That(attrappe.Aufrufe, Is.Empty, "Ohne Schlüssel darf keine Anfrage hinausgehen");
+    }
+
+    [Test]
+    public async Task Ein_Film_wird_gelesen()
+    {
+        var film = await Client(Attrappe.MitJson(FilmTreffer)).FindMovieAsync("Matrix", 1999);
+
+        Assert.That(film, Is.Not.Null);
+        Assert.That(film!.ProviderId, Is.EqualTo(603));
+        Assert.That(film.Title, Is.EqualTo("Matrix"));
+        Assert.That(film.Year, Is.EqualTo(1999));
+        Assert.That(film.Overview, Does.StartWith("Neo zweifelt"));
+        Assert.That(film.Poster!.Url, Is.EqualTo("https://image.tmdb.org/t/p/w500/abc.jpg"));
+        Assert.That(film.Backdrop!.Url, Is.EqualTo("https://image.tmdb.org/t/p/w1280/def.jpg"));
+    }
+
+    [Test]
+    public async Task Titel_Jahr_und_Sprache_landen_in_der_Anfrage()
+    {
+        var attrappe = Attrappe.MitJson(FilmTreffer);
+        await Client(attrappe, FesteEinstellungen.MitSchluessel("de-DE")).FindMovieAsync("Der Untergang", 2004);
+
+        var aufruf = attrappe.Aufrufe.Single();
+        Assert.That(aufruf, Does.Contain("query=Der%20Untergang"));
+        Assert.That(aufruf, Does.Contain("year=2004"));
+        Assert.That(aufruf, Does.Contain("language=de-DE"));
+    }
+
+    [Test]
+    public async Task Ohne_Jahr_wird_keines_mitgeschickt()
+    {
+        var attrappe = Attrappe.MitJson(FilmTreffer);
+        await Client(attrappe).FindMovieAsync("Matrix", null);
+        Assert.That(attrappe.Aufrufe.Single(), Does.Not.Contain("year="));
+    }
+
+    [Test]
+    public async Task Eine_leere_Trefferliste_ergibt_nichts()
+    {
+        Assert.That(await Client(Attrappe.MitJson("""{"results":[]}""")).FindMovieAsync("Gibtesnicht", null), Is.Null);
+    }
+
+    /// <summary>Ein falscher Schlüssel muss auffallen.</summary>
+    ///
+    /// <remarks>
+    /// <b>„Nichts gefunden" und „dein Schlüssel ist falsch" sehen in der
+    /// Mediathek gleich aus.</b> Ohne diese Unterscheidung sucht jemand
+    /// stundenlang nach dem Grund, warum keine Bilder erscheinen.
+    /// </remarks>
+    [TestCase(HttpStatusCode.Unauthorized)]
+    [TestCase(HttpStatusCode.Forbidden)]
+    public void Ein_zurueckgewiesener_Schluessel_wirft(HttpStatusCode code)
+    {
+        var client = Client(Attrappe.MitStatus(code));
+        var fehler = Assert.ThrowsAsync<MetadataCredentialsException>(() => client.FindMovieAsync("Matrix", null));
+        Assert.That(fehler!.Message, Does.Contain("Schlüssel"));
+    }
+
+    /// <summary>Alles andere ist kein Grund, den Scan abzubrechen.</summary>
+    [TestCase(HttpStatusCode.NotFound)]
+    [TestCase(HttpStatusCode.InternalServerError)]
+    [TestCase(HttpStatusCode.TooManyRequests)]
+    [TestCase(HttpStatusCode.ServiceUnavailable)]
+    public async Task Andere_Fehler_ergeben_still_nichts(HttpStatusCode code)
+    {
+        Assert.That(await Client(Attrappe.MitStatus(code)).FindMovieAsync("Matrix", null), Is.Null);
+    }
+
+    /// <summary>Ein Anmeldeportal im Hotel-WLAN antwortet mit HTML und Status 200.</summary>
+    ///
+    /// <remarks>
+    /// Darauf mit einer Ausnahme zu reagieren hiesse, den ganzen Scan an einem
+    /// fremden Netz scheitern zu lassen.
+    /// </remarks>
+    [Test]
+    public async Task Unsinn_statt_JSON_wirft_nicht()
+    {
+        var attrappe = Attrappe.MitJson("<html><body>Bitte anmelden</body></html>");
+        Assert.That(await Client(attrappe).FindMovieAsync("Matrix", null), Is.Null);
+    }
+
+    [Test]
+    public async Task Kein_Netz_ergibt_nichts_statt_eines_Absturzes()
+    {
+        var attrappe = Attrappe.DieWirft(new HttpRequestException("Name or service not known"));
+        Assert.That(await Client(attrappe).FindMovieAsync("Matrix", null), Is.Null);
+    }
+
+    [Test]
+    public async Task Eine_Serie_wird_gelesen()
+    {
+        var json = """
+            {"results":[{"id":70523,"name":"Dark","first_air_date":"2017-12-01",
+              "overview":"Vier Familien.","poster_path":"/p.jpg","backdrop_path":null}]}
+            """;
+        var serie = await Client(Attrappe.MitJson(json)).FindSeriesAsync("Dark", null);
+
+        Assert.That(serie!.ProviderId, Is.EqualTo(70523));
+        Assert.That(serie.Title, Is.EqualTo("Dark"));
+        Assert.That(serie.Year, Is.EqualTo(2017));
+        Assert.That(serie.Poster!.Url, Does.EndWith("/p.jpg"));
+        Assert.That(serie.Backdrop, Is.Null, "Ein fehlendes Bild ist null, keine kaputte Adresse");
+    }
+
+    [Test]
+    public async Task Eine_Folge_wird_gelesen()
+    {
+        var attrappe = Attrappe.MitJson("""
+            {"name":"Geheimnisse","overview":"Ein Junge verschwindet.","still_path":"/s.jpg"}
+            """);
+        var folge = await Client(attrappe).FindEpisodeAsync(70523, 1, 1);
+
+        Assert.That(folge!.Title, Is.EqualTo("Geheimnisse"));
+        Assert.That(folge.Still!.Url, Is.EqualTo("https://image.tmdb.org/t/p/w300/s.jpg"));
+        Assert.That(attrappe.Aufrufe.Single(), Does.Contain("tv/70523/season/1/episode/1"));
+    }
+
+    /// <summary>Eine Folge, die TMDB nicht kennt, ist kein Fehler.</summary>
+    [Test]
+    public async Task Eine_unbekannte_Folge_ergibt_nichts()
+    {
+        Assert.That(await Client(Attrappe.MitStatus(HttpStatusCode.NotFound)).FindEpisodeAsync(1, 99, 99), Is.Null);
+    }
+
+    [Test]
+    public async Task Leere_Felder_werden_zu_null_statt_zu_Leerstrings()
+    {
+        var json = """{"results":[{"id":1,"title":"Ohne","release_date":"","overview":"","poster_path":""}]}""";
+        var film = await Client(Attrappe.MitJson(json)).FindMovieAsync("Ohne", null);
+
+        Assert.That(film!.Overview, Is.Null);
+        Assert.That(film.Year, Is.Null);
+        Assert.That(film.Poster, Is.Null);
+    }
+}