Phase 2 (Teil 1): Widget-Raster, Layout-Engine, Persistenz

Layout-Engine mit vier Spalten, testgetrieben. Widgets werden nicht stur
hintereinander gesetzt, sondern jeweils an die erste Stelle, an die sie passen.
Der Unterschied zeigt sich neben einem 2x2-Widget: dort bleiben rechts zwei
1x1-Plätze frei, die ein reines Anhängen dauerhaft leer ließe.

Persistenz unterscheidet zwei Fälle, die gleich aussehen und es nicht sind. Eine
leere Layout-Datei ist eine Aussage — der Nutzer hat alle Widgets entfernt. Eine
Datei, aus der nach dem Filtern unbekannter Kennungen nichts übrig bleibt, ist
dagegen ein Zeichen, dass sich die Kennungen geändert haben; dort wäre ein leeres
Panel eine stille Fehlfunktion, also greift das Standardlayout.

Beschädigte und fehlende Dateien führen beide zum Standardlayout statt zu einem
Absturz oder einem leeren Panel.

Die Panelgröße folgt dem Layout statt umgekehrt. Positioniert wird über
LayoutEngine.frame, nicht über LazyVGrid — das kann keine Kacheln über zwei
Zeilen führen, und genau das braucht der Mini-Monat.

Platzhalter-Widgets für alle 13 geplanten Karten. Sie tragen die endgültigen
Kennungen, damit gespeicherte Layouts weitergelten, wenn die echten Widgets sie
Phase für Phase ersetzen.

66 Tests grün.

Packages/OnyxKit/Tests/OnyxWidgetKitTests/LayoutStoreTests.swift

@@ -0,0 +1,129 @@
+import Testing
+import Foundation
+@testable import OnyxWidgetKit
+
+// Die Layout-Datei überlebt App-Updates. Sie kann also Widgets nennen, die es
+// nicht mehr gibt, oder aus einer neueren Version stammen — und sie kann halb
+// geschrieben auf der Platte liegen, wenn der Rechner mitten im Speichern
+// abstürzt. Keiner dieser Fälle darf zu einem leeren Panel führen, ohne dass
+// jemand merkt warum.
+
+@Suite("Layout-Persistenz")
+struct LayoutStoreTests {
+
+    private func temporaryURL() -> URL {
+        FileManager.default.temporaryDirectory
+            .appendingPathComponent("onyx-test-\(UUID().uuidString)")
+            .appendingPathComponent("layout.json")
+    }
+
+    private let known: Set<String> = ["calendar", "weather", "media", "cpu"]
+
+    @Test("Gespeichertes Layout kommt unverändert zurück")
+    func roundTrip() throws {
+        let url = temporaryURL()
+        let store = LayoutStore(url: url)
+        let layout = [
+            WidgetPlacement(widgetID: "calendar", size: .large),
+            WidgetPlacement(widgetID: "media", size: .wide),
+        ]
+
+        try store.save(layout)
+        let loaded = store.load(knownWidgetIDs: known)
+
+        #expect(loaded.map(\.widgetID) == ["calendar", "media"])
+        #expect(loaded.map(\.size) == [.large, .wide])
+    }
+
+    @Test("Die Kennung eines Widgets bleibt über das Speichern hinweg dieselbe")
+    func identitySurvives() throws {
+        let url = temporaryURL()
+        let store = LayoutStore(url: url)
+        let placement = WidgetPlacement(widgetID: "cpu", size: .small)
+
+        try store.save([placement])
+
+        #expect(store.load(knownWidgetIDs: known).first?.id == placement.id)
+    }
+
+    @Test("Fehlende Datei ergibt das Standardlayout, keinen Fehler")
+    func missingFileFallsBack() {
+        let loaded = LayoutStore(url: temporaryURL()).load(knownWidgetIDs: known)
+
+        #expect(!loaded.isEmpty)
+        #expect(loaded.allSatisfy { known.contains($0.widgetID) })
+    }
+
+    @Test("Beschädigte Datei ergibt das Standardlayout statt eines Absturzes")
+    func corruptFileFallsBack() throws {
+        let url = temporaryURL()
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(),
+                                                withIntermediateDirectories: true)
+        try Data("{ das ist kein JSON".utf8).write(to: url)
+
+        let loaded = LayoutStore(url: url).load(knownWidgetIDs: known)
+
+        #expect(!loaded.isEmpty)
+    }
+
+    @Test("Ein entferntes Widget wird aus dem Layout gefiltert, der Rest bleibt")
+    func unknownWidgetIsDropped() throws {
+        let url = temporaryURL()
+        let store = LayoutStore(url: url)
+        try store.save([
+            WidgetPlacement(widgetID: "calendar", size: .large),
+            WidgetPlacement(widgetID: "widget-aus-einer-alten-version", size: .small),
+            WidgetPlacement(widgetID: "media", size: .wide),
+        ])
+
+        let loaded = store.load(knownWidgetIDs: known)
+
+        #expect(loaded.map(\.widgetID) == ["calendar", "media"])
+    }
+
+    @Test("Eine Datei, in der ALLE Widgets unbekannt sind, ergibt das Standardlayout")
+    func allUnknownFallsBack() throws {
+        // Sonst startet die App nach einem Umbau der Widget-Kennungen mit einem
+        // leeren Panel und keiner Erklärung.
+        let url = temporaryURL()
+        let store = LayoutStore(url: url)
+        try store.save([WidgetPlacement(widgetID: "voellig-unbekannt", size: .small)])
+
+        let loaded = store.load(knownWidgetIDs: known)
+
+        #expect(!loaded.isEmpty)
+        #expect(loaded.allSatisfy { known.contains($0.widgetID) })
+    }
+
+    @Test("Ein absichtlich leeres Layout bleibt leer")
+    func deliberatelyEmptyStaysEmpty() throws {
+        // Wer alle Widgets entfernt, meint das auch so — das ist etwas anderes
+        // als eine kaputte Datei.
+        let url = temporaryURL()
+        let store = LayoutStore(url: url)
+        try store.save([])
+
+        #expect(store.load(knownWidgetIDs: known).isEmpty)
+    }
+
+    @Test("Speichern legt fehlende Verzeichnisse an")
+    func savingCreatesDirectories() throws {
+        let url = temporaryURL()
+        try LayoutStore(url: url).save([WidgetPlacement(widgetID: "cpu", size: .small)])
+
+        #expect(FileManager.default.fileExists(atPath: url.path))
+    }
+
+    @Test("Das Standardlayout nennt nur Widgets, die es wirklich gibt")
+    func defaultLayoutIsValid() {
+        let defaults = LayoutStore.defaultLayout(knownWidgetIDs: known)
+
+        #expect(!defaults.isEmpty)
+        #expect(defaults.allSatisfy { known.contains($0.widgetID) })
+    }
+
+    @Test("Ohne bekannte Widgets bleibt auch das Standardlayout leer")
+    func defaultLayoutWithNoWidgets() {
+        #expect(LayoutStore.defaultLayout(knownWidgetIDs: []).isEmpty)
+    }
+}