Swift Xctest

Swift 6 + XCTest testing patterns for macOS/iOS apps using SwiftData, EventKit, and SwiftUI

Security Scan

This is an instruction-only XCTest / Swift testing pattern skill that is internally consistent with its description and does not request credentials or install anything; exercise normal caution when running tests because xcodebuild executes project code.

Purpose & Capability

The name/description (Swift + XCTest patterns) matches the SKILL.md contents. Examples and run instructions (xcodebuild) are directly related to writing and running tests for Swift/iOS/macOS apps.

Instruction Scope

SKILL.md contains only test patterns, code snippets, and xcodebuild commands — all within the stated purpose. Note: the instructions include running xcodebuild which runs the project's test code (i.e., arbitrary code in the repository under test), so executing those commands on untrusted projects can execute arbitrary code on the host.

Install Mechanism

No install spec and no code files are present (instruction-only). Nothing is downloaded or written to disk by the skill itself.

Credentials

No environment variables, credentials, or config paths are requested. The skill's requirements are minimal and appropriate for its stated purpose.

Persistence & Privilege

always is false and the skill does not request persistent system presence or modify other skills/config. Autonomous invocation is permitted by platform default but is not elevated here.

Assessment

This skill is an instructional guide for writing XCTest tests and appears coherent. Before using it: (1) understand that running the provided xcodebuild commands executes the project's test code — only run tests for code you trust or in an isolated environment (container/VM). (2) Ensure you have Xcode and required SDKs installed; the skill assumes xcodebuild and project schemes exist. (3) Review any third‑party test code you copy into your repo for network calls, shell execution, or other side effects. If you want a deeper review, provide the actual test files or the project the tests will run against so I can check for runtime actions (networking, file I/O, spawned processes).

Swift/XCTest Testing Skill

Expert-level XCTest patterns for Swift 6 macOS/iOS applications. Specialized for SwiftData, EventKit, SwiftUI, and strict concurrency.

When to Use

Use this skill when:

• Writing XCTest for Swift 6 applications
• Testing SwiftData models with in-memory containers
• Testing Swift 6 actors and @MainActor isolation
• Testing EventKit integrations
• Testing SwiftUI views and @Observable ViewModels
• Writing performance tests for macOS apps

Core Principles

1. SwiftData Testing Pattern

import SwiftData
import XCTest

@MainActor
final class ModelTests: XCTestCase {
    var container: ModelContainer!
    var context: ModelContext!

    override func setUp() async throws {
        try await super.setUp()
        // Use in-memory config for isolated tests
        let config = ModelConfiguration(isStoredInMemoryOnly: true)
        container = try ModelContainer(for: YourModel.self, configurations: config)
        context = container.mainContext
    }

    override func tearDown() async throws {
        container = nil
        context = nil
        try await super.tearDown()
    }
}

2. Swift 6 Actor Testing

@MainActor
final class ServiceTests: XCTestCase {
    var service: YourActor!

    override func setUp() async throws {
        try await super.setUp()
        service = YourActor()
    }

    func testActorMethod() async throws {
        // Actor-isolated tests work naturally with async
        let result = try await service.method()
        XCTAssertEqual(result, expected)
    }
}

3. Given-When-Then Pattern

func testFeature() async throws {
    // Given: Set up initial state
    let task = service.createTask(title: "Test")

    // When: Perform action
    task.complete()

    // Then: Verify result
    XCTAssertTrue(task.isCompleted)
}

4. Test Organization

@MainActor
final class FeatureTests: XCTestCase {
    // MARK: - Properties
    // Test dependencies

    // MARK: - Setup & Teardown
    // setUp/tearDown methods

    // MARK: - Unit Tests
    // Isolated tests

    // MARK: - Integration Tests
    // Tests across components

    // MARK: - Edge Cases
    // Boundary and error conditions

    // MARK: - Performance Tests
    // Performance benchmarks
}

Testing Guidelines

SwiftData Models

• Always use ModelConfiguration(isStoredInMemoryOnly: true)
• Mark test classes with @MainActor
• Use try context.save() after mutations
• Verify state with FetchDescriptor and #Predicate

Actors & Concurrency

• Test classes interacting with actors should be @MainActor
• Use await for all actor methods
• Test isolation boundaries with nonisolated tests where appropriate

SwiftData Services

• Use in-memory mode: YourService(inMemory: true)
• Test fetch, create, update, delete operations
• Verify FetchDescriptor queries with predicates

EventKit Mocking

• Mock EKEventStore for isolated testing
• Test permission handling scenarios
• Verify EKReminder to model mapping

SwiftUI Views

• Use @Testable import to access internal types
• Test @Observable ViewModel behavior
• Test state transitions and side effects

Best Practices

1. Isolation: Each test should be independent
2. Async-Safety: Use async/await for all async operations
3. MainActor: Mark SwiftData tests with @MainActor
4. Performance: Use measure blocks for critical paths
5. Readability: Use Given-When-Then comments
6. Organization: Group tests with // MARK: sections

Performance Testing

func testPerformance() async throws {
    measure {
        // Code to measure
        _ = service.process(data: largeDataSet)
    }
}

Common Test Patterns

Batch Query Testing

func testBatchFetchEfficiency() async throws {
    let ids = (0..<100).map { "ID-\($0)" }
    let start = Date()
    let results = service.fetch(by: ids)
    let duration = Date().timeIntervalSince(start)

    XCTAssertEqual(results.count, 100)
    XCTAssertLessThan(duration, 0.5, "Batch fetch should be fast")
}

Predicate Testing

func testPredicateFiltering() async throws {
    let descriptor = FetchDescriptor<IdentityMap>(
        predicate: #Predicate { $0.isDirty == true }
    )
    let results = try context.fetch(descriptor)
    XCTAssertEqual(results.count, expectedCount)
}

Running Tests

# Run all tests
xcodebuild test -scheme YourApp -destination 'platform=macOS'

# Run specific test
xcodebuild test -scheme YourApp -destination 'platform=macOS' \
  -only-testing:'YourAppTests/FeatureTests/testMethod'

# Run with performance output
xcodebuild test -scheme YourApp -destination 'platform=macOS' \
  -resultBundlePath ~/TestResults.xcresult