swift-code-reviewer-skill 1.1.1 → 1.2.1

package/skills/swift-testing/references/migration-xctest.md

@@ -0,0 +1,301 @@
+# Migration from XCTest to Swift Testing
+
+How to migrate existing XCTest tests to Swift Testing.
+
+## Quick Reference
+
+| XCTest | Swift Testing |
+|--------|---------------|
+| `class FooTests: XCTestCase` | `@Suite struct FooTests` |
+| `func testFoo()` | `@Test func foo()` |
+| `XCTAssertEqual(a, b)` | `#expect(a == b)` |
+| `XCTAssertTrue(x)` | `#expect(x)` |
+| `XCTAssertFalse(x)` | `#expect(!x)` |
+| `XCTAssertNil(x)` | `#expect(x == nil)` |
+| `XCTAssertNotNil(x)` | `#expect(x != nil)` or `try #require(x)` |
+| `XCTAssertThrowsError` | `#expect(throws:)` |
+| `XCTFail("message")` | `Issue.record("message")` |
+| `XCTSkip("reason")` | Test trait `.disabled("reason")` |
+| `setUp()` | `init()` |
+| `tearDown()` | `deinit` |
+
+## Basic Test Migration
+
+### Before (XCTest)
+
+```swift
+import XCTest
+
+class UserTests: XCTestCase {
+    func testUserCreation() {
+        let user = User(name: "Alice")
+        XCTAssertEqual(user.name, "Alice")
+        XCTAssertNotNil(user.id)
+    }
+}
+```
+
+### After (Swift Testing)
+
+```swift
+import Testing
+
+@Suite struct UserTests {
+    @Test func userCreation() throws {
+        let user = User(name: "Alice")
+        #expect(user.name == "Alice")
+        let id = try #require(user.id)
+        #expect(!id.isEmpty)
+    }
+}
+```
+
+## Assertion Migration
+
+### Equality
+
+```swift
+// XCTest
+XCTAssertEqual(result, expected)
+XCTAssertEqual(result, expected, "Custom message")
+
+// Swift Testing
+#expect(result == expected)
+#expect(result == expected, "Custom message")
+```
+
+### Boolean
+
+```swift
+// XCTest
+XCTAssertTrue(condition)
+XCTAssertFalse(condition)
+
+// Swift Testing
+#expect(condition)
+#expect(!condition)
+```
+
+### Nil Checks
+
+```swift
+// XCTest
+XCTAssertNil(optional)
+XCTAssertNotNil(optional)
+
+// Swift Testing
+#expect(optional == nil)
+#expect(optional != nil)
+
+// Or use #require for unwrapping
+let value = try #require(optional)
+```
+
+### Error Testing
+
+```swift
+// XCTest
+XCTAssertThrowsError(try riskyOperation()) { error in
+    XCTAssertEqual(error as? MyError, .specific)
+}
+
+XCTAssertNoThrow(try safeOperation())
+
+// Swift Testing
+#expect(throws: MyError.specific) {
+    try riskyOperation()
+}
+
+#expect(throws: Never.self) {
+    try safeOperation()
+}
+```
+
+## Setup and Teardown
+
+### Before (XCTest)
+
+```swift
+class DatabaseTests: XCTestCase {
+    var database: Database!
+
+    override func setUp() {
+        super.setUp()
+        database = Database.inMemory()
+    }
+
+    override func tearDown() {
+        database.close()
+        database = nil
+        super.tearDown()
+    }
+
+    func testInsert() {
+        database.insert(record)
+    }
+}
+```
+
+### After (Swift Testing)
+
+```swift
+@Suite struct DatabaseTests {
+    let database: Database
+
+    init() throws {
+        database = try Database.inMemory()
+    }
+
+    @Test func insert() {
+        database.insert(record)
+    }
+}
+```
+
+## Async Tests
+
+### Before (XCTest)
+
+```swift
+func testAsyncFetch() async throws {
+    let result = try await service.fetch()
+    XCTAssertFalse(result.isEmpty)
+}
+
+// Or with expectations
+func testAsyncWithExpectation() {
+    let expectation = XCTestExpectation(description: "Fetch")
+
+    service.fetch { result in
+        XCTAssertNotNil(result)
+        expectation.fulfill()
+    }
+
+    wait(for: [expectation], timeout: 5)
+}
+```
+
+### After (Swift Testing)
+
+```swift
+@Test func asyncFetch() async throws {
+    let result = try await service.fetch()
+    #expect(!result.isEmpty)
+}
+
+// For callbacks, use confirmation
+@Test func asyncWithConfirmation() async {
+    await confirmation { confirm in
+        service.fetch { result in
+            #expect(result != nil)
+            confirm()
+        }
+    }
+}
+```
+
+## Parameterized Tests
+
+### Before (XCTest)
+
+```swift
+func testValidEmails() {
+    let validEmails = ["a@b.com", "test@example.org"]
+    for email in validEmails {
+        XCTAssertTrue(EmailValidator.isValid(email), "\(email) should be valid")
+    }
+}
+```
+
+### After (Swift Testing)
+
+```swift
+@Test(arguments: ["a@b.com", "test@example.org"])
+func validEmail(email: String) {
+    #expect(EmailValidator.isValid(email))
+}
+```
+
+## Skipping Tests
+
+### Before (XCTest)
+
+```swift
+func testPlatformSpecific() throws {
+    #if !os(iOS)
+    throw XCTSkip("iOS only")
+    #endif
+    // Test code
+}
+```
+
+### After (Swift Testing)
+
+```swift
+@Test(.enabled(if: Platform.isIOS, "iOS only"))
+func platformSpecific() {
+    // Test code
+}
+
+// Or
+@Test(.disabled("Not implemented yet"))
+func futureFeature() { }
+```
+
+## Test Organization
+
+### Before (XCTest)
+
+```swift
+class CartTests: XCTestCase {
+    // Tests grouped by comments
+    // MARK: - Adding Items
+    func testAddSingleItem() { }
+    func testAddMultipleItems() { }
+
+    // MARK: - Removing Items
+    func testRemoveItem() { }
+}
+```
+
+### After (Swift Testing)
+
+```swift
+@Suite("Cart")
+struct CartTests {
+    @Suite("Adding Items")
+    struct AddingTests {
+        @Test func singleItem() { }
+        @Test func multipleItems() { }
+    }
+
+    @Suite("Removing Items")
+    struct RemovingTests {
+        @Test func removeItem() { }
+    }
+}
+```
+
+## Migration Strategy
+
+1. **Start with leaf tests**: Tests that don't depend on XCTest infrastructure
+2. **Migrate one file at a time**: Keep changes reviewable
+3. **Run both simultaneously**: XCTest and Swift Testing can coexist
+4. **Update CI configuration**: Ensure both are run during migration
+5. **Remove XCTest after full migration**: Clean up imports and dependencies
+
+## Coexistence
+
+You can have both frameworks in the same project:
+
+```swift
+// XCTest (existing)
+import XCTest
+class OldTests: XCTestCase { }
+
+// Swift Testing (new)
+import Testing
+@Suite struct NewTests { }
+```
+
+Both will be discovered and run by `swift test`.

package/skills/swift-testing/references/parameterized-tests.md

@@ -0,0 +1,171 @@
+# Parameterized Tests
+
+Test multiple inputs with a single test function.
+
+## Basic Parameterization
+
+```swift
+@Test(arguments: [1, 2, 3, 4, 5])
+func isPositive(number: Int) {
+    #expect(number > 0)
+}
+```
+
+## Multiple Arguments
+
+### Using zip (Paired)
+
+```swift
+@Test(arguments: zip(
+    ["hello", "world", "test"],
+    [5, 5, 4]
+))
+func stringLength(string: String, expectedLength: Int) {
+    #expect(string.count == expectedLength)
+}
+```
+
+### Cartesian Product (All Combinations)
+
+```swift
+@Test(arguments: [1, 2], ["a", "b"])
+func combinations(number: Int, letter: String) {
+    // Runs 4 times: (1,a), (1,b), (2,a), (2,b)
+    #expect(!"\(number)\(letter)".isEmpty)
+}
+```
+
+## Custom Test Cases
+
+```swift
+struct ValidationTestCase {
+    let input: String
+    let isValid: Bool
+    let description: String
+}
+
+extension ValidationTestCase: CustomTestStringConvertible {
+    var testDescription: String { description }
+}
+
+let validationCases = [
+    ValidationTestCase(input: "valid@email.com", isValid: true, description: "valid email"),
+    ValidationTestCase(input: "invalid", isValid: false, description: "missing @"),
+    ValidationTestCase(input: "", isValid: false, description: "empty string"),
+]
+
+@Test(arguments: validationCases)
+func validateEmail(testCase: ValidationTestCase) {
+    let result = EmailValidator.validate(testCase.input)
+    #expect(result == testCase.isValid)
+}
+```
+
+## Enum Cases
+
+```swift
+enum Environment: CaseIterable {
+    case development, staging, production
+}
+
+@Test(arguments: Environment.allCases)
+func configurationLoads(environment: Environment) {
+    let config = Configuration(environment: environment)
+    #expect(config.isValid)
+}
+```
+
+## Ranges
+
+```swift
+@Test(arguments: 1...100)
+func withinRange(value: Int) {
+    #expect(value >= 1 && value <= 100)
+}
+```
+
+## Collection of Tuples
+
+```swift
+@Test(arguments: [
+    ("2024-01-15", true),
+    ("invalid", false),
+    ("2024-13-45", false),
+])
+func dateValidation(dateString: String, shouldBeValid: Bool) {
+    let isValid = DateValidator.validate(dateString)
+    #expect(isValid == shouldBeValid)
+}
+```
+
+## Avoiding Cartesian Explosion
+
+Be careful with multiple argument lists:
+
+```swift
+// WARNING: This runs 1000 times (10 x 10 x 10)
+@Test(arguments: 1...10, 1...10, 1...10)
+func tooManyTests(a: Int, b: Int, c: Int) { }
+
+// BETTER: Use zip for paired testing
+@Test(arguments: zip(zip(inputs1, inputs2), expectedResults))
+func pairedTest(inputs: ((Int, Int), Int)) { }
+```
+
+## Filtering Arguments
+
+```swift
+let testCases = (1...100).filter { $0 % 10 == 0 }
+
+@Test(arguments: testCases)
+func multiplesOfTen(value: Int) {
+    #expect(value % 10 == 0)
+}
+```
+
+## Complex Test Data
+
+```swift
+struct APITestCase: Sendable {
+    let endpoint: String
+    let method: HTTPMethod
+    let expectedStatus: Int
+    let body: Data?
+
+    static let cases: [APITestCase] = [
+        APITestCase(endpoint: "/users", method: .get, expectedStatus: 200, body: nil),
+        APITestCase(endpoint: "/users", method: .post, expectedStatus: 201, body: validUserData),
+        APITestCase(endpoint: "/users/999", method: .get, expectedStatus: 404, body: nil),
+    ]
+}
+
+@Test(arguments: APITestCase.cases)
+func apiEndpoint(testCase: APITestCase) async throws {
+    let response = try await client.request(
+        endpoint: testCase.endpoint,
+        method: testCase.method,
+        body: testCase.body
+    )
+    #expect(response.statusCode == testCase.expectedStatus)
+}
+```
+
+## Best Practices
+
+1. **Keep test cases focused**: Each should test one thing
+2. **Use descriptive names**: Implement `CustomTestStringConvertible`
+3. **Avoid Cartesian products**: Use zip for paired data
+4. **Group related cases**: Create structs for complex scenarios
+5. **Make test data Sendable**: Required for parallel execution
+
+```swift
+// GOOD: Clear, paired test cases
+@Test(arguments: zip(["a", "ab", "abc"], [1, 2, 3]))
+func stringLength(string: String, expected: Int) {
+    #expect(string.count == expected)
+}
+
+// BAD: Cartesian product, unclear intent
+@Test(arguments: ["a", "ab", "abc"], [1, 2, 3])
+func unclearTest(string: String, number: Int) { }
+```

package/skills/swift-testing/references/snapshot-testing.md

@@ -0,0 +1,201 @@
+# Snapshot Testing
+
+Snapshot testing catches visual regressions by comparing rendered UI against recorded baselines.
+
+## Setup
+
+Use [SnapshotTesting](https://github.com/pointfreeco/swift-snapshot-testing):
+
+```swift
+// Package.swift
+.package(url: "https://github.com/pointfreeco/swift-snapshot-testing", from: "1.15.0")
+```
+
+## Basic Usage
+
+```swift
+import SnapshotTesting
+import Testing
+import SwiftUI
+@testable import DesignSystem
+
+@Suite("PRCelebrationToast Snapshots")
+struct PRCelebrationToastSnapshotTests {
+
+    @Test("renders correctly for new PR")
+    func newPRLayout() {
+        let record = PersonalRecord.fixture(liftType: .snatch, weight: 120.0)
+        let toast = PRCelebrationToast(
+            newPR: record,
+            quote: "New personal best!"
+        )
+
+        assertSnapshot(
+            of: toast,
+            as: .image(layout: .device(config: .iPhone15Pro))
+        )
+    }
+}
+```
+
+## Parameterized Snapshots
+
+Test multiple configurations:
+
+```swift
+@Test("renders correctly for different lift types", arguments: LiftType.allCases)
+func differentLiftTypes(liftType: LiftType) {
+    let record = PersonalRecord.fixture(liftType: liftType, weight: 100.0)
+    let toast = PRCelebrationToast(newPR: record, quote: "Great lift!")
+
+    assertSnapshot(
+        of: toast,
+        as: .image(layout: .sizeThatFits),
+        named: "\(liftType)"
+    )
+}
+```
+
+## Layout Options
+
+```swift
+// Device-specific
+.image(layout: .device(config: .iPhone15Pro))
+.image(layout: .device(config: .iPadPro12_9))
+
+// Size that fits content
+.image(layout: .sizeThatFits)
+
+// Fixed size
+.image(layout: .fixed(width: 300, height: 200))
+```
+
+## Recording Mode
+
+First run records baselines. To re-record:
+
+```swift
+// Re-record all snapshots in this test
+assertSnapshot(of: view, as: .image, record: true)
+```
+
+Or use environment variable:
+
+```bash
+SNAPSHOT_TESTING_RECORD=1 swift test
+```
+
+## Multiple Device Sizes
+
+```swift
+@Test("adapts to different screen sizes")
+func multipleDevices() {
+    let view = SettingsScreen()
+
+    let devices: [(String, ViewImageConfig)] = [
+        ("iPhoneSE", .iPhoneSe),
+        ("iPhone15Pro", .iPhone15Pro),
+        ("iPadPro", .iPadPro12_9),
+    ]
+
+    for (name, config) in devices {
+        assertSnapshot(
+            of: view,
+            as: .image(layout: .device(config: config)),
+            named: name
+        )
+    }
+}
+```
+
+## Dark Mode Testing
+
+```swift
+@Test("renders correctly in dark mode")
+func darkModeAppearance() {
+    let view = SettingsRow(title: "Notifications", isEnabled: true)
+        .preferredColorScheme(.dark)
+
+    assertSnapshot(
+        of: view,
+        as: .image(layout: .sizeThatFits),
+        named: "dark"
+    )
+}
+```
+
+## Accessibility Testing
+
+```swift
+@Test("supports Dynamic Type")
+func dynamicTypeSupport() {
+    let sizes: [ContentSizeCategory] = [.small, .large, .accessibilityExtraExtraLarge]
+
+    for size in sizes {
+        let view = SettingsRow(title: "Notifications", isEnabled: true)
+            .environment(\.sizeCategory, size)
+
+        assertSnapshot(
+            of: view,
+            as: .image(layout: .sizeThatFits),
+            named: "\(size)"
+        )
+    }
+}
+```
+
+## Best Practices
+
+### Consistency
+
+- **Same simulator**: Record all snapshots on the same device/simulator
+- **Match CI**: Use same configuration as CI pipeline
+- **Commit baselines**: Store reference images in version control
+
+### Organization
+
+```
+Tests/
+└── DesignSystemTests/
+    ├── Snapshots/
+    │   ├── PRCelebrationToastSnapshotTests.swift
+    │   └── __Snapshots__/           # Generated baseline images
+    │       └── PRCelebrationToastSnapshotTests/
+    │           ├── newPRLayout.png
+    │           └── differentLiftTypes-snatch.png
+```
+
+### Review Process
+
+1. Run tests locally before PR
+2. Review snapshot diffs carefully
+3. Re-record intentional changes
+4. Commit new baselines with code changes
+
+## Troubleshooting
+
+### Flaky Tests
+
+```swift
+// Add precision tolerance for anti-aliasing differences
+assertSnapshot(
+    of: view,
+    as: .image(precision: 0.99)
+)
+```
+
+### CI Failures
+
+- Ensure CI uses same simulator version
+- Consider using `perceptualPrecision` for minor rendering differences
+- Document expected simulator in README
+
+### Large Files
+
+```swift
+// Use smaller scale for large views
+assertSnapshot(
+    of: view,
+    as: .image(layout: .fixed(width: 375, height: 812), scale: 1)
+)
+```