As a [role], I want to [action], so that [benefit]

Example:
As a user, I want to select my problems during onboarding,
so that I receive relevant notifications.

class ProblemSelectionTests: XCTestCase {

    func testProblemSelection_updatesSelectedProblems() {
        // Test implementation
    }

    func testProblemSelection_requiresAtLeastOneProblem() {
        // Test validation
    }

    func testProblemSelection_persistsToUserDefaults() {
        // Test persistence
    }

    func testProblemSelection_handlesMaxSelection() {
        // Test boundary
    }
}

xcodebuild test -scheme aniccaios -destination 'platform=iOS Simulator,name=iPhone 16'
# Tests should fail - we haven't implemented yet

// Implementation guided by tests
func selectProblem(_ problem: ProblemType) {
    guard selectedProblems.count < maxSelections else { return }
    selectedProblems.append(problem)
    persistSelection()
}

xcodebuild test
# Tests should now pass

xcodebuild test -scheme aniccaios -enableCodeCoverage YES
# Verify 80%+ coverage achieved

import XCTest
@testable import aniccaios

class ProblemTypeTests: XCTestCase {

    func testProblemType_hasDisplayName() {
        let problem = ProblemType.procrastination
        XCTAssertEqual(problem.displayName, "Procrastination")
    }

    func testProblemType_hasIcon() {
        for problem in ProblemType.allCases {
            XCTAssertFalse(problem.icon.isEmpty, "\(problem) should have an icon")
        }
    }

    func testProblemType_hasNudgeMessages() {
        let problem = ProblemType.anxiety
        XCTAssertFalse(problem.nudgeMessages.isEmpty)
    }
}

class OnboardingViewModelTests: XCTestCase {

    var sut: OnboardingViewModel!

    override func setUp() {
        super.setUp()
        sut = OnboardingViewModel()
    }

    override func tearDown() {
        sut = nil
        super.tearDown()
    }

    func testSelectProblem_addsToSelection() {
        sut.selectProblem(.procrastination)

        XCTAssertTrue(sut.selectedProblems.contains(.procrastination))
    }

    func testSelectProblem_togglesIfAlreadySelected() {
        sut.selectProblem(.anxiety)
        sut.selectProblem(.anxiety)

        XCTAssertFalse(sut.selectedProblems.contains(.anxiety))
    }

    func testCanProceed_requiresAtLeastOneProblem() {
        XCTAssertFalse(sut.canProceed)

        sut.selectProblem(.rumination)

        XCTAssertTrue(sut.canProceed)
    }
}

func testFetchData_returnsData() async throws {
    let service = DataService()

    let result = try await service.fetchData()

    XCTAssertFalse(result.isEmpty)
}

func testFetchData_throwsOnNetworkError() async {
    let service = DataService(networkAvailable: false)

    do {
        _ = try await service.fetchData()
        XCTFail("Expected error to be thrown")
    } catch {
        XCTAssertTrue(error is NetworkError)
    }
}

class OnboardingUITests: XCTestCase {

    var app: XCUIApplication!

    override func setUp() {
        continueAfterFailure = false
        app = XCUIApplication()
        app.launchArguments = ["UI_TESTING"]
        app.launch()
    }

    func testOnboarding_completesSuccessfully() {
        // Welcome step
        app.buttons["Get Started"].tap()

        // Value step
        app.buttons["Continue"].tap()

        // Struggles step - select problems
        app.buttons["Procrastination"].tap()
        app.buttons["Anxiety"].tap()
        app.buttons["Continue"].tap()

        // Notification permission
        // (handled by system, skip in UI test)

        // Verify completion
        XCTAssertTrue(app.staticTexts["My Path"].waitForExistence(timeout: 5))
    }

    func testOnboarding_requiresProblemSelection() {
        app.buttons["Get Started"].tap()
        app.buttons["Continue"].tap()

        // Try to continue without selecting
        let continueButton = app.buttons["Continue"]
        XCTAssertFalse(continueButton.isEnabled)
    }
}

// Define protocol
protocol NotificationScheduling {
    func scheduleNotifications(for problems: [ProblemType])
}

// Production implementation
class ProblemNotificationScheduler: NotificationScheduling {
    func scheduleNotifications(for problems: [ProblemType]) {
        // Real implementation
    }
}

// Mock for testing
class MockNotificationScheduler: NotificationScheduling {
    var scheduledProblems: [ProblemType] = []

    func scheduleNotifications(for problems: [ProblemType]) {
        scheduledProblems = problems
    }
}

// Test usage
func testViewModel_schedulesNotifications() {
    let mockScheduler = MockNotificationScheduler()
    let viewModel = OnboardingViewModel(scheduler: mockScheduler)

    viewModel.completeOnboarding()

    XCTAssertEqual(mockScheduler.scheduledProblems, viewModel.selectedProblems)
}

// DON'T test private state
XCTAssertEqual(viewModel.internalCounter, 5)

// DO test what users/consumers see
XCTAssertEqual(viewModel.displayText, "Count: 5")

// DON'T rely on previous test
func testCreatesItem() { /* ... */ }
func testUpdatesSameItem() { /* needs previous test */ }

// DO setup data in each test
func testUpdatesItem() {
    let item = createTestItem()
    // Test logic
}