Wetter: Zwischenspeicher auf Platte, Zeitlimits auf alle Netzaufrufe

Das Protokoll zeigte das Wetter nach 185 ms erfolgreich geladen — und
danach nichts mehr. Dazwischen liegt genau ein Aufruf, der noch ins Netz
geht: die Abfrage der Namensnennung. Sie hatte kein Zeitlimit, und ohne
sie wurde der Schnappschuss nie gebaut. Ein Netzaufruf ohne Zeitlimit ist
ein Aufruf, der hängen darf.

Jetzt hat jeder ein Limit: Wetter zwölf Sekunden, Ortung acht, Umkehrsuche
fünf, Namensnennung drei. Die Namensnennung hält den Messwert ohnehin nicht
mehr auf — sie ist Pflicht für die Anzeige, nicht für das Laden — und wird
behalten, weil sie sich nicht ändert.

Der Zwischenspeicher lag nur im Arbeitsspeicher. Beim Start stand deshalb
ein Rädchen da, bis der erste Abruf durch war; hing der, für immer. Er
liegt jetzt in weather.json und wird beim Anlegen des Modells gelesen: das
Widget zeigt sofort, was zuletzt bekannt war, mit Zeitstempel, und lädt im
Hintergrund nach. Ein Wert von vor einer Stunde ist eine Auskunft, ein
Rädchen ist keine.

Nachgeprüft: Datei wird geschrieben, Hamburg mit zwölf Stundenwerten.

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

Packages/OnyxKit/Tests/WeatherProviderTests/WeatherCacheTests.swift

@@ -25,7 +25,7 @@ struct WeatherCacheTests {
     @Test("Frischer Eintrag wird wiederverwendet")
     func freshEntryIsReused() {
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: place)
 
         #expect(cache.valid(for: place, now: now.addingTimeInterval(60)) != nil)
@@ -34,7 +34,7 @@ struct WeatherCacheTests {
     @Test("Nach Ablauf der Frist wird neu geladen")
     func staleEntryIsDiscarded() {
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: place)
 
         let later = now.addingTimeInterval(WeatherCache.maxAge + 1)
@@ -44,7 +44,7 @@ struct WeatherCacheTests {
     @Test("Genau auf der Frist gilt der Eintrag noch")
     func exactlyAtMaxAgeIsStillValid() {
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: place)
 
         #expect(cache.valid(for: place, now: now.addingTimeInterval(WeatherCache.maxAge)) != nil)
@@ -55,7 +55,7 @@ struct WeatherCacheTests {
         // Sonst zeigt das Widget nach dem Umstellen des Ortes weiter das alte
         // Wetter — und zwar überzeugend, weil Zahlen dastehen.
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: place)
 
         #expect(cache.valid(for: other, now: now) == nil)
@@ -64,7 +64,7 @@ struct WeatherCacheTests {
     @Test("Der aktuelle Standort ist ein eigener Eintrag")
     func currentLocationIsItsOwnEntry() {
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: .current)
 
         #expect(cache.valid(for: .current, now: now) != nil)
@@ -73,7 +73,7 @@ struct WeatherCacheTests {
 
     @Test("Leerer Zwischenspeicher liefert nichts")
     func emptyCacheMisses() {
-        #expect(WeatherCache().valid(for: place, now: Date()) == nil)
+        #expect(WeatherCache(url: nil).valid(for: place, now: Date()) == nil)
     }
 
     @Test("Ein abgelaufener Eintrag bleibt als letzter bekannter Stand erhalten")
@@ -81,7 +81,7 @@ struct WeatherCacheTests {
         // Bei einem Netzfehler ist ein alter Messwert mit sichtbarem Zeitstempel
         // deutlich besser als ein leeres Feld.
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now), for: place)
 
         let later = now.addingTimeInterval(WeatherCache.maxAge * 10)
@@ -92,7 +92,7 @@ struct WeatherCacheTests {
     @Test("Ein neuer Eintrag ersetzt den alten desselben Ortes")
     func storingReplaces() {
         let now = Date()
-        var cache = WeatherCache()
+        var cache = WeatherCache(url: nil)
         cache.store(snapshot(at: now.addingTimeInterval(-1000)), for: place)
         cache.store(snapshot(at: now), for: place)
 
@@ -103,6 +103,59 @@ struct WeatherCacheTests {
     func maxAgeMatchesPlan() {
         #expect(WeatherCache.maxAge == 15 * 60)
     }
+
+    @Test("Der Stand überlebt einen Neustart")
+    func survivesRestart() throws {
+        // Der eigentliche Punkt. Ohne Datei steht beim Start ein Rädchen da,
+        // bis der erste Abruf durch ist — und wenn der hängt, für immer.
+        let url = Self.temporaryURL()
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        var cache = WeatherCache(url: url)
+        cache.store(snapshot(at: Date()), for: place)
+        try cache.save()
+
+        let restored = WeatherCache(url: url).lastKnown(for: place)
+        #expect(restored?.temperature.value == 18)
+        #expect(restored?.placeName == "Lemgo")
+    }
+
+    @Test("Auch die Stundenwerte überleben")
+    func hourlySurvives() throws {
+        let url = Self.temporaryURL()
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        let point = HourlyPoint(date: Date(), temperature: .init(value: 19, unit: .celsius),
+                                condition: .clear, precipitationChance: 0.1)
+        var cache = WeatherCache(url: url)
+        cache.store(WeatherSnapshot(placeName: "Lemgo",
+                                    temperature: .init(value: 18, unit: .celsius),
+                                    apparentTemperature: .init(value: 17, unit: .celsius),
+                                    condition: .partlyCloudy, isDaylight: true, humidity: 0.6,
+                                    windSpeed: .init(value: 10, unit: .kilometersPerHour),
+                                    high: nil, low: nil, hourly: [point],
+                                    asOf: Date(), attribution: nil), for: place)
+        try cache.save()
+
+        #expect(WeatherCache(url: url).lastKnown(for: place)?.hourly.count == 1)
+    }
+
+    @Test("Eine unlesbare Datei führt nicht zum Absturz")
+    func brokenFileIsSurvivable() throws {
+        let url = Self.temporaryURL()
+        defer { try? FileManager.default.removeItem(at: url) }
+        try Data("kein JSON".utf8).write(to: url)
+
+        // Leer ist hier richtig: ein Zwischenspeicher, dem man nicht trauen
+        // kann, ist kein Grund, das Widget aufzugeben.
+        #expect(WeatherCache(url: url).lastKnown(for: place) == nil)
+    }
+
+    /// Nie der echte Ablageort — Tests dürfen ihn nicht anfassen.
+    private static func temporaryURL() -> URL {
+        URL(fileURLWithPath: NSTemporaryDirectory())
+            .appendingPathComponent("onyx-weather-\(UUID().uuidString).json")
+    }
 }
 
 @Suite("Wettersymbole")
@@ -136,3 +189,25 @@ struct WeatherSymbolTests {
         }
     }
 }
+
+@Suite("Zeitlimit")
+struct TimeoutTests {
+
+    @Test("Ein schneller Aufruf kommt durch")
+    func fastCallReturns() async {
+        let value = await withTimeout(seconds: 1) { 42 }
+        #expect(value == 42)
+    }
+
+    @Test("Ein hängender Aufruf gibt auf")
+    func slowCallGivesUp() async {
+        // Genau das ist passiert: WeatherKit lieferte das Wetter in 185 ms,
+        // danach hing die Abfrage der Namensnennung — und das Widget zeigte
+        // für immer ein Rädchen.
+        let value: Int? = await withTimeout(seconds: 0.05) {
+            try? await Task.sleep(for: .seconds(5))
+            return 42
+        }
+        #expect(value == nil)
+    }
+}