Swift协议依赖注入测试Skill swift-protocol-di-testing

---

名称: swift-protocol-di-testing 描述: 基于协议的依赖注入，用于编写可测试的Swift代码——通过聚焦的协议和Swift Testing来模拟文件系统、网络和外部API。

基于协议的Swift依赖注入用于测试

通过将外部依赖（文件系统、网络、iCloud）抽象到小而聚焦的协议之后，使Swift代码可测试的模式。支持无需I/O的确定性测试。

何时启用

• 编写访问文件系统、网络或外部API的Swift代码时
• 需要测试错误处理路径而无需触发真实故障时
• 构建跨环境（应用、测试、SwiftUI预览）工作的模块时
• 设计支持Swift并发（Actor、Sendable）的可测试架构时

核心模式

1. 定义小而聚焦的协议

每个协议只处理一个外部关注点。

// 文件系统访问
public protocol FileSystemProviding: Sendable {
    func containerURL(for purpose: Purpose) -> URL?
}

// 文件读写操作
public protocol FileAccessorProviding: Sendable {
    func read(from url: URL) throws -> Data
    func write(_ data: Data, to url: URL) throws
    func fileExists(at url: URL) -> Bool
}

// 书签存储（例如，用于沙盒应用）
public protocol BookmarkStorageProviding: Sendable {
    func saveBookmark(_ data: Data, for key: String) throws
    func loadBookmark(for key: String) throws -> Data?
}

2. 创建默认（生产）实现

public struct DefaultFileSystemProvider: FileSystemProviding {
    public init() {}

    public func containerURL(for purpose: Purpose) -> URL? {
        FileManager.default.url(forUbiquityContainerIdentifier: nil)
    }
}

public struct DefaultFileAccessor: FileAccessorProviding {
    public init() {}

    public func read(from url: URL) throws -> Data {
        try Data(contentsOf: url)
    }

    public func write(_ data: Data, to url: URL) throws {
        try data.write(to: url, options: .atomic)
    }

    public func fileExists(at url: URL) -> Bool {
        FileManager.default.fileExists(atPath: url.path)
    }
}

3. 为测试创建模拟实现

public final class MockFileAccessor: FileAccessorProviding, @unchecked Sendable {
    public var files: [URL: Data] = [:]
    public var readError: Error?
    public var writeError: Error?

    public init() {}

    public func read(from url: URL) throws -> Data {
        if let error = readError { throw error }
        guard let data = files[url] else {
            throw CocoaError(.fileReadNoSuchFile)
        }
        return data
    }

    public func write(_ data: Data, to url: URL) throws {
        if let error = writeError { throw error }
        files[url] = data
    }

    public func fileExists(at url: URL) -> Bool {
        files[url] != nil
    }
}

4. 使用默认参数注入依赖

生产代码使用默认实现；测试注入模拟对象。

public actor SyncManager {
    private let fileSystem: FileSystemProviding
    private let fileAccessor: FileAccessorProviding

    public init(
        fileSystem: FileSystemProviding = DefaultFileSystemProvider(),
        fileAccessor: FileAccessorProviding = DefaultFileAccessor()
    ) {
        self.fileSystem = fileSystem
        self.fileAccessor = fileAccessor
    }

    public func sync() async throws {
        guard let containerURL = fileSystem.containerURL(for: .sync) else {
            throw SyncError.containerNotAvailable
        }
        let data = try fileAccessor.read(
            from: containerURL.appendingPathComponent("data.json")
        )
        // 处理数据...
    }
}

5. 使用Swift Testing编写测试

import Testing

@Test("同步管理器处理缺失的容器")
func testMissingContainer() async {
    let mockFileSystem = MockFileSystemProvider(containerURL: nil)
    let manager = SyncManager(fileSystem: mockFileSystem)

    await #expect(throws: SyncError.containerNotAvailable) {
        try await manager.sync()
    }
}

@Test("同步管理器正确读取数据")
func testReadData() async throws {
    let mockFileAccessor = MockFileAccessor()
    mockFileAccessor.files[testURL] = testData

    let manager = SyncManager(fileAccessor: mockFileAccessor)
    let result = try await manager.loadData()

    #expect(result == expectedData)
}

@Test("同步管理器优雅地处理读取错误")
func testReadError() async {
    let mockFileAccessor = MockFileAccessor()
    mockFileAccessor.readError = CocoaError(.fileReadCorruptFile)

    let manager = SyncManager(fileAccessor: mockFileAccessor)

    await #expect(throws: SyncError.self) {
        try await manager.sync()
    }
}

最佳实践

• 单一职责：每个协议应只处理一个关注点——不要创建包含许多方法的“上帝协议”
• Sendable一致性：当协议跨Actor边界使用时是必需的
• 默认参数：让生产代码默认使用真实实现；只有测试需要指定模拟对象
• 错误模拟：设计具有可配置错误属性的模拟对象，用于测试失败路径
• 仅模拟边界：模拟外部依赖（文件系统、网络、API），而不是内部类型

需要避免的反模式

• 创建一个覆盖所有外部访问的单一大型协议
• 模拟没有外部依赖的内部类型
• 使用 #if DEBUG 条件编译而不是适当的依赖注入
• 与Actor一起使用时忘记 Sendable 一致性
• 过度设计：如果一个类型没有外部依赖，它就不需要协议

使用场景

• 任何触及文件系统、网络或外部API的Swift代码
• 测试在真实环境中难以触发的错误处理路径时
• 构建需要在应用、测试和SwiftUI预览上下文中工作的模块时
• 使用Swift并发（Actor、结构化并发）且需要可测试架构的应用