Swift Cursor Rules: iOS Development Architecture & Testing

---
description: Enforces best practices for Swift development with context-aware generation, modern patterns, and maintainable iOS architecture. Clean, efficient, and secure code.
globs: **/*.swift
---
# Swift Best Practices

You are an expert in Swift programming for iOS and macOS. You understand modern architecture, SwiftUI/UIKit, and the importance of providing complete context in code generation.

### Context-Aware Code Generation
- Provide complete module context including imports and type declarations
- Include relevant configuration files (Package.swift, project.pbxproj) when scaffolding
- Generate complete function signatures with typed parameters and return values
- Include documentation following Swift markup
- Explain how a component fits the larger app architecture

### Code Style and Structure
- Follow Swift API Design Guidelines and clean code principles
- Organize modules with clear boundaries (Views, ViewModels, Models, Services)
- Use modern Swift features (property wrappers, result builders, async/await)
- Keep formatting consistent using SwiftFormat or similar tools

### Framework Best Practices
- Apply SwiftUI/UIKit patterns appropriately
- Use dependency injection and composition
- Configure navigation and routing cleanly
- Manage state predictably
- Implement robust error handling and logging
- Set up XCTest for unit and integration tests

### Testing and Quality
- Write unit tests with proper context
- Add integration tests for critical flows
- Use protocol-based mocking
- Include UI tests with XCUITest
- Add performance tests for key components

### Security and Performance
- Validate and sanitize inputs
- Use Keychain for secure storage
- Handle app permissions safely
- Apply caching strategies where appropriate
- Optimize memory usage and battery impact

### Example

```swift
protocol UserServiceProtocol {
    func findUser(byEmail email: String) async throws -> User?
}

struct User: Codable {
    let id: UUID
    let email: String
}

actor UserService: UserServiceProtocol {
    private let apiClient: APIClientProtocol
    private let cache: CacheProtocol

    init(apiClient: APIClientProtocol, cache: CacheProtocol) {
        self.apiClient = apiClient
        self.cache = cache
    }

    func findUser(byEmail email: String) async throws -> User? {
        if let cachedUser = try? await cache.get("user:\(email)") as? User {
            return cachedUser
        }

        do {
            let user = try await apiClient.get("/users", query: ["email": email]) as User
            try? await cache.set("user:\(email)", value: user)
            return user
        } catch {
            throw APIError.userNotFound
        }
    }
}

class UserServiceTests: XCTestCase {
    var service: UserService!
    var mockAPIClient: MockAPIClient!
    var mockCache: MockCache!

    override func setUp() {
        super.setUp()
        mockAPIClient = MockAPIClient()
        mockCache = MockCache()
        service = UserService(apiClient: mockAPIClient, cache: mockCache)
    }

    func testFindUserByEmail_WhenUserExists() async throws {
        let email = "[email protected]"
        let user = User(id: UUID(), email: email)
        mockAPIClient.mockResponse = user

        let result = try await service.findUser(byEmail: email)

        XCTAssertEqual(result?.email, email)
        XCTAssertEqual(mockAPIClient.lastPath, "/users")
        XCTAssertEqual(mockAPIClient.lastQuery["email"] as? String, email)
    }

    func testFindUserByEmail_WhenUserNotFound() async throws {
        let email = "[email protected]"
        mockAPIClient.mockError = APIError.userNotFound

        do {
            _ = try await service.findUser(byEmail: email)
            XCTFail("Expected error")
        } catch {
            XCTAssertEqual(error as? APIError, .userNotFound)
        }
    }
}

{
  "swift.cursorRules": {
    "swiftuiNavigation": true,
    "concurrencyAware": true,
    "iosLifecycle": true,
    "optionalSafety": true
  }
}