Swift - 单元测试私有变量和方法

Question

我正在尝试测试一门课程，但我对要测试的内容有点困惑。这是我要单元测试的类：

class CalculatorBrain {

    private var accumulator = 0.0

    func setOperand(operand: Double) {
        accumulator = operand
    }

    var result: Double {
        return accumulator
    }

    private var operations: Dictionary<String, Operation> = [
        "=" : .Equals,

        "π" : .Constant(M_PI),
        "e" : .Constant(M_E),

        "±" : .UnaryOperation({ (op1: Double) -> Double in return -op1 }),
        "√" : .UnaryOperation(sqrt ),
        "cos": .UnaryOperation(cos),

        "+" : .BinaryOperation({ (op1: Double, op2: Double) -> Double in return op1 + op2 }),
        "−" : .BinaryOperation({ (op1: Double, op2: Double) -> Double in return op1 - op2 }),
        "×" : .BinaryOperation({ (op1: Double, op2: Double) -> Double in return op1 * op2 }),
        "÷" : .BinaryOperation({ (op1: Double, op2: Double) -> Double in return op1 / op2 })
    ]

    private enum Operation {
        case Constant(Double)
        case UnaryOperation((Double) -> Double)
        case BinaryOperation((Double, Double) -> Double)
        case Equals
    }

    func performOperation(symbol: String) {
        if let operation = operations[symbol] {
            switch operation {
            case .Constant(let value):
                accumulator = value
            case .UnaryOperation(let function):
                accumulator = function(accumulator)
            case .BinaryOperation(let function):
                executePendingBinaryOperation()
                pendingBinaryOperation = PendingBinaryOperationInfo(binaryOperation: function, firstOperand: accumulator)
            case .Equals:
                executePendingBinaryOperation()
            }
        }
    }

    private var pendingBinaryOperation: PendingBinaryOperationInfo?

    private struct PendingBinaryOperationInfo {
        var binaryOperation: (Double, Double) -> Double
        var firstOperand: Double
    }

    private func executePendingBinaryOperation() {
        if let pending = pendingBinaryOperation {
            accumulator = pending.binaryOperation(pending.firstOperand, accumulator)
            pendingBinaryOperation = nil
        }
    }
}

对于上面的代码，什么是好的测试。

是否值得测试字典 operations 中的每个操作（+、-、*、/ 等）？

是否值得测试私有方法？

Answer 1

您不能在 Swift 中使用 @testable 测试私有方法。您只能测试标记为internal 或public 的方法。正如文档所说：

注意：@testable 仅提供对“内部”函数的访问； “私人”声明在文件之外是不可见的，即使 使用@testable。

阅读更多here

Answer 2

虽然我同意不测试private 的东西，而且我宁愿只测试公共接口，但有时我需要测试隐藏的类中的某些东西（比如复杂的状态机）。对于这些情况，您可以做的是：

import Foundation

public class Test {

    internal func testInternal() -> Int {
        return 1
    }

    public func testPublic() -> Int {
        return 2
    }

    // we can't test this!        
    private func testPrivate() -> Int {
        return 3
    }
}

// won't ship with production code thanks to #if DEBUG
// add a good comment with "WHY this is needed ?"
#if DEBUG
extension Test {
    public func exposePrivate() -> Int {
        return self.testPrivate()
    }
}
#endif

那么你可以这样做：

import XCTest
@testable import TestTests

class TestTestsTests: XCTestCase {

    func testExample() {
        let sut = Test()

        XCTAssertEqual(1, sut.testInternal())
    }

    func testPrivateExample() {
        let sut = Test()

        XCTAssertEqual(3, sut.exposePrivate())
    }
}

我完全理解这是一个 hack。但是知道这个技巧可以在将来保存你的培根。不要滥用这个技巧。

Answer 3

单元测试应该被视为黑盒测试，这意味着您不关心所测试单元的内部结构。您主要感兴趣的是根据您在单元测试中提供的输入来查看单元输出是什么。

现在，通过输出我们可以断言几件事：

• 方法的结果
• 作用于对象后的状态，
• 与对象所具有的依赖项的交互

在所有情况下，我们只对公共接口感兴趣，因为它是与世界其他地方通信的接口。

私人物品不需要进行单元测试，因为任何私人物品都被公共物品间接使用。诀窍是编写足够多的测试来锻炼公共成员，以便完全覆盖私有成员。

另外，要记住的一件重要事情是单元测试应该验证单元规范，而不是它的实现。验证实现细节增加了单元测试代码和被测试代码之间的紧密耦合，这有一个很大的缺点：如果测试的实现细节发生变化，那么单元测试很可能也需要改变。

以黑盒方式编写单元测试意味着您可以重构这些单元中的所有代码，而不必担心通过更改测试可能会在单元测试代码中引入错误。不可靠的单元测试有时比缺乏测试更糟糕，因为给出误报的测试可能会隐藏代码中的实际错误。

Answer 4

迭戈的回答很聪明，但可以走得更远。

1. 进入您的项目编辑器并通过复制调试配置来定义新的测试配置。
2. 编辑方案的测试操作，使构建配置为测试。
3. 现在编辑您的测试目标的构建设置，为测试配置定义一个额外的活动编译条件值"TESTING"。

现在您可以说 #if TESTING，与单纯的 DEBUG 不同。

例如，我使用它来声明只有测试才能看到的初始化程序。

Answer 5

我发现this link 与 Cristik 有类似的说法。

基本上，您问错了问题，您不应该试图测试标有“私有”的类/函数。

Answer 6

我认为实际上不需要测试私人成员。 但是如果你想在UnitTest使用private成员（属性和方法），有一种方法可以使用Protocol。

Protocol PrivateTestable {
  associatedtype PrivateTestCase  
  var privateTestCase: PrivateTestCase {get}
}

并尝试在同一个文件（目标类文件）中扩展协议。

extension CalculatorBrain: PrivateTestable {
  struct PrivateTestCase {
    private let target: CalculatorBrain

    var pendingBinaryOperation: PendingBinaryOperationInfo? {
      return target.pendingBinaryOperation
    }

    init(target: CalculatorBrain) {
      self.target = target
    }
  }

  var privateTestable: PrivateTestCase { 
    return PrivateTestCase(target: self)
  }

}

那么你可以在UnitTest中使用pendingBinaryOperation

class CalculatorBrainTest: XCTestCase {
  func testPendingBinaryOperation() {
    let brain = CalculatorBrain()
    XCTAssertNotNil(brain.privateTestCase.pendingBinaryOperation)
  }
}

Answer 7

简短的回答是你不能。不能测试私处。

但是，我不认为“你不应该”是一个有效的答案。我曾经这样想，但现实生活中的场景比我们想象的要复杂得多。在某些时候，我需要编写一个FileScanner 类作为框架的一部分，它符合一个只有scan(filename: String) 函数的Scanner 协议。当然FileScanner.scan(filename: String)必须是public，但是支持scan的功能呢？

正如我在上面的评论中提到的，我想：

1. 尽可能保持界面整洁，并且
2. 尽可能将访问级别限制为私密

这意味着我不想公开其他类未使用的其他功能。我真的希望在函数级别有一个 @testable 修饰符（类似于 @discardable 等），但由于它在 Swift 中并不存在，不幸的是我们只有 2 个选项：

1. 只为scan 编写单元测试，这是大多数人的建议。这需要单元测试包中的大量输入文件（不一定是Target，因为我只使用没有Xcode 的SPM，而且它只是一个Tests 目录），并且很难为单个函数创建特定的案例。取决于scan 的复杂程度，这并不是一个好方法。
2. 公开其他私有函数。我最终采用了这种方法，并制定了一个约定，如果一个函数没有任何修饰符，我们假设它是internal，并且可以被同一个包（目标）中的其他文件使用，而不是public。但如果我们特别将其标记为internal func 等，则意味着我们只想将其设为@testable，并且它不应该被同一包中的其他类使用。

所以，我的结论是，即使你还不能在 Swift 中测试私有方法和属性，我认为这是 Swift 的一个限制，但不是一个无效的用例。