Tests for the logic, a picture, and the flow

extension TripFilter {
    /// All, Favorites, and then a filter for each country that has a trip, in the order the trips first name them.
    static func choices(for trips: [Trip]) -> [TripFilter] {
        var countries: [String] = []
        for trip in trips where !countries.contains(trip.country) {
            countries.append(trip.country)
        }
        return [.all, .favorites] + countries.map { TripFilter.country($0) }
    }
}

struct ContentView: View {    @Environment(TripStore.self) private var store    @AppStorage(Settings.showsYearKey) private var showsYear = true    @State private var filter = TripFilter.all    @State private var closings = 0    var body: some View {        ScrollView {            LazyVStack(spacing: 12) {                TripPlanner()                    .environment(\.highlight, .mint)                PhotoStrip(trips: store.trips)                TripSummary(trips: store.trips)                WeatherStrip(cities: store.trips.map(\.city))                if showsYear {                    YearGrid(trips: store.trips)                }                FilterBar(filters: filters, selection: $filter) { trips in                FilterBar(filters: TripFilter.choices(for: store.trips), selection: $filter) { trips in                    store.makeFavorites(trips)                }                    .frame(maxWidth: .infinity, alignment: .leading)                    .padding(.horizontal)                TripControls(closings: $closings)                TripGrid(filter: filter, closings: closings)            }        }        .sensoryFeedback(.success, trigger: store.trips.filter(\.isFavorite).count)    }    /// All, Favorites, and then a filter for each country that has a trip.    private var filters: [TripFilter] {        var countries: [String] = []        for trip in store.trips where !countries.contains(trip.country) {            countries.append(trip.country)        }        return [.all, .favorites] + countries.map { TripFilter.country($0) }    }}

struct ContentView: View {
    @Environment(TripStore.self) private var store
    @AppStorage(Settings.showsYearKey) private var showsYear = true
    @State private var filter = TripFilter.all
    @State private var closings = 0

    var body: some View {
        ScrollView {
            LazyVStack(spacing: 12) {
                TripPlanner()
                    .environment(\.highlight, .mint)
                PhotoStrip(trips: store.trips)
                TripSummary(trips: store.trips)
                WeatherStrip(cities: store.trips.map(\.city))
                if showsYear {
                    YearGrid(trips: store.trips)
                }
                FilterBar(filters: TripFilter.choices(for: store.trips), selection: $filter) { trips in
                    store.makeFavorites(trips)
                }
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(.horizontal)
                TripControls(closings: $closings)
                TripGrid(filter: filter, closings: closings)
            }
        }
        .sensoryFeedback(.success, trigger: store.trips.filter(\.isFavorite).count)
    }
}

import Testing
@testable import Trips

/// The Overview's filters: logic that used to live inside a view, where no test could reach it.
@MainActor
struct FilterTests {
    @Test func oneChoicePerCountry() {
        let trips = [Trip.seattle, .vancouver, .atacama, .seattle]
        #expect(TripFilter.choices(for: trips) == [.all, .favorites, .country("United States"), .country("Canada"), .country("Chile")])
    }

    @Test func noTripsStillOffersAllAndFavorites() {
        #expect(TripFilter.choices(for: []) == [.all, .favorites])
    }

    @Test(arguments: [TripFilter.all, .favorites, .country("Chile")])
    func includesAtacama(filter: TripFilter) {
        #expect(filter.includes(.atacama))
    }

    @Test(arguments: [TripFilter.country("Canada"), .country("United States")])
    func leavesOutAtacama(filter: TripFilter) {
        #expect(!filter.includes(.atacama))
    }
}

import Testing
import SwiftUI
import UIKit
@testable import Trips

/// A trip's row drawn by a test, at a size the canvas is rarely set to.
@MainActor
struct TripRowPictures {
    @Test func atTheLargestTextSize() throws {
        let row = TripRow(trip: .seattle)
            .dynamicTypeSize(.accessibility5)
            .padding()
            .frame(width: 390)
            .background(.white)
        let renderer = ImageRenderer(content: row)
        renderer.scale = 3
        let picture = try #require(renderer.uiImage)
        Attachment.record(picture, named: "trip-row-largest-text", as: .png)
        #expect(picture.size.width == 390)
    }
}

extension TripStore {
    /// A store that starts with these trips, whatever was saved — for a UI test that needs to know where it begins.
    convenience init(trips: [Trip]) {
        self.init()
        self.trips = trips
    }
}

import SwiftUIimport SwiftData@mainstruct TripsApp: App {    @Environment(\.scenePhase) private var scenePhase    @State private var store = TripStore()    /// The saved trips — or, when a UI test asks for a fresh start, the samples.    @State private var store = ProcessInfo.processInfo.arguments.contains("-fresh-start")        ? TripStore(trips: Trip.samples) : TripStore()    @State private var settings = Settings()    @AppStorage(Settings.highlightKey) private var highlight = Settings.Highlight.yellow    var body: some Scene {        WindowGroup {            MainTabs()            .environment(store)            .environment(settings)            .environment(\.highlight, highlight.color)            .task {                // On the main actor, as the store is: `.task` and the closure take                // the actor of the code they are written in. Each value is a [Trip],                // handed on because a trip is Sendable.                for await _ in Observations({ store.trips }) {                    store.save()                }            }        }        .modelContainer(for: PackingItem.self)        .onChange(of: scenePhase) { _, new in            if new == .background {                store.save()            }        }    }}

import SwiftUI
import SwiftData

@main
struct TripsApp: App {
    @Environment(\.scenePhase) private var scenePhase
    /// The saved trips — or, when a UI test asks for a fresh start, the samples.
    @State private var store = ProcessInfo.processInfo.arguments.contains("-fresh-start")
        ? TripStore(trips: Trip.samples) : TripStore()
    @State private var settings = Settings()
    @AppStorage(Settings.highlightKey) private var highlight = Settings.Highlight.yellow

    var body: some Scene {
        WindowGroup {
            MainTabs()
            .environment(store)
            .environment(settings)
            .environment(\.highlight, highlight.color)
            .task {
                // On the main actor, as the store is: `.task` and the closure take
                // the actor of the code they are written in. Each value is a [Trip],
                // handed on because a trip is Sendable.
                for await _ in Observations({ store.trips }) {
                    store.save()
                }
            }
        }
        .modelContainer(for: PackingItem.self)
        .onChange(of: scenePhase) { _, new in
            if new == .background {
                store.save()
            }
        }
    }
}

import XCTest

final class TripsUITests: XCTestCase {

    override func setUpWithError() throws {
        // Put setup code here. This method is called before the invocation of each test method in the class.

        // In UI tests it is usually best to stop immediately when a failure occurs.
        continueAfterFailure = false

        // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.
    }

    override func tearDownWithError() throws {
        // Put teardown code here. This method is called after the invocation of each test method in the class.
    }

    @MainActor
    func testExample() throws {
        // UI tests must launch the application that they test.
        let app = XCUIApplication()
        app.launch()

        // Use XCTAssert and related functions to verify your tests produce the correct results.
        // XCUIAutomation Documentation
        // https://developer.apple.com/documentation/xcuiautomation
    }

    @MainActor
    func testLaunchPerformance() throws {
        // This measures how long it takes to launch your application.
        measure(metrics: [XCTApplicationLaunchMetric()]) {
            XCUIApplication().launch()
        }
    }
}

import XCTestfinal class TripsUITests: XCTestCase {    override func setUpWithError() throws {        // Put setup code here. This method is called before the invocation of each test method in the class.        // In UI tests it is usually best to stop immediately when a failure occurs.        // In a UI test each step depends on the one before: stop at the first failure.        continueAfterFailure = false        // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.    }    override func tearDownWithError() throws {        // Put teardown code here. This method is called after the invocation of each test method in the class.    }    @MainActor    func testExample() throws {        // UI tests must launch the application that they test.    func testPlanningATripAddsItToTheList() throws {        let app = XCUIApplication()        // the samples, whatever an earlier run saved        app.launchArguments = ["-fresh-start"]        app.launch()        // Use XCTAssert and related functions to verify your tests produce the correct results.        // XCUIAutomation Documentation        // https://developer.apple.com/documentation/xcuiautomation    }        // the app remembers its tab: do not assume one        app.tabBars.buttons["Overview"].tap()        app.buttons["Plan a trip"].tap()        let city = app.textFields["City"]        city.tap()        city.typeText("Lisbon")        let country = app.textFields["Country"]        country.tap()        country.typeText("Portugal")        app.buttons["Add to my trips"].tap()    @MainActor    func testLaunchPerformance() throws {        // This measures how long it takes to launch your application.        measure(metrics: [XCTApplicationLaunchMetric()]) {            XCUIApplication().launch()        }        app.tabBars.buttons["Trips"].tap()        XCTAssertTrue(app.staticTexts["Lisbon"].waitForExistence(timeout: 2))        let screenshot = XCTAttachment(screenshot: app.screenshot())        screenshot.lifetime = .keepAlways        add(screenshot)    }}

import XCTest

final class TripsUITests: XCTestCase {

    override func setUpWithError() throws {
        // In a UI test each step depends on the one before: stop at the first failure.
        continueAfterFailure = false
    }

    @MainActor
    func testPlanningATripAddsItToTheList() throws {
        let app = XCUIApplication()
        // the samples, whatever an earlier run saved
        app.launchArguments = ["-fresh-start"]
        app.launch()

        // the app remembers its tab: do not assume one
        app.tabBars.buttons["Overview"].tap()
        app.buttons["Plan a trip"].tap()
        let city = app.textFields["City"]
        city.tap()
        city.typeText("Lisbon")
        let country = app.textFields["Country"]
        country.tap()
        country.typeText("Portugal")
        app.buttons["Add to my trips"].tap()

        app.tabBars.buttons["Trips"].tap()
        XCTAssertTrue(app.staticTexts["Lisbon"].waitForExistence(timeout: 2))

        let screenshot = XCTAttachment(screenshot: app.screenshot())
        screenshot.lifetime = .keepAlways
        add(screenshot)
    }
}