crossmate

TipStoreTests.swift (6110B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("TipStore")
 @MainActor
 struct TipStoreTests {
 
     private let catalog = [
         Tip(id: "one", title: "One", body: "First"),
         Tip(id: "two", title: "Two", body: "Second"),
         Tip(id: "three", title: "Three", body: "Third"),
     ]
 
     private func makeStore(
         defaults: UserDefaults? = nil
     ) -> (store: TipStore, defaults: UserDefaults) {
         // Fresh UserDefaults suite per test to avoid cross-test pollution.
         let defaults = defaults ?? UserDefaults(suiteName: "test-\(UUID().uuidString)")!
         // Past the launch warm-up by default so tests can focus on dismissal,
         // disable, and platform logic. The warm-up itself is covered separately.
         return (warmedUp(TipStore(defaults: defaults, catalog: catalog)), defaults)
     }
 
     /// Notes enough cold launches to move `store` past the tip warm-up.
     @discardableResult
     private func warmedUp(_ store: TipStore) -> TipStore {
         for _ in 0...TipStore.launchesBeforeTips { store.noteColdLaunch() }
         return store
     }
 
     @Test("currentTip returns the first catalog tip by default")
     func firstTipInitially() {
         let (store, _) = makeStore()
         #expect(store.currentTip()?.id == "one")
     }
 
     @Test("Dismissing a tip advances to the next undismissed one")
     func dismissAdvances() {
         let (store, _) = makeStore()
         store.markDismissed("one")
         #expect(store.currentTip()?.id == "two")
         store.markDismissed("two")
         #expect(store.currentTip()?.id == "three")
     }
 
     @Test("Once every tip is dismissed there is nothing to surface")
     func allDismissed() {
         let (store, _) = makeStore()
         for tip in catalog { store.markDismissed(tip.id) }
         #expect(store.currentTip() == nil)
     }
 
     @Test("Disabling tips suppresses the banner regardless of dismissals")
     func disableSuppresses() {
         let (store, _) = makeStore()
         store.disable()
         #expect(store.isDisabled)
         #expect(store.currentTip() == nil)
         // Re-enabling brings back the next undismissed tip.
         store.enable()
         #expect(!store.isDisabled)
         #expect(store.currentTip()?.id == "one")
     }
 
     @Test("Dismissals and the opt-out flag persist across instances")
     func persistsAcrossInstances() {
         let (store, defaults) = makeStore()
         store.markDismissed("one")
         store.disable()
 
         let (reloaded, _) = makeStore(defaults: defaults)
         #expect(reloaded.isDisabled)
         reloaded.enable()
         #expect(reloaded.currentTip()?.id == "two")
     }
 
     @Test("No tip surfaces during the launch warm-up")
     func warmUpSuppressesTips() {
         let defaults = UserDefaults(suiteName: "test-\(UUID().uuidString)")!
         let store = TipStore(defaults: defaults, catalog: catalog)
         // A brand new store surfaces nothing, and each warm-up launch stays
         // tip-free.
         #expect(store.currentTip() == nil)
         for _ in 0..<TipStore.launchesBeforeTips {
             store.noteColdLaunch()
             #expect(store.currentTip() == nil)
         }
         // The launch after the warm-up surfaces the first tip.
         store.noteColdLaunch()
         #expect(store.currentTip()?.id == "one")
     }
 
     @Test("The launch warm-up persists across instances")
     func warmUpPersists() {
         let defaults = UserDefaults(suiteName: "test-\(UUID().uuidString)")!
         // Note every warm-up launch but one on a first instance…
         let first = TipStore(defaults: defaults, catalog: catalog)
         for _ in 0..<TipStore.launchesBeforeTips { first.noteColdLaunch() }
 
         // …a reload picks up the persisted count: still within the warm-up, so
         // the final launch is what tips over into surfacing a tip.
         let reloaded = TipStore(defaults: defaults, catalog: catalog)
         #expect(reloaded.currentTip() == nil)
         reloaded.noteColdLaunch()
         #expect(reloaded.currentTip()?.id == "one")
     }
 
     @Test("Tips scoped to other platforms are filtered out")
     func platformScoping() {
         let catalog = [
             Tip(id: "both", title: "Both", body: "Everywhere"),
             Tip(id: "ipad", title: "iPad", body: "iPad only", only: [.iPad]),
             Tip(id: "iphone", title: "iPhone", body: "iPhone only", only: [.iPhone]),
         ]
         let defaults = UserDefaults(suiteName: "test-\(UUID().uuidString)")!
         let onPhone = warmedUp(TipStore(defaults: defaults, catalog: catalog, platform: .iPhone))
         #expect(onPhone.visibleTips.map(\.id) == ["both", "iphone"])
         // The first applicable tip skips the iPad-only one.
         #expect(onPhone.currentTip()?.id == "both")
         onPhone.markDismissed("both")
         #expect(onPhone.currentTip()?.id == "iphone")
 
         let onPad = TipStore(defaults: defaults, catalog: catalog, platform: .iPad)
         #expect(onPad.visibleTips.map(\.id) == ["both", "ipad"])
     }
 
     @Test("Tip announcement ids round-trip so the banner can recognise a tip")
     func announcementIDRoundTrips() {
         let id = Tip.announcementID(for: "welcome")
         #expect(Tip.tipID(fromAnnouncementID: id) == "welcome")
         // A non-tip announcement id is not mistaken for a tip.
         #expect(Tip.tipID(fromAnnouncementID: "reset-database-error") == nil)
     }
 
     @Test("A tip's live banner is a lowest-severity, manually dismissable global")
     func liveAnnouncementShape() {
         let tip = catalog[0]
         let announcement = tip.liveAnnouncement()
         #expect(announcement.scope == .global)
         #expect(announcement.severity == .tip)
         #expect(announcement.dismissal == .manual)
         #expect(announcement.title == "One")
         #expect(announcement.body == "First")
     }
 
     @Test("A tip's archive banner has no close control")
     func archiveAnnouncementHasNoCloseControl() {
         // The banner shows a ✕ only for `.manual`; the archive uses `.sticky`.
         #expect(catalog[0].archiveAnnouncement().dismissal == .sticky)
     }
 }