Das eigene Bild führte aus dem Server heraus

Ein Klick auf den Buchstabenkreis meldete ab. Keine Rückfrage, kein Menü, kein Weg zurück — hinter einer Geste, die überall sonst „mein Konto" heisst. Jetzt führt er auf `#/profil`; Abmelden steht dort als Knopf, mit Nachfrage. Auf der Seite: Bild wählen, tauschen, entfernen. Dazu „Meine Sprache" — **umgezogen, nicht kopiert.** Sie stand mitten in der Verwaltung, und die zeigt der Client nur Administratoren; der Endpunkt erlaubte sie längst jedem. Wer kein Admin war, konnte seine eigene Sprache nirgends ändern. Der Warnhinweis „weicht ab" bleibt in der Verwaltung, denn dort entsteht die Verwirrung — er verweist jetzt aufs Profil. **Vorher musste ein Fehler weg, der seit Monaten dasteht.** `ImageCache.StoreStreamAsync` baute den Schlüssel aus 32 Hexzeichen plus Dateiendung; `PfadFür` verlangt genau 64 Hexzeichen und nichts sonst. Es gab keinen Wert, den beide gelten liessen: **jeder Bildupload gab `null` zurück und endete in einem 502.** Kein Test fragte je danach — jetzt vier. Damit geht nebenbei auch „eigenes Bild hochladen" für Filme und Serien wieder. Weil der Schlüssel keine Endung mehr trägt, kommt der Medientyp beim Ausliefern aus den ersten Bytes der Datei. Vorher ging alles als `image/jpeg` hinaus — bei TMDB stimmte das, bei einem hochgeladenen PNG nicht. **Und die gemerkte Sitzung war eine Kopie, die nie nachzog.** Sie wurde bei der Anmeldung geschrieben und danach nie wieder. Wer sein Bild am Telefon setzt und den Browser am Schreibtisch öffnet, fand dort den alten Buchstaben — bis zum nächsten Anmelden. Gemessen und behoben: beim Hochfahren wird das Konto abgeglichen, und das Profil meldet Änderungen an die Kopfleiste, damit sie ohne Neuladen nachzieht. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 17:07:40 +02:00
parent 9622da0284
commit d8a1633cf4
18 changed files with 1757 additions and 57 deletions
@@ -152,4 +152,72 @@ public class ImageCacheTests
        public override void SetLength(long v) => throw new NotSupportedException();
        public override void Write(byte[] p, int v, int a) => throw new NotSupportedException();
    }
+
+    /* ---------- Hochgeladene Bilder ---------- */
+
+    /// <summary>Ein hochgeladenes Bild landet und ist danach abrufbar.</summary>
+    ///
+    /// <remarks>
+    /// <b>Dieser Weg war monatelang kaputt und niemand prüfte ihn.</b>
+    /// <c>StoreStreamAsync</c> baute einen Schlüssel aus 32 Hexzeichen plus
+    /// Dateiendung, <c>PfadFür</c> verlangt genau 64 Hexzeichen — es gab
+    /// keinen Wert, den beide gelten liessen. Jeder Upload gab <c>null</c>
+    /// zurück, und der Endpunkt antwortete 502.
+    /// </remarks>
+    [Test]
+    public async Task Ein_hochgeladenes_Bild_landet_da_wo_man_es_wiederfindet()
+    {
+        var ablage = Ablage(MitBild());
+        using var strom = new MemoryStream(Encoding.UTF8.GetBytes("ein eigenes bild"));
+
+        var schlüssel = await ablage.StoreStreamAsync(strom, "image/png");
+
+        Assert.That(schlüssel, Is.Not.Null, "ohne Schlüssel gibt es kein Bild");
+        Assert.Multiple(() =>
+        {
+            Assert.That(schlüssel, Has.Length.EqualTo(64));
+            Assert.That(ablage.PfadFür(schlüssel!), Is.Not.Null,
+                "der Schlüssel muss durch dieselbe Prüfung passen, die ihn ausliefert");
+            Assert.That(File.Exists(ablage.PfadFür(schlüssel!)), Is.True);
+        });
+    }
+
+    /// <summary>Derselbe Inhalt ergibt dieselbe Datei.</summary>
+    [Test]
+    public async Task Zweimal_dasselbe_Bild_liegt_einmal_da()
+    {
+        var ablage = Ablage(MitBild());
+        var a = await ablage.StoreStreamAsync(new MemoryStream(Encoding.UTF8.GetBytes("gleich")), "image/jpeg");
+        var b = await ablage.StoreStreamAsync(new MemoryStream(Encoding.UTF8.GetBytes("gleich")), "image/png");
+
+        Assert.That(b, Is.EqualTo(a));
+    }
+
+    /// <summary>Leeres wird abgelehnt, nicht abgelegt.</summary>
+    [Test]
+    public async Task Eine_leere_Datei_wird_nicht_abgelegt()
+    {
+        var ablage = Ablage(MitBild());
+        Assert.That(await ablage.StoreStreamAsync(new MemoryStream([]), "image/jpeg"), Is.Null);
+    }
+
+    /// <summary>Der Medientyp kommt aus dem Inhalt, nicht aus dem Namen.</summary>
+    ///
+    /// <remarks>
+    /// Der Schlüssel trägt keine Endung — ohne diese Erkennung ginge jedes
+    /// Bild als <c>image/jpeg</c> hinaus, auch ein PNG.
+    /// </remarks>
+    [Test]
+    public void Der_Medientyp_steht_in_den_ersten_Bytes()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(ImageCache.Medientyp([0x89, 0x50, 0x4E, 0x47, 0x0D]), Is.EqualTo("image/png"));
+            Assert.That(ImageCache.Medientyp([0x47, 0x49, 0x46, 0x38, 0x39]), Is.EqualTo("image/gif"));
+            Assert.That(ImageCache.Medientyp(
+                [0x52, 0x49, 0x46, 0x46, 1, 2, 3, 4, 0x57, 0x45, 0x42, 0x50]), Is.EqualTo("image/webp"));
+            Assert.That(ImageCache.Medientyp([0xFF, 0xD8, 0xFF, 0xE0]), Is.EqualTo("image/jpeg"));
+            Assert.That(ImageCache.Medientyp([]), Is.EqualTo("image/jpeg"), "im Zweifel das Häufigste");
+        });
+    }
 }