iOS Test Automation with Claude Code — Where XCTest, Swift Testing, and XCUITest Each Belong

# MyApp CLAUDE.md
 
## Architecture
- Pattern: MVVM + Coordinator
- Async: Swift Concurrency (async/await + Actor)
- DI: Custom ServiceLocator container
 
## Testing Strategy
- Unit Tests: Swift Testing framework preferred (Xcode 16+)
- Integration Tests: XCTest for Repository to ViewModel boundaries
- UI Tests: XCUITest for Critical Path only (login, purchase flows)
 
## Test File Naming
- Unit: `{TargetClass}Tests.swift`
- Integration: `{Feature}IntegrationTests.swift`
- UI: `{Flow}UITests.swift`
 
## Mocking Approach
- Protocol-based mocks (no Mockolo)
- All test doubles in Mocks/ folder
 
## Prohibited Patterns
- No #if DEBUG blocks in production code
- No sleep() for async waiting (use XCTestExpectation or async/await)

// Swift Testing ViewModel example
import Testing
@testable import MyApp
 
@Suite("ArticleViewModel Tests")
struct ArticleViewModelTests {
 
    let mockRepository: MockArticleRepository
    let viewModel: ArticleViewModel
 
    init() {
        mockRepository = MockArticleRepository()
        viewModel = ArticleViewModel(repository: mockRepository)
    }
 
    @Test("Fetches articles on initial load")
    func fetchArticlesOnLoad() async throws {
        // Arrange
        let expected = [Article.stub(id: "1"), Article.stub(id: "2")]
        mockRepository.stubbedArticles = expected
 
        // Act
        await viewModel.loadArticles()
 
        // Assert
        #expect(viewModel.articles.count == 2)
        #expect(viewModel.articles.first?.id == "1")
        #expect(!viewModel.isLoading)
    }
 
    @Test("Shows error message on network failure")
    func showErrorOnNetworkFailure() async throws {
        mockRepository.shouldThrowError = true
        await viewModel.loadArticles()
        #expect(viewModel.errorMessage != nil)
        #expect(viewModel.articles.isEmpty)
    }
 
    // Parameterized Test
    @Test("Category filtering returns correct count", arguments: [
        ("tech", 3),
        ("design", 2),
        ("business", 0)
    ])
    func filterByCategory(category: String, expectedCount: Int) async throws {
        mockRepository.stubbedArticles = Article.stubCollection()
        await viewModel.loadArticles()
        viewModel.filterByCategory(category)
        #expect(viewModel.filteredArticles.count == expectedCount)
    }
}

claude "Read Sources/Features/Article/ArticleViewModel.swift and generate
unit tests using Swift Testing (import Testing) as ArticleViewModelTests.swift.
- Cover happy path and error cases for all public methods
- Use parameterized tests where applicable
- Match mock patterns in Sources/Tests/Mocks/"

# Identify migration candidates
claude "Analyze all XCTest files under Tests/ and rank them
by migration complexity (simple to complex).
Factors: setUp/tearDown complexity, async usage, external dependencies"

claude "Migrate Tests/Unit/UserServiceTests.swift from XCTest to Swift Testing.
Conversion rules:
- XCTAssertEqual → #expect(a == b)
- XCTAssertNil → #expect(value == nil)
- setUp() → init()
- tearDown() → deinit (make the suite a final class instead of a struct if you need deinit)
- Async: XCTestExpectation → async/await
Back up the original and overwrite with the converted version"

claude "Create XCUITest files for these Critical Path flows:
1. Email + password login flow
2. Product detail → Add to cart → Purchase complete flow
Use accessibility IDs for all element selectors to resist UI changes"

// XCUITest: Login Flow
import XCTest
 
final class LoginFlowUITests: XCTestCase {
 
    private var app: XCUIApplication!
 
    override func setUpWithError() throws {
        continueAfterFailure = false
        app = XCUIApplication()
        app.launchEnvironment["USE_MOCK_SERVER"] = "true"
        app.launchEnvironment["RESET_STATE"] = "true"
        app.launch()
    }
 
    func testLoginWithValidCredentials() throws {
        let loginButton = app.buttons["nav_login_button"]
        XCTAssertTrue(loginButton.waitForExistence(timeout: 5))
        loginButton.tap()
 
        let emailField = app.textFields["login_email_field"]
        XCTAssertTrue(emailField.waitForExistence(timeout: 3))
        emailField.tap()
        emailField.typeText("test@example.com")
 
        let passwordField = app.secureTextFields["login_password_field"]
        passwordField.tap()
        passwordField.typeText("TestPassword123!")
 
        app.buttons["login_submit_button"].tap()
 
        let homeNav = app.navigationBars["home_nav_bar"]
        XCTAssertTrue(homeNav.waitForExistence(timeout: 10),
                      "Home screen should appear after successful login")
    }
 
    func testLoginWithInvalidPassword() throws {
        app.buttons["nav_login_button"].tap()
        app.textFields["login_email_field"].tap()
        app.textFields["login_email_field"].typeText("test@example.com")
        app.secureTextFields["login_password_field"].tap()
        app.secureTextFields["login_password_field"].typeText("wrongpassword")
        app.buttons["login_submit_button"].tap()
 
        let errorMessage = app.staticTexts["login_error_message"]
        XCTAssertTrue(errorMessage.waitForExistence(timeout: 5))
    }
}

claude "Add accessibility IDs to all interactive elements in Sources/Features/Login/
Naming convention: {screen}_{elementType}_{name} e.g. login_email_field
Update files in place and list all IDs added"

xcodebuild test \
  -project MyApp.xcodeproj \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  -enableCodeCoverage YES \
  -resultBundlePath ./TestResults.xcresult
 
xcrun xccov view --report --json TestResults.xcresult > coverage.json

claude "Analyze coverage.json and list files below 60% coverage.
For each file, suggest specific test cases for uncovered code paths.
Prioritize files containing business logic (ViewModel, Service, Repository)"

#!/bin/bash
# scripts/check_coverage.sh
THRESHOLD=80
COVERAGE=$(xcrun xccov view --report --json TestResults.xcresult | \
  python3 -c "import json,sys; d=json.load(sys.stdin); \
  print(round(d['lineCoverage'] * 100, 1))")
 
echo "Current coverage: ${COVERAGE}%"
 
if (( $(echo "$COVERAGE < $THRESHOLD" | bc -l) )); then
  echo "❌ Coverage ${COVERAGE}% is below threshold ${THRESHOLD}%"
  exit 1
fi
 
echo "✅ Coverage check passed"

claude "Create ci_post_xcodebuild.sh for Xcode Cloud with:
- Slack notification on failure (via SLACK_WEBHOOK_URL env var)
- Coverage report written as text under the derived data path"

#!/bin/sh
# ci_post_xcodebuild.sh
set -e
 
if [ "$CI_XCODEBUILD_EXIT_CODE" -ne 0 ]; then
    echo "❌ Build or tests failed"
    if [ -n "$SLACK_WEBHOOK_URL" ]; then
        curl -s -X POST "$SLACK_WEBHOOK_URL" \
            -H 'Content-type: application/json' \
            --data "{
                \"text\": \"❌ *$CI_WORKFLOW_NAME* failed on branch \`$CI_BRANCH\`\"
            }"
    fi
    exit 1
fi
 
echo "✅ All tests passed"
 
if [ -d "$CI_RESULT_BUNDLE_PATH" ]; then
    xcrun xccov view --report "$CI_RESULT_BUNDLE_PATH" \
      > "$CI_DERIVED_DATA_PATH/coverage_report.txt"
    echo "Coverage report saved"
fi

# .github/workflows/ios-tests.yml
name: iOS Tests
on:
  pull_request:
    branches: [main, develop]
 
jobs:
  test:
    runs-on: macos-15
    steps:
      - uses: actions/checkout@v4
      - name: Select Xcode
        run: sudo xcode-select -s /Applications/Xcode_16.3.app
      - name: Run Tests
        run: |
          set -o pipefail
          xcodebuild test \
            -project MyApp.xcodeproj \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 16,OS=18.4' \
            -enableCodeCoverage YES \
            -resultBundlePath ./TestResults.xcresult \
            | xcbeautify
      - name: Coverage Check
        run: bash scripts/check_coverage.sh
      - name: Upload Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: TestResults.xcresult

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/xctest-feedback.sh"
          }
        ]
      }
    ]
  }
}

#!/bin/bash
# .claude/hooks/xctest-feedback.sh
# Called on PostToolUse(Bash); returns only xcodebuild test failures to Claude
set -u
INPUT="$(cat)"
CMD="$(printf '%s' "$INPUT" | jq -r '.tool_input.command // ""')"
 
# Ignore every Bash call that is not a test run
case "$CMD" in
  *xcodebuild*test*) ;;
  *) exit 0 ;;
esac
 
# tool_response may change shape: join stdout/stderr when present, otherwise stringify it
OUT="$(printf '%s' "$INPUT" | jq -r '
  .tool_response
  | if type == "object" then ([.stdout, .stderr] | map(select(. != null)) | join("\n"))
    else tostring end')"
 
COUNT_FILE="${CLAUDE_PROJECT_DIR:-.}/.claude/.xctest_fail_count"
PATTERN='\*\* TEST FAILED \*\*|Test Case .* failed|✘ Test'
 
if printf '%s' "$OUT" | grep -qE "$PATTERN"; then
  N=$(( $(cat "$COUNT_FILE" 2>/dev/null || echo 0) + 1 ))
  echo "$N" > "$COUNT_FILE"
  if [ "$N" -ge 3 ]; then
    echo "Tests have failed ${N} times in a row. Stop fixing and report only the failing test names and your hypothesis." >&2
    rm -f "$COUNT_FILE"
    exit 2
  fi
  {
    echo "Tests are failing (attempt ${N}). Fix the implementation. Do not change test expectations."
    printf '%s' "$OUT" | grep -E "$PATTERN|error:" | head -30
  } >&2
  exit 2
fi
 
rm -f "$COUNT_FILE"
exit 0

import SwiftData
import Testing
@testable import MyApp
 
@Suite("Article Persistence Tests")
struct ArticlePersistenceTests {
 
    var container: ModelContainer
 
    init() throws {
        let config = ModelConfiguration(isStoredInMemoryOnly: true)
        container = try ModelContainer(for: Article.self, configurations: config)
    }
 
    @Test("Full CRUD lifecycle works correctly")
    func articleCRUD() throws {
        let context = ModelContext(container)
 
        // Create
        let article = Article(title: "Test Article", slug: "test-article")
        context.insert(article)
        try context.save()
 
        // Read
        let descriptor = FetchDescriptor<Article>()
        let articles = try context.fetch(descriptor)
        #expect(articles.count == 1)
        #expect(articles.first?.title == "Test Article")
 
        // Update
        articles.first?.title = "Updated Article"
        try context.save()
        let updated = try context.fetch(descriptor)
        #expect(updated.first?.title == "Updated Article")
 
        // Delete
        if let toDelete = updated.first { context.delete(toDelete) }
        try context.save()
        #expect(try context.fetch(descriptor).isEmpty)
    }
}

claude "Read Sources/Models/Article.swift and generate CRUD tests
using an in-memory ModelContainer as ArticlePersistenceTests.swift.
Include tests for the Article → Tag many-to-many relationship"

import XCTest
@testable import MyApp
 
final class ImageProcessingPerformanceTests: XCTestCase {
 
    func testImageFilterPerformance() throws {
        let image = UIImage(
            named: "test_image_2048x2048",
            in: Bundle(for: type(of: self)),
            with: nil
        )!
 
        // Measure both clock time and memory usage
        measure(metrics: [XCTClockMetric(), XCTMemoryMetric()]) {
            _ = ImageProcessor.applyVintageFilter(to: image)
        }
    }
 
    func testArticleListFilterPerformance() throws {
        let articles = Article.generateLargeDataset(count: 1000)
 
        measure {
            let viewModel = ArticleListViewModel(articles: articles)
            viewModel.filter(by: "swift")
        }
    }
}

claude "The image filter in Sources/Services/ImageProcessor.swift seems
slower after the recent refactor. Create a performance test with
XCTest metrics to measure processing time and set a baseline"

// Tests/Builders/ArticleBuilder.swift
@testable import MyApp
 
struct ArticleBuilder {
    private var title: String = "Test Article"
    private var slug: String = "test-article"
    private var category: String = "tech"
    private var isPremium: Bool = false
    private var publishedAt: Date = Date()
 
    func title(_ value: String) -> Self {
        var copy = self; copy.title = value; return copy
    }
    func slug(_ value: String) -> Self {
        var copy = self; copy.slug = value; return copy
    }
    func premium() -> Self {
        var copy = self; copy.isPremium = true; return copy
    }
    func publishedDaysAgo(_ days: Int) -> Self {
        var copy = self
        copy.publishedAt = Calendar.current.date(
            byAdding: .day, value: -days, to: Date()
        )!
        return copy
    }
    func build() -> Article {
        Article(
            title: title, slug: slug,
            category: category, isPremium: isPremium,
            publishedAt: publishedAt
        )
    }
}
 
// Usage in tests: reads almost like plain English
@Test("Only premium articles pass the premium filter")
func filterPremiumArticles() {
    let articles = [
        ArticleBuilder().build(),                           // free
        ArticleBuilder().premium().build(),                 // premium
        ArticleBuilder().premium().title("Another").build() // premium
    ]
    let viewModel = ArticleListViewModel(articles: articles)
    viewModel.showPremiumOnly()
    #expect(viewModel.filteredArticles.count == 2)
}

claude "Generate Builder classes for all SwiftData models in Sources/Models/
Output to Tests/Builders/, using ArticleBuilder as the reference pattern.
Each builder should support all settable fields as fluent setter methods"

# Ask Claude Code to scaffold the entire test structure
claude "Create the folder structure and placeholder test files for MyApp
following the structure in our CLAUDE.md. Generate empty @Suite structs
for each ViewModel and Service in Sources/Features/"

#!/bin/bash
# scripts/export_coverage_trend.sh
DATE=$(date +%Y-%m-%d)
COVERAGE=$(xcrun xccov view --report --json TestResults.xcresult | \
  python3 -c "import json,sys; d=json.load(sys.stdin); \
  print(round(d['lineCoverage'] * 100, 1))")
 
# Append to trend log
echo "$DATE,$COVERAGE" >> coverage_trend.csv
echo "Coverage on $DATE: ${COVERAGE}%"

claude "Read coverage_trend.csv and identify:
1. The overall coverage trend over the past 30 days
2. Any dates where coverage dropped significantly
3. Correlation with release dates in CHANGELOG.md
Generate a brief markdown report"

// ❌ Using sleep to wait
func testAsyncOperation() async throws {
    viewModel.startFetch()
    try await Task.sleep(nanoseconds: 2_000_000_000)
    XCTAssertTrue(viewModel.isLoaded) // flaky
}
 
// ✅ Use confirmation for explicit signaling
@Test func testAsyncOperation() async throws {
    await confirmation("Data loaded") { confirm in
        viewModel.onLoadComplete = { confirm() }
        await viewModel.startFetch()
    }
    #expect(viewModel.isLoaded)
}

// ❌ Accessing actor state without await
@Test func testActorState() async throws {
    let actor = MyActor()
    await actor.performWork()
    XCTAssertEqual(actor.state, .completed) // Isolation violation
}
 
// ✅ Properly await actor property access
@Test func testActorState() async throws {
    let actor = MyActor()
    await actor.performWork()
    let state = await actor.state
    #expect(state == .completed)
}

claude "XCUITest can't find 'login_submit_button'.
Check accessibility ID setup in LoginView.swift and
review waitForExistence timeout settings. Suggest a fix."

claude "I need an ArticleFilter service with the following behavior:
- filterByCategory(category: String) returns only articles matching that category
- filterByLevel(level: Level) returns articles at beginner, intermediate, or advanced
- Combined filters should be AND conditions (category AND level must match)
- Empty results should return an empty array, not throw an error
First, write the Swift Testing tests. Don't write the implementation yet."

claude "Now implement ArticleFilter.swift to make all the tests in
ArticleFilterTests.swift pass. Use a protocol-based design so
the filter logic is injectable in ViewModels."

# Run the specific test suite
xcodebuild test -project MyApp.xcodeproj -scheme MyApp \
  -only-testing MyAppTests/ArticleFilterTests | xcbeautify

// Protocol wrapping an analytics SDK
protocol AnalyticsTracking {
    func track(event: String, parameters: [String: Any])
}
 
// Real implementation
final class FirebaseAnalyticsTracker: AnalyticsTracking {
    func track(event: String, parameters: [String: Any]) {
        // Firebase.Analytics.logEvent(event, parameters: parameters)
    }
}
 
// Test double — records calls without side effects
final class MockAnalyticsTracker: AnalyticsTracking {
    var trackedEvents: [(name: String, params: [String: Any])] = []
 
    func track(event: String, parameters: [String: Any]) {
        trackedEvents.append((name: event, params: parameters))
    }
}
 
// Test
@Test("Article view triggers analytics event")
func articleViewTracksEvent() async throws {
    let mockTracker = MockAnalyticsTracker()
    let viewModel = ArticleViewModel(analytics: mockTracker)
 
    await viewModel.markAsViewed(articleId: "article-123")
 
    #expect(mockTracker.trackedEvents.count == 1)
    #expect(mockTracker.trackedEvents.first?.name == "article_viewed")
    #expect(mockTracker.trackedEvents.first?.params["article_id"] as? String == "article-123")
}

claude "Find all calls to analytics tracking in Sources/ that aren't
covered by tests. List them with their file and line number.
Then suggest how to make each one testable using protocol injection"