swift-code-reviewer-skill 1.1.1 → 1.2.1

package/skills/swift-testing/references/test-doubles.md

@@ -0,0 +1,243 @@
+# Test Doubles
+
+Test doubles help isolate the system under test (SUT) from side effects. Terminology from [Martin Fowler's "Mocks Aren't Stubs"](https://martinfowler.com/articles/mocksArentStubs.html).
+
+## State vs Behavior Verification
+
+| Approach | Description | Test Doubles Used |
+|----------|-------------|-------------------|
+| **State Verification** | Assert on final state after action | Stubs, Fakes, Spies |
+| **Behavior Verification** | Verify correct calls to collaborators | Mocks |
+
+**Prefer state verification** - simpler, less brittle tests.
+
+## Dummy
+
+A dummy doesn't do anything - just a placeholder:
+
+```swift
+struct UserServiceDummy: UserServiceProtocol {
+    func login(_ user: User, completion: (Result<Void, Error>) -> Void) {
+        // Does nothing
+    }
+}
+```
+
+## Fake
+
+Working implementation with shortcuts (e.g., in-memory database):
+
+```swift
+final class FavoritesManagerFake: FavoritesManagerProtocol {
+    var favorites: [Movie] = []
+
+    func add(_ movie: Movie) throws {
+        guard !favorites.contains(where: { $0.id == movie.id }) else {
+            throw FavoritesError.alreadyExists
+        }
+        favorites.append(movie)
+    }
+
+    func remove(_ movie: Movie) throws {
+        guard let index = favorites.firstIndex(where: { $0.id == movie.id }) else {
+            throw FavoritesError.notFound
+        }
+        favorites.remove(at: index)
+    }
+}
+```
+
+## Stub
+
+Returns pre-configured values:
+
+```swift
+final class PostsServiceStub: PostsServiceProtocol {
+    var fetchAllResultToBeReturned: Result<[Post], Error> = .success([])
+
+    func fetchAll() async throws -> [Post] {
+        try fetchAllResultToBeReturned.get()
+    }
+}
+
+// Naming: [methodName]ToBeReturned
+```
+
+## Spy
+
+Records calls for verification:
+
+```swift
+final class SafeStorageSpy: SafeStorageProtocol, @unchecked Sendable {
+    private(set) var storeUserDataCalled = false
+    private(set) var userPassed: User?
+    private(set) var storeUserDataCount = 0
+
+    func storeUserData(_ user: User) {
+        storeUserDataCalled = true
+        storeUserDataCount += 1
+        userPassed = user
+    }
+}
+
+// Naming conventions:
+// - Method called: [name]Called (Bool)
+// - Parameter captured: [name]Passed
+// - Call count: [name]Count (Int)
+// - All should be private(set)
+```
+
+## SpyingStub (Most Common)
+
+Combines Stub + Spy - this is what Swift developers usually call "Mock":
+
+```swift
+final class PersonalRecordsRepositorySpyingStub: PersonalRecordsRepositoryProtocol, @unchecked Sendable {
+    // Spy: Captured calls
+    private(set) var savedRecords: [PersonalRecord] = []
+    private(set) var deletedIds: [UUID] = []
+    private(set) var getAllCalled = false
+
+    // Stub: Configurable responses
+    var recordsToReturn: [PersonalRecord] = []
+    var errorToThrow: Error?
+
+    func getAll() async throws -> [PersonalRecord] {
+        getAllCalled = true
+        if let error = errorToThrow { throw error }
+        return recordsToReturn
+    }
+
+    func save(_ record: PersonalRecord) async throws {
+        if let error = errorToThrow { throw error }
+        savedRecords.append(record)
+    }
+
+    func delete(id: UUID) async throws {
+        if let error = errorToThrow { throw error }
+        deletedIds.append(id)
+    }
+}
+
+// Naming: [ProtocolName]SpyingStub
+```
+
+## True Mock (Fowler Definition)
+
+Pre-programmed with expectations, self-verifies:
+
+```swift
+final class UserServiceMock: UserServiceProtocol {
+    struct Expectation: Equatable {
+        let method: String
+        let userId: String?
+    }
+
+    private var expectations: [Expectation] = []
+    private var actualCalls: [Expectation] = []
+    private var returnValues: [String: User] = [:]
+
+    // Setup (before test)
+    func expectGetUser(id: String, returning user: User) {
+        expectations.append(Expectation(method: "getUser", userId: id))
+        returnValues[id] = user
+    }
+
+    // Protocol implementation
+    func getUser(id: String) async throws -> User {
+        let call = Expectation(method: "getUser", userId: id)
+        actualCalls.append(call)
+
+        guard expectations.contains(call) else {
+            fatalError("Unexpected call: getUser(id: \(id))")
+        }
+
+        guard let user = returnValues[id] else {
+            throw UserError.notFound
+        }
+        return user
+    }
+
+    // Verification (after test)
+    func verify() {
+        assert(expectations == actualCalls)
+    }
+}
+
+// Usage
+@Test("fetches user with expected ID")
+func fetchesExpectedUser() async throws {
+    let mock = UserServiceMock()
+    mock.expectGetUser(id: "123", returning: User.fixture())
+
+    await sut.loadProfile(userId: "123")
+
+    mock.verify()  // Self-verifies
+}
+```
+
+**Use true mocks when**:
+- Testing interaction protocols (delegates)
+- Verifying exact call sequences
+- Testing that calls are NOT made
+
+## Failings (Unimplemented)
+
+Fail if unexpectedly called:
+
+```swift
+import XCTestDynamicOverlay
+
+struct FailingNetworkService: NetworkServiceProtocol {
+    func fetchData(from url: URL) async throws -> Data {
+        XCTFail("fetchData(from:) was not expected to be called!")
+        fatalError()
+    }
+}
+```
+
+With swift-dependencies:
+
+```swift
+extension PersonalRecordsRepository: TestDependencyKey {
+    static let testValue = PersonalRecordsRepository(
+        getAll: unimplemented("\(Self.self).getAll"),
+        save: unimplemented("\(Self.self).save")
+    )
+}
+```
+
+## Choosing the Right Double
+
+| Need | Use |
+|------|-----|
+| Fill a parameter | Dummy |
+| Working lightweight implementation | Fake |
+| Control return values | Stub |
+| Verify calls were made | Spy |
+| Both control and verify | SpyingStub |
+| Verify exact interactions | Mock |
+| Catch unexpected usage | Failing |
+
+## Placement
+
+Place test doubles **close to the interface**, not in test targets:
+
+```swift
+// In ModuleName-Interface/Sources/...
+
+public protocol MyServiceProtocol: Sendable {
+    func doSomething() async throws
+}
+
+#if DEBUG
+public final class MyServiceSpyingStub: MyServiceProtocol {
+    // Implementation
+}
+#endif
+```
+
+Benefits:
+- Available to all test targets
+- Lives with the contract it implements
+- Zero production overhead with `#if DEBUG`

package/skills/swift-testing/references/test-organization.md

@@ -0,0 +1,231 @@
+# Test Organization
+
+Organizing tests with suites, tags, and traits in Swift Testing.
+
+## Test Suites
+
+Group related tests:
+
+```swift
+@Suite("User Management")
+struct UserTests {
+    @Test func createUser() { }
+    @Test func deleteUser() { }
+}
+
+@Suite("Authentication")
+struct AuthTests {
+    @Test func login() { }
+    @Test func logout() { }
+}
+```
+
+### Nested Suites
+
+```swift
+@Suite("Shopping Cart")
+struct CartTests {
+    @Suite("Adding Items")
+    struct AddTests {
+        @Test func addSingleItem() { }
+        @Test func addMultipleItems() { }
+    }
+
+    @Suite("Removing Items")
+    struct RemoveTests {
+        @Test func removeSingleItem() { }
+        @Test func clearCart() { }
+    }
+}
+```
+
+## Tags
+
+Categorize tests for selective running:
+
+```swift
+extension Tag {
+    @Tag static var integration: Self
+    @Tag static var slow: Self
+    @Tag static var network: Self
+}
+
+@Test(.tags(.integration))
+func databaseIntegration() { }
+
+@Test(.tags(.slow, .network))
+func networkRequest() { }
+```
+
+### Running Tagged Tests
+
+```bash
+# Run only integration tests
+swift test --filter .tags:integration
+
+# Exclude slow tests
+swift test --skip .tags:slow
+```
+
+## Traits
+
+### Disabled Tests
+
+```swift
+@Test(.disabled("Waiting for API fix"))
+func brokenTest() { }
+
+@Test(.disabled(if: isCI, "Flaky on CI"))
+func sometimesFlaky() { }
+```
+
+### Time Limits
+
+```swift
+@Test(.timeLimit(.minutes(1)))
+func slowTest() async { }
+```
+
+### Bug References
+
+```swift
+@Test(.bug("https://github.com/org/repo/issues/123"))
+func testWithKnownBug() { }
+```
+
+### Custom Traits
+
+```swift
+@Test(.enabled(if: ProcessInfo.processInfo.environment["RUN_SLOW_TESTS"] != nil))
+func conditionalTest() { }
+```
+
+## Setup and Teardown
+
+### Per-Test Setup
+
+```swift
+@Suite struct DatabaseTests {
+    var database: Database
+
+    init() throws {
+        // Runs before each test
+        database = try Database.inMemory()
+    }
+
+    @Test func insertRecord() {
+        // database is fresh for each test
+    }
+}
+```
+
+### Suite-Level Setup
+
+```swift
+@Suite struct ServerTests {
+    static var server: TestServer!
+
+    init() async throws {
+        // Per-test setup
+    }
+
+    @Test func request() async { }
+}
+```
+
+## Test Organization Best Practices
+
+### File Structure
+
+```
+Tests/
+├── UnitTests/
+│   ├── Models/
+│   │   ├── UserTests.swift
+│   │   └── ProductTests.swift
+│   ├── Services/
+│   │   ├── AuthServiceTests.swift
+│   │   └── CartServiceTests.swift
+│   └── Utilities/
+│       └── FormatterTests.swift
+├── IntegrationTests/
+│   ├── DatabaseTests.swift
+│   └── APITests.swift
+└── TestHelpers/
+    ├── Fixtures.swift
+    └── Mocks.swift
+```
+
+### Naming Files
+
+- Name test files after the type they test: `UserTests.swift` for `User`
+- Use `Tests` suffix for test files
+
+### Organizing Within Files
+
+```swift
+@Suite("User")
+struct UserTests {
+    // MARK: - Initialization
+
+    @Test func initWithValidData() { }
+    @Test func initWithInvalidData() { }
+
+    // MARK: - Properties
+
+    @Test func fullName() { }
+    @Test func age() { }
+
+    // MARK: - Methods
+
+    @Test func update() { }
+    @Test func delete() { }
+}
+```
+
+## Test Discovery
+
+Swift Testing automatically discovers:
+- Functions marked with `@Test`
+- Types marked with `@Suite`
+- Nested suites and tests
+
+No need to:
+- Inherit from XCTestCase
+- Prefix with "test"
+- Register tests manually
+
+## Parallel Execution
+
+Tests run in parallel by default:
+
+```swift
+@Suite(.serialized)  // Run tests in this suite serially
+struct SerialTests {
+    @Test func first() { }
+    @Test func second() { }
+}
+```
+
+## FIRST Principles
+
+Structure tests to be:
+
+- **Fast**: Run quickly
+- **Isolated**: No dependencies between tests
+- **Repeatable**: Same result every time
+- **Self-validating**: Clear pass/fail
+- **Timely**: Written with or before code
+
+```swift
+@Test func fastAndIsolated() {
+    // Uses in-memory database, not real one
+    let db = Database.inMemory()
+
+    // Self-contained data
+    let user = User.fixture()
+
+    // Clear assertion
+    #expect(db.save(user))
+}
+```

package/skills/swiftui-expert-skill/NOTICE.md

@@ -0,0 +1,18 @@
+# swiftui-expert-skill — Attribution Notice
+
+Bundled into `swift-code-reviewer-skill` on 2026-04-21 from
+`~/.agents/skills/swiftui-expert-skill`.
+
+Primary author (best-effort attribution): **Thomas Ricouard ([@Dimillian](https://github.com/Dimillian))**
+Also credited: [@AvdLee](https://github.com/AvdLee), [@bocato](https://github.com/bocato)
+
+These three authors' public Swift/SwiftUI content — including IceCubesApp, SwiftLee,
+and their various open-source contributions — informed the skills bundled here.
+
+License: the upstream folder did not contain a LICENSE file at the time of vendoring.
+Content is reproduced here in good faith for reference alongside this MIT-licensed
+project. If you are an upstream author and want the attribution corrected, the license
+clarified, or the content removed, please open an issue at:
+https://github.com/Viniciuscarvalho/swift-code-reviewer-skill/issues
+
+Changes from upstream: none (verbatim copy; `.DS_Store` files excluded).