Fünf Aufmacher je Titel, und der Abspann zählt als Schluss

**Der Aufmacher darf wechseln.** Bisher hing hinter jedem Titel genau ein
Hintergrundbild, und das Karussell war nach einer Woche ein Standbild.
Jetzt lassen sich bis zu fünf Aufnahmen aussuchen — im Bilderdialog unter
einem vierten Reiter, gespeist aus denselben Hintergründen.

Welches gerade gilt, entscheidet der Server aus Uhrzeit und Kennung: alle
fünf Stunden ein anderes, überall dasselbe — im Web, in der App, nach
einem Neustart. Ein Zufall je Abruf hiesse, dass das Bild beim Blättern
springt; eine gespeicherte Wahl hiesse einen Schreibvorgang je Titel und
Fenster. Die Kennung geht mit in die Rechnung, damit nicht alle Titel im
selben Augenblick umschalten.

Plakat und Hintergrund bleiben unberührt. Sie stehen hinter Kacheln und
Kopfzeilen, und dort soll nichts wechseln.

**Und der Abspann zählt als Schluss.** Eine Serie hängt sechs Minuten
Abspann an eine Folge von fünfundvierzig; neunzig Prozent liegen dann
mittendrin, und die Folge gilt erst als gesehen, wenn man ihn sich ganz
ansieht. Die Schwelle herunterzudrehen hiesse, jeden anderen Titel zu
früh abzuhaken. Der erkannte Abspann ist die genauere Antwort auf
dieselbe Frage — er zieht die Schwelle nach vorn, nie nach hinten.

Dazu der Verlauf über dem Aufmacher: er war immer noch zu dunkel. Jetzt
trägt der Schattenwurf der Schrift, was vorher eine Decke über dem
ganzen Bild tat.

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

server/tests/Flaro.Core.Tests/AufmacherwahlTests.cs

@@ -0,0 +1,100 @@
+using Flaro.Core.Media;
+
+namespace Flaro.Core.Tests;
+
+/// <summary>Welches Aufmacherbild gerade gilt.</summary>
+public class AufmacherwahlTests
+{
+    private static readonly Guid Titel = Guid.Parse("11111111-2222-3333-4444-555555555555");
+    private static readonly DateTimeOffset Montag = new(2026, 10, 12, 8, 0, 0, TimeSpan.Zero);
+
+    [Test]
+    public void Ohne_Auswahl_gibt_es_keines()
+    {
+        Assert.That(Aufmacherwahl.Jetziges(null, Titel, Montag), Is.Null);
+        Assert.That(Aufmacherwahl.Jetziges("", Titel, Montag), Is.Null);
+    }
+
+    [Test]
+    public void Ein_einziges_Bild_bleibt_immer_dasselbe()
+    {
+        var spaeter = Montag.AddDays(30);
+        Assert.That(Aufmacherwahl.Jetziges("a", Titel, Montag), Is.EqualTo("a"));
+        Assert.That(Aufmacherwahl.Jetziges("a", Titel, spaeter), Is.EqualTo("a"));
+    }
+
+    /// <summary>Innerhalb eines Fensters kommt überall dasselbe heraus.</summary>
+    ///
+    /// <remarks>
+    /// <b>Der eigentliche Grund für die Rechnung.</b> Ein Zufall je Abruf
+    /// hiesse: beim Blättern springt das Bild, und die App zeigt ein
+    /// anderes als das Web.
+    /// </remarks>
+    [Test]
+    public void Innerhalb_des_Fensters_wechselt_nichts()
+    {
+        var erstes = Aufmacherwahl.Jetziges("a,b,c", Titel, Montag);
+        var kurzDarauf = Aufmacherwahl.Jetziges("a,b,c", Titel, Montag.AddMinutes(90));
+
+        Assert.That(kurzDarauf, Is.EqualTo(erstes));
+    }
+
+    [Test]
+    public void Nach_dem_Fenster_kommt_ein_anderes()
+    {
+        var erstes = Aufmacherwahl.Jetziges("a,b,c", Titel, Montag);
+        var danach = Aufmacherwahl.Jetziges("a,b,c", Titel, Montag + Aufmacherwahl.Fenster);
+
+        Assert.That(danach, Is.Not.EqualTo(erstes));
+    }
+
+    /// <summary>Über einen Tag kommt jedes Bild vor.</summary>
+    [Test]
+    public void Alle_Bilder_kommen_an_die_Reihe()
+    {
+        var gesehen = new HashSet<string?>();
+        for (var i = 0; i < 24; i++)
+            gesehen.Add(Aufmacherwahl.Jetziges("a,b,c", Titel, Montag.AddHours(i * 5)));
+
+        Assert.That(gesehen, Is.EquivalentTo(new[] { "a", "b", "c" }));
+    }
+
+    /// <summary>Zwei Titel schalten nicht im selben Augenblick um.</summary>
+    [Test]
+    public void Nicht_alle_Titel_zugleich()
+    {
+        var anderer = Guid.Parse("99999999-8888-7777-6666-555555555555");
+        var eins = Aufmacherwahl.Jetziges("a,b,c", Titel, Montag);
+        var zwei = Aufmacherwahl.Jetziges("a,b,c", anderer, Montag);
+
+        Assert.That(zwei, Is.Not.EqualTo(eins));
+    }
+
+    [Test]
+    public void Mehr_als_fuenf_werden_abgeschnitten()
+    {
+        var zeile = Aufmacherwahl.Schreiben(["a", "b", "c", "d", "e", "f", "g"]);
+        Assert.That(Aufmacherwahl.Lesen(zeile), Has.Count.EqualTo(5));
+    }
+
+    [Test]
+    public void Doppelte_und_Leere_fallen_heraus()
+    {
+        var zeile = Aufmacherwahl.Schreiben(["a", " a ", "", "  ", "b"]);
+        Assert.That(Aufmacherwahl.Lesen(zeile), Is.EqualTo(new[] { "a", "b" }));
+    }
+
+    /// <summary>Ein Komma im Schlüssel zerlegte die Zeile beim Lesen.</summary>
+    [Test]
+    public void Ein_Schluessel_mit_Komma_wird_verworfen()
+    {
+        Assert.That(Aufmacherwahl.Lesen(Aufmacherwahl.Schreiben(["a,b", "c"])),
+            Is.EqualTo(new[] { "c" }));
+    }
+
+    [Test]
+    public void Ohne_Bilder_bleibt_die_Zeile_leer()
+    {
+        Assert.That(Aufmacherwahl.Schreiben([]), Is.Null);
+    }
+}

server/tests/Flaro.Core.Tests/ProgressRuleTests.cs

@@ -268,4 +268,60 @@ public sealed class ProgressRuleTests
 
     private static UserItemState Zustand(TimeSpan stelle, TimeSpan? laenge) =>
         new() { UserId = Guid.CreateVersion7(), MovieId = Guid.CreateVersion7(), Position = stelle, Runtime = laenge };
+
+    /// <summary>Ein erkannter Abspann zieht das Häkchen nach vorn.</summary>
+    ///
+    /// <remarks>
+    /// <b>Der Fall aus dem Gebrauch.</b> Eine Serie hängt sechs Minuten
+    /// Abspann an eine Folge von fünfundvierzig. Neunzig Prozent liegen dann
+    /// mitten im Abspann, und die Folge gilt erst als gesehen, wenn man ihn
+    /// sich ganz ansieht. Die Schwelle dafür herunterzudrehen hiesse, jeden
+    /// anderen Titel zu früh abzuhaken.
+    /// </remarks>
+    [Test]
+    public void Der_Abspann_zaehlt_als_Schluss()
+    {
+        var laenge = TimeSpan.FromMinutes(45);
+        var abspann = TimeSpan.FromMinutes(39);
+        var regeln = new Wiedergaberegeln { GesehenAnteil = 0.9 };
+
+        var amAbspann = ProgressRule.Apply(abspann, laenge, regeln, abspann);
+        var davor = ProgressRule.Apply(abspann - TimeSpan.FromSeconds(30), laenge, regeln, abspann);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(amAbspann.Watched, Is.True, "ab dem Abspann ist die Handlung vorbei");
+            Assert.That(davor.Watched, Is.False, "eine halbe Minute davor noch nicht");
+        });
+    }
+
+    /// <summary>Eine Marke hinter der Schwelle verschiebt nichts nach hinten.</summary>
+    ///
+    /// <remarks>
+    /// Sonst machte eine falsch erkannte Marke aus einem Titel, der bei
+    /// neunzig Prozent fertig war, einen, der es erst bei fünfundneunzig
+    /// ist — und niemand sähe, warum.
+    /// </remarks>
+    [Test]
+    public void Eine_spaete_Marke_schiebt_nichts_nach_hinten()
+    {
+        var laenge = TimeSpan.FromMinutes(45);
+        var regeln = new Wiedergaberegeln { GesehenAnteil = 0.9 };
+
+        var ergebnis = ProgressRule.Apply(
+            TimeSpan.FromMinutes(41), laenge, regeln, abspannAb: TimeSpan.FromMinutes(44));
+
+        Assert.That(ergebnis.Watched, Is.True);
+    }
+
+    /// <summary>Ohne Marke bleibt alles, wie es war.</summary>
+    [Test]
+    public void Ohne_Abspann_gilt_der_Anteil()
+    {
+        var laenge = TimeSpan.FromMinutes(45);
+        var regeln = new Wiedergaberegeln { GesehenAnteil = 0.9 };
+
+        Assert.That(ProgressRule.Apply(TimeSpan.FromMinutes(39), laenge, regeln).Watched, Is.False);
+        Assert.That(ProgressRule.Apply(TimeSpan.FromMinutes(41), laenge, regeln).Watched, Is.True);
+    }
 }