Tests that do not wait for the clock

import Foundation

/// The weather for the city being typed into the planner: asked once typing has paused. `@MainActor`: the planner
/// reads it.
@MainActor
@Observable
final class PlannerWeather {
    private(set) var preview: Weather?
    private let cache: WeatherCache
    private let clock: any Clock<Duration>

    /// The cache every screen shares and the real clock, unless a test hands in its own.
    init(cache: WeatherCache = .shared, clock: any Clock<Duration> = ContinuousClock()) {
        self.cache = cache
        self.clock = clock
    }

    /// Waits for typing to pause, then asks. Call it from `.task(id:)`, which cancels it when the text changes.
    func update(for city: String) async {
        guard !city.isEmpty else {
            preview = nil
            return
        }
        do {
            try await clock.sleep(for: .milliseconds(500))
        } catch {
            // another letter came, or the planner closed
            return
        }
        let answer = try? await cache.weather(in: city)
        if !Task.isCancelled {
            preview = answer
        }
    }
}

struct TripPlanner: View {    @Environment(TripStore.self) private var store    @State private var isOpen = false    @State private var draft = TripDraft()    @State private var preview: Weather?    @State private var weather = PlannerWeather()    @Environment(\.horizontalSizeClass) private var sizeClass    var body: some View {        VStack(spacing: 12) {            VStack(alignment: .leading, spacing: 12) {                Button(isOpen ? "Close the planner" : "Plan a trip", systemImage: isOpen ? "xmark" : "plus") {                    isOpen.toggle()                }                .buttonStyle(.bordered)                if isOpen {                    IdeasRow { idea in                        draft.city = idea.city                        draft.country = idea.country                        draft.nights = idea.suggestedNights                    }                    let fields = sizeClass == .regular ? AnyLayout(HStackLayout()) : AnyLayout(VStackLayout(alignment: .leading))                    fields {                        TextField("City", text: $draft.city)                        TextField("Country", text: $draft.country)                    }                    if let preview {                    if let preview = weather.preview {                        Label("\(preview.place): \(preview.temperature, format: .number.precision(.fractionLength(0)))°F, \(preview.sky.words)",                              systemImage: preview.sky.symbol)                            .font(.subheadline)                    }                    Stepper(value: $draft.nights, in: 1...60) {                        Text("^[\(draft.nights) night](inflect: true)")                    }                    Stepper(value: $draft.price, in: 0...20_000, step: 250) {                        Text(draft.price, format: .currency(code: "USD"))                    }                    HStack {                        PicturePicker(selection: $draft.imageName)                        Spacer()                        FavoriteButton(isFavorite: $draft.isFavorite)                    }                    Button("Add to my trips") {                        store.add(draft)                        draft = TripDraft()                        isOpen = false                    }                    .buttonStyle(.borderedProminent)                    .disabled(draft.city.isEmpty)                }            }            .textFieldStyle(.roundedBorder)            .frame(maxWidth: .infinity, alignment: .leading)            .padding(.horizontal)            .task(id: draft.city) {                guard !draft.city.isEmpty else {                    preview = nil                    return                }                do {                    try await Task.sleep(for: .milliseconds(500))      // until typing pauses                } catch {                    // another letter came, or the planner closed                    return                }                let answer = try? await WeatherCache.shared.weather(in: draft.city)                if !Task.isCancelled {                    preview = answer                }                await weather.update(for: draft.city)            }            if isOpen {                TripCard(trip: Binding(                    get: { draft.trip(id: 0) },                    set: { draft.isFavorite = $0.isFavorite }                ))            }        }    }}

struct TripPlanner: View {
    @Environment(TripStore.self) private var store
    @State private var isOpen = false
    @State private var draft = TripDraft()
    @State private var weather = PlannerWeather()
    @Environment(\.horizontalSizeClass) private var sizeClass

    var body: some View {
        VStack(spacing: 12) {
            VStack(alignment: .leading, spacing: 12) {
                Button(isOpen ? "Close the planner" : "Plan a trip", systemImage: isOpen ? "xmark" : "plus") {
                    isOpen.toggle()
                }
                .buttonStyle(.bordered)
                if isOpen {
                    IdeasRow { idea in
                        draft.city = idea.city
                        draft.country = idea.country
                        draft.nights = idea.suggestedNights
                    }
                    let fields = sizeClass == .regular ? AnyLayout(HStackLayout()) : AnyLayout(VStackLayout(alignment: .leading))
                    fields {
                        TextField("City", text: $draft.city)
                        TextField("Country", text: $draft.country)
                    }
                    if let preview = weather.preview {
                        Label("\(preview.place): \(preview.temperature, format: .number.precision(.fractionLength(0)))°F, \(preview.sky.words)",
                              systemImage: preview.sky.symbol)
                            .font(.subheadline)
                    }
                    Stepper(value: $draft.nights, in: 1...60) {
                        Text("^[\(draft.nights) night](inflect: true)")
                    }
                    Stepper(value: $draft.price, in: 0...20_000, step: 250) {
                        Text(draft.price, format: .currency(code: "USD"))
                    }
                    HStack {
                        PicturePicker(selection: $draft.imageName)
                        Spacer()
                        FavoriteButton(isFavorite: $draft.isFavorite)
                    }
                    Button("Add to my trips") {
                        store.add(draft)
                        draft = TripDraft()
                        isOpen = false
                    }
                    .buttonStyle(.borderedProminent)
                    .disabled(draft.city.isEmpty)
                }
            }
            .textFieldStyle(.roundedBorder)
            .frame(maxWidth: .infinity, alignment: .leading)
            .padding(.horizontal)
            .task(id: draft.city) {
                await weather.update(for: draft.city)
            }
            if isOpen {
                TripCard(trip: Binding(
                    get: { draft.trip(id: 0) },
                    set: { draft.isFavorite = $0.isFavorite }
                ))
            }
        }
    }
}

import Testing
@testable import Trips

/// The cities a stand-in for Open-Meteo was asked about.
actor Requests {
    private(set) var cities: [String] = []

    func record(_ city: String) {
        cities.append(city)
    }
}

/// The planner's weather, with a stand-in for Open-Meteo.
@MainActor
struct PlannerWeatherTests {
    let requests = Requests()

    /// A cache whose `fetch` records the city it was asked about, and answers with a made-up Bergen.
    var cache: WeatherCache {
        let bergen = Weather(place: "Bergen, Testland", temperature: 52, code: 61)
        return WeatherCache(fetch: { [requests] city in
            await requests.record(city)
            return bergen
        })
    }

    @Test func asksOnceTypingPauses() async {
        let weather = PlannerWeather(cache: cache)
        await weather.update(for: "Bergen")
        #expect(await requests.cities == ["Bergen"])
    }
}

import Foundation
import Synchronization

/// A clock that moves only when a test tells it to. `Sendable`, as `Clock` requires: every task that sleeps on it
/// shares it, and its state is behind a `Mutex`.
final class TestClock: Clock {
    struct Instant: InstantProtocol {
        var offset: Duration = .zero

        func advanced(by duration: Duration) -> Instant {
            Instant(offset: offset + duration)
        }
        func duration(to other: Instant) -> Duration {
            other.offset - offset
        }
        static func < (a: Instant, b: Instant) -> Bool {
            a.offset < b.offset
        }
    }

    /// A task that is sleeping until a deadline.
    private struct Sleeper {
        let id: UUID
        let deadline: Instant
        let continuation: CheckedContinuation<Void, any Error>
    }

    private let state = Mutex<(now: Instant, sleepers: [Sleeper])>((Instant(), []))

    var now: Instant {
        state.withLock { $0.now }
    }
    var minimumResolution: Duration {
        .zero
    }

    func sleep(until deadline: Instant, tolerance: Duration? = nil) async throws {
        let id = UUID()
        try await withTaskCancellationHandler {
            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, any Error>) in
                state.withLock {
                    if Task.isCancelled {
                        continuation.resume(throwing: CancellationError())
                    } else if deadline <= $0.now {
                        continuation.resume()
                    } else {
                        $0.sleepers.append(Sleeper(id: id, deadline: deadline, continuation: continuation))
                    }
                }
            }
        } onCancel: {
            let sleeper = state.withLock { s -> Sleeper? in
                guard let i = s.sleepers.firstIndex(where: { $0.id == id }) else { return nil }
                return s.sleepers.remove(at: i)
            }
            sleeper?.continuation.resume(throwing: CancellationError())
        }
    }

    /// Moves time on, waking every sleeper whose deadline it reaches. `nonisolated(nonsending)`: on the test's actor,
    /// so that its yields give that actor's other tasks their turns.
    nonisolated(nonsending) func advance(by duration: Duration) async {
        // let tasks that are about to sleep get to their sleep first
        await Task.megaYield()
        let due = state.withLock { s -> [Sleeper] in
            s.now = s.now.advanced(by: duration)
            let due = s.sleepers.filter { $0.deadline <= s.now }
            s.sleepers.removeAll { $0.deadline <= s.now }
            return due
        }
        for sleeper in due {
            sleeper.continuation.resume()
        }
        await Task.megaYield()                      // and let the ones woken run
    }
}

extension Task where Success == Never, Failure == Never {
    /// Gives other tasks many turns to run before carrying on — on the caller's actor, whose tasks they are.
    nonisolated(nonsending) static func megaYield(count: Int = 20) async {
        for _ in 0..<count {
            await Task.yield()
        }
    }
}

/// The planner's weather, with a stand-in for Open-Meteo.@MainActorstruct PlannerWeatherTests {    let requests = Requests()    /// A cache whose `fetch` records the city it was asked about, and answers with a made-up Bergen.    var cache: WeatherCache {        let bergen = Weather(place: "Bergen, Testland", temperature: 52, code: 61)        return WeatherCache(fetch: { [requests] city in            await requests.record(city)            return bergen        })    }    @Test func asksOnceTypingPauses() async {        let weather = PlannerWeather(cache: cache)        await weather.update(for: "Bergen")        #expect(await requests.cities == ["Bergen"])    }    @Test func nothingBeforeTheWaitIsOver() async {        let clock = TestClock()        let weather = PlannerWeather(cache: cache, clock: clock)        let typing = Task { await weather.update(for: "Bergen") }        await clock.advance(by: .milliseconds(499))        #expect(await requests.cities == [])        await clock.advance(by: .milliseconds(1))        await typing.value        #expect(await requests.cities == ["Bergen"])        #expect(weather.preview?.place == "Bergen, Testland")    }    @Test func aNewLetterCancelsTheWait() async {        let clock = TestClock()        let weather = PlannerWeather(cache: cache, clock: clock)        let first = Task { await weather.update(for: "Berg") }        await clock.advance(by: .milliseconds(300))        // what .task(id:) does when the text changes        first.cancel()        let second = Task { await weather.update(for: "Bergen") }        await clock.advance(by: .milliseconds(500))        await first.value        await second.value        #expect(await requests.cities == ["Bergen"])    }}

/// The planner's weather, with a stand-in for Open-Meteo.
@MainActor
struct PlannerWeatherTests {
    let requests = Requests()

    /// A cache whose `fetch` records the city it was asked about, and answers with a made-up Bergen.
    var cache: WeatherCache {
        let bergen = Weather(place: "Bergen, Testland", temperature: 52, code: 61)
        return WeatherCache(fetch: { [requests] city in
            await requests.record(city)
            return bergen
        })
    }

    @Test func asksOnceTypingPauses() async {
        let weather = PlannerWeather(cache: cache)
        await weather.update(for: "Bergen")
        #expect(await requests.cities == ["Bergen"])
    }

    @Test func nothingBeforeTheWaitIsOver() async {
        let clock = TestClock()
        let weather = PlannerWeather(cache: cache, clock: clock)
        let typing = Task { await weather.update(for: "Bergen") }
        await clock.advance(by: .milliseconds(499))
        #expect(await requests.cities == [])
        await clock.advance(by: .milliseconds(1))
        await typing.value
        #expect(await requests.cities == ["Bergen"])
        #expect(weather.preview?.place == "Bergen, Testland")
    }

    @Test func aNewLetterCancelsTheWait() async {
        let clock = TestClock()
        let weather = PlannerWeather(cache: cache, clock: clock)
        let first = Task { await weather.update(for: "Berg") }
        await clock.advance(by: .milliseconds(300))
        // what .task(id:) does when the text changes
        first.cancel()
        let second = Task { await weather.update(for: "Bergen") }
        await clock.advance(by: .milliseconds(500))
        await first.value
        await second.value
        #expect(await requests.cities == ["Bergen"])
    }
}