Swift Protocol Di Testing

1---2name: swift-protocol-di-testing3description: Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing.4origin: ECC5---6 7# Swift Protocol-Based Dependency Injection for Testing8 9Patterns for making Swift code testable by abstracting external dependencies (file system, network, iCloud) behind small, focused protocols. Enables deterministic tests without I/O.10 11## When to Activate12 13- Writing Swift code that accesses file system, network, or external APIs14- Need to test error handling paths without triggering real failures15- Building modules that work across environments (app, test, SwiftUI preview)16- Designing testable architecture with Swift concurrency (actors, Sendable)17 18## Core Pattern19 20### 1. Define Small, Focused Protocols21 22Each protocol handles exactly one external concern.23 24```swift25// File system access26public protocol FileSystemProviding: Sendable {27    func containerURL(for purpose: Purpose) -> URL?28}29 30// File read/write operations31public protocol FileAccessorProviding: Sendable {32    func read(from url: URL) throws -> Data33    func write(_ data: Data, to url: URL) throws34    func fileExists(at url: URL) -> Bool35}36 37// Bookmark storage (e.g., for sandboxed apps)38public protocol BookmarkStorageProviding: Sendable {39    func saveBookmark(_ data: Data, for key: String) throws40    func loadBookmark(for key: String) throws -> Data?41}42```43 44### 2. Create Default (Production) Implementations45 46```swift47public struct DefaultFileSystemProvider: FileSystemProviding {48    public init() {}49 50    public func containerURL(for purpose: Purpose) -> URL? {51        FileManager.default.url(forUbiquityContainerIdentifier: nil)52    }53}54 55public struct DefaultFileAccessor: FileAccessorProviding {56    public init() {}57 58    public func read(from url: URL) throws -> Data {59        try Data(contentsOf: url)60    }61 62    public func write(_ data: Data, to url: URL) throws {63        try data.write(to: url, options: .atomic)64    }65 66    public func fileExists(at url: URL) -> Bool {67        FileManager.default.fileExists(atPath: url.path)68    }69}70```71 72### 3. Create Mock Implementations for Testing73 74```swift75public final class MockFileAccessor: FileAccessorProviding, @unchecked Sendable {76    public var files: [URL: Data] = [:]77    public var readError: Error?78    public var writeError: Error?79 80    public init() {}81 82    public func read(from url: URL) throws -> Data {83        if let error = readError { throw error }84        guard let data = files[url] else {85            throw CocoaError(.fileReadNoSuchFile)86        }87        return data88    }89 90    public func write(_ data: Data, to url: URL) throws {91        if let error = writeError { throw error }92        files[url] = data93    }94 95    public func fileExists(at url: URL) -> Bool {96        files[url] != nil97    }98}99```100 101### 4. Inject Dependencies with Default Parameters102 103Production code uses defaults; tests inject mocks.104 105```swift106public actor SyncManager {107    private let fileSystem: FileSystemProviding108    private let fileAccessor: FileAccessorProviding109 110    public init(111        fileSystem: FileSystemProviding = DefaultFileSystemProvider(),112        fileAccessor: FileAccessorProviding = DefaultFileAccessor()113    ) {114        self.fileSystem = fileSystem115        self.fileAccessor = fileAccessor116    }117 118    public func sync() async throws {119        guard let containerURL = fileSystem.containerURL(for: .sync) else {120            throw SyncError.containerNotAvailable121        }122        let data = try fileAccessor.read(123            from: containerURL.appendingPathComponent("data.json")124        )125        // Process data...126    }127}128```129 130### 5. Write Tests with Swift Testing131 132```swift133import Testing134 135@Test("Sync manager handles missing container")136func testMissingContainer() async {137    let mockFileSystem = MockFileSystemProvider(containerURL: nil)138    let manager = SyncManager(fileSystem: mockFileSystem)139 140    await #expect(throws: SyncError.containerNotAvailable) {141        try await manager.sync()142    }143}144 145@Test("Sync manager reads data correctly")146func testReadData() async throws {147    let mockFileAccessor = MockFileAccessor()148    mockFileAccessor.files[testURL] = testData149 150    let manager = SyncManager(fileAccessor: mockFileAccessor)151    let result = try await manager.loadData()152 153    #expect(result == expectedData)154}155 156@Test("Sync manager handles read errors gracefully")157func testReadError() async {158    let mockFileAccessor = MockFileAccessor()159    mockFileAccessor.readError = CocoaError(.fileReadCorruptFile)160 161    let manager = SyncManager(fileAccessor: mockFileAccessor)162 163    await #expect(throws: SyncError.self) {164        try await manager.sync()165    }166}167```168 169## Best Practices170 171- **Single Responsibility**: Each protocol should handle one concern — don't create "god protocols" with many methods172- **Sendable conformance**: Required when protocols are used across actor boundaries173- **Default parameters**: Let production code use real implementations by default; only tests need to specify mocks174- **Error simulation**: Design mocks with configurable error properties for testing failure paths175- **Only mock boundaries**: Mock external dependencies (file system, network, APIs), not internal types176 177## Anti-Patterns to Avoid178 179- Creating a single large protocol that covers all external access180- Mocking internal types that have no external dependencies181- Using `#if DEBUG` conditionals instead of proper dependency injection182- Forgetting `Sendable` conformance when used with actors183- Over-engineering: if a type has no external dependencies, it doesn't need a protocol184 185## When to Use186 187- Any Swift code that touches file system, network, or external APIs188- Testing error handling paths that are hard to trigger in real environments189- Building modules that need to work in app, test, and SwiftUI preview contexts190- Apps using Swift concurrency (actors, structured concurrency) that need testable architecture