如何在XCTest中模拟低版本macOS测试Swift项目代码

好问题！在XCTest里模拟低版本macOS来测试分支代码，确实比直接调用分支逻辑更能还原真实的运行场景，也能确保你的版本适配代码真的按预期工作。下面给你几个实用的方案，按推荐程度排序：

方案1：封装系统版本检测工具（推荐） #

核心思路是不要直接在业务代码里调用ProcessInfo，而是把系统版本检测逻辑封装成一个独立的工具类，这样测试时可以轻松替换返回值来模拟不同系统版本。

步骤1：封装检测工具 #

import Foundation

struct SystemVersionChecker {
    // 默认返回真实的系统版本
    private static var mockedVersion: OperatingSystemVersion?
    
    // 对外暴露的当前系统版本，优先使用mock值
    static var currentOSVersion: OperatingSystemVersion {
        return mockedVersion ?? ProcessInfo.processInfo.operatingSystemVersion
    }
    
    // 简化版本判断的快捷方法
    static func isAtLeast(major: Int, minor: Int = 0, patch: Int = 0) -> Bool {
        return currentOSVersion >= OperatingSystemVersion(majorVersion: major, minorVersion: minor, patchVersion: patch)
    }
    
    // 测试专用：设置模拟版本
    static func mock(version: OperatingSystemVersion) {
        mockedVersion = version
    }
    
    // 测试专用：重置mock，恢复真实版本
    static func resetMock() {
        mockedVersion = nil
    }
}

步骤2：业务代码中使用工具类 #

class YourFeature {
    func performAction() -> String {
        if SystemVersionChecker.isAtLeast(major: 10, minor: 13) {
            // macOS 10.13+的实现
            return "High Sierra+"
        } else {
            // 低版本实现
            return "Pre-High Sierra"
        }
    }
}

步骤3：编写测试用例 #

import XCTest
@testable import YourProject

class YourFeatureTests: XCTestCase {
    func testLowVersionLogic() {
        // 模拟macOS 10.12版本
        let mockOS = OperatingSystemVersion(majorVersion: 10, minorVersion: 12, patchVersion: 0)
        SystemVersionChecker.mock(version: mockOS)
        
        // 执行测试
        let feature = YourFeature()
        let result = feature.performAction()
        
        // 断言低版本逻辑生效
        XCTAssertEqual(result, "Pre-High Sierra")
        
        // 测试结束后重置mock，避免影响其他测试
        SystemVersionChecker.resetMock()
    }
    
    func testHighVersionLogic() {
        let mockOS = OperatingSystemVersion(majorVersion: 10, minorVersion: 13, patchVersion: 0)
        SystemVersionChecker.mock(version: mockOS)
        
        let feature = YourFeature()
        let result = feature.performAction()
        
        XCTAssertEqual(result, "High Sierra+")
        
        SystemVersionChecker.resetMock()
    }
}

这个方案的优势是代码清晰、易维护，而且完全隔离了测试代码和生产代码（测试相关的mock方法不会影响Release构建）。

方案2：针对#available的工厂模式适配 #

如果你的代码用了#available编译期判断，直接mock系统版本不太现实，这时候可以把不同版本的实现抽成独立的类型，用工厂模式来分发，然后在测试时替换工厂的判断逻辑。

步骤1：定义协议和不同版本的实现 #

protocol FeatureAction {
    func execute() -> String
}

// macOS 10.13+专属实现
@available(macOS 10.13, *)
class HighVersionAction: FeatureAction {
    func execute() -> String {
        return "Using 10.13+ APIs"
    }
}

// 低版本兼容实现
class LowVersionAction: FeatureAction {
    func execute() -> String {
        return "Using compatible APIs"
    }
}

步骤2：实现可mock的工厂类 #

class FeatureFactory {
    // 可替换的版本判断闭包，默认使用真实系统版本
    static var isHighVersion: () -> Bool = {
        return #available(macOS 10.13, *)
    }
    
    static func makeAction() -> FeatureAction {
        if isHighVersion() {
            // 这里因为#available是编译期检查，所以需要用条件编译确保代码合法
            if #available(macOS 10.13, *) {
                return HighVersionAction()
            }
        }
        return LowVersionAction()
    }
}

步骤3：测试不同分支 #

class FeatureFactoryTests: XCTestCase {
    func testLowVersionAction() {
        // 模拟系统版本低于10.13
        FeatureFactory.isHighVersion = { false }
        
        let action = FeatureFactory.makeAction()
        XCTAssertTrue(action is LowVersionAction)
        XCTAssertEqual(action.execute(), "Using compatible APIs")
        
        // 重置闭包
        FeatureFactory.isHighVersion = { #available(macOS 10.13, *) }
    }
    
    func testHighVersionAction() {
        FeatureFactory.isHighVersion = { true }
        
        let action = FeatureFactory.makeAction()
        XCTAssertTrue(action is HighVersionAction)
        XCTAssertEqual(action.execute(), "Using 10.13+ APIs")
        
        FeatureFactory.isHighVersion = { #available(macOS 10.13, *) }
    }
}

这个方案完美适配#available的场景，同时保持了代码的可测试性。

方案3：运行时替换ProcessInfo（Hack方式） #

如果不想封装工具类，也可以用Objective-C的运行时特性直接替换ProcessInfo的operatingSystemVersion方法。这种方法比较底层，适合快速临时测试，但不推荐长期使用（可读性和维护性较差）。

步骤1：编写OC分类（需要桥接） #

#import <Foundation/Foundation.h>

@interface ProcessInfo (Mock)
+ (void)mockOperatingSystemVersion:(OperatingSystemVersion)version;
+ (void)resetOSVersionMock;
@end

@implementation ProcessInfo (Mock)
static OperatingSystemVersion _mockVersion;
static BOOL _isMocking = NO;

+ (void)mockOperatingSystemVersion:(OperatingSystemVersion)version {
    _mockVersion = version;
    _isMocking = YES;
    
    Method original = class_getInstanceMethod(self, @selector(operatingSystemVersion));
    Method mocked = class_getInstanceMethod(self, @selector(mocked_operatingSystemVersion));
    method_exchangeImplementations(original, mocked);
}

- (OperatingSystemVersion)mocked_operatingSystemVersion {
    if (_isMocking) {
        return _mockVersion;
    }
    return [self mocked_operatingSystemVersion]; // 交换后调用原方法
}

+ (void)resetOSVersionMock {
    _isMocking = NO;
    Method original = class_getInstanceMethod(self, @selector(operatingSystemVersion));
    Method mocked = class_getInstanceMethod(self, @selector(mocked_operatingSystemVersion));
    method_exchangeImplementations(original, mocked);
}
@end

步骤2：在Swift测试中使用 #

func testWithRuntimeMock() {
    let mockOS = OperatingSystemVersion(majorVersion: 10, minorVersion: 12, patchVersion: 0)
    ProcessInfo.mockOperatingSystemVersion(mockOS)
    
    // 执行你的业务代码测试...
    
    ProcessInfo.resetOSVersionMock()
}

内容的提问来源于stack exchange，提问作者Jay