Как проверить, был ли вызван метод в конкретном классе при тестировании модулей в Swift?

Question

У меня есть такой сценарий:

class X {
    init(y: ProtocolA)

    func foo(){
        if(y.isSomething()){
            methodA()
        } else {
            methodB()
        }
    }

    func methodA(){
        // any 
    }

    func methodB(){
        // any
    }

}

class Y : ProtocolA {

    func isSomething(): Bool { return true OR false }

}

я хочу проверить класс X ,

Я буду издеваться ProtocolA для возврата в isSomething () метод true или false в двух разных тестах, чтобы узнать, methodA или methodB был вызван.

Какая лучшая стратегия для решения этой проблемы?

пс: с мокито, с помощью шпиона с проверить это очень легко, но с помощью Swift это очень больно

редактирование:

хорошо, я делаю это:

сначала части:

class X { init(y: Y) }
protocol Y { func isSomething() -> Bool }

Теперь структура для тестирования: макет и шпионский объект

typealias VerifyMethodAssert = (count: Int, parameters: [Any]?, returnn: Any?)

Настраиваемый макет для зависимости

class YMock : Y {


        init(configure: Bool)
        func isSomething{ return configure }

    }

Шпион для конкретного класса

class XSpy : X {

    private let y: Y

    var verify: [String: VerifyMethodAssert] = [
        "methodA()": (count: 0, parameters: nil, returnn: nil)
        "methodB()": (count: 0, parameters: nil, returnn: nil)
    ]

    var nothing: [String: Bool] = [
        "methodA()": false
        "methodB()": false
    ]

    init(y: Y, verify: [String: VerifyMethodAssert]?, nothing: [String: Bool]?)

    func methodA(){
        verify["\(#function)"] = (count: verify["\(#function)"]!.count + 1, parameters: nil, 
            returnn: nothing["\(#function)"]! ? nil : super.methodA())
    }

    func methodB(doNothing: Bool = false){
        verify["\(#function)"] = (count: verify["\(#function)"]!.count + 1, parameters: nil, 
            returnn: nothing["\(#function)"]! ? nil : super.methodB())
    }

}

и тест:

class XTest : QuickSpec {

    override func spec(){
        describe("a position view model"){

            it("test 1"){
                let y = Y(configure: true)
                let x = XSpy(y: y)

                x.foo()

                expect(1).to(x.verify["methodA()"].count)
                expect(0).to(x.verify["methodB()"].count)
            }

            it("test 2"){
                let y = Y(configure: true)
                let x = XSpy(y: y)

                x.foo()

                expect(0).to(x.verify["methodA()"].count)
                expect(1).to(x.verify["methodB()"].count)
            }

        }
    }
}

Answer 1

В этом конкретном случае вы можете создать подкласс X и использовать связанный объект для хранения количества вызовов, вы можете обобщить это, если увидите, что используете его снова и снова:

final class TestX: X {

    private struct AssociatedKeys {
        static var invocations = "\(String(describing: type(of: TestX.self)))-invocations"
    }

    func invocations(for method: String) -> Int {
        return invocations[method] ?? 0
    }

    private var invocations: [String: Int] {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.invocations) as? [String: Int] ?? [:]
        }
        set {
            objc_setAssociatedObject( self, &AssociatedKeys.invocations, newValue as NSDictionary, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    override func methodA(){
        super.methodA()
        invocations["methodA"] = (invocations["methodA"] ?? 0) + 1
    }

    override func methodB(){
        super.methodB()
        invocations["methodB"] = (invocations["methodB"] ?? 0) + 1
    }
}

let x = TestX(y: Y())
x.invocations(for: "methodA") //0
x.foo()
x.invocations(for: "methodA") //1

Answer 2

Насколько я знаю, нет ничего необычного. Один из способов сделать это - проверить счетчик:

class X {

    var countA: Int = 0
    var countB: Int = 0

    init(y: ProtocolA)

    func foo(){
        if(y.isSomething()){
            methodA()
        } else {
            methodB()
        }
    }

    func methodA(){
        countA += 1
        // any 

    }

    func methodB(){
        countB += 1
        // any
    }

}

Этот подход также предлагается здесь .