Swift

Question

我是 Swift 的新手，目前正在尝试编写单元测试（使用 XCTest）来测试以下功能：

func login(email: String, password: String)  {

    Auth.auth().signIn(withEmail: email, password: password) { (user, error) in
        if let _error = error {
            print(_error.localizedDescription)
        } else {
            self.performSegue(identifier: "loginSeg")
        }
    }
}

我的研究表明我需要使用 XCTestExpectation 功能，因为 XCTest 默认同步执行，这意味着它不会等待闭包完成运行（如果我错了请纠正我）。

让我失望的是我如何测试登录函数，因为它本身调用异步函数 Auth.auth().signIn()。我正在测试是否登录成功

很抱歉，如果这个问题已经得到解答，但我找不到直接解决此问题的答案。

谢谢

更新：

在答案和进一步研究的帮助下，我通过登录功能修改为使用转义闭包：

func login(email: String, password: String, completion: @escaping(Bool)->())  {

    Auth.auth().signIn(withEmail: email, password: password) { (user, error) in
        if let _error = error {
            print(_error.localizedDescription)
            completion(false)
        } else {
            self.performSegue(identifier: "loginSeg")
            completion(true)
        }
    }
}

然后我按以下方式测试：

func testLoginSuccess() {

    // other setup

    let exp = expectation(description: "Check Login is successful")

    let result = login.login(email: email, password: password) { (loginRes) in
        loginResult = loginRes
        exp.fulfill()
    }

    waitForExpectations(timeout: 10) { error in
        if let error = error {
            XCTFail("waitForExpectationsWithTimeout errored: \(error)")
        }
        XCTAssertEqual(loginResult, true)
    }
}

我的测试函数现在可以成功测试登录功能。

希望这对某人有所帮助，因为它让我难住了一段时间:)

Answer 1

对 Auth 的调用是架构边界。如果单元测试达到这样的边界，但不要越过它们，它们会更快、更可靠。我们可以通过将 Auth 单例隔离在协议后面来做到这一点。

我在猜测 signIn 的签名。不管是什么，将其复制并粘贴到协议中：

protocol AuthProtocol {
    func signIn(withEmail email: String, password: String, completion: @escaping (String, NSError?) -> Void)
}

这只是整个 Auth 界面的一小部分，只包含您想要的部分。这是接口隔离原则的一个例子。

然后扩展 Auth 以符合此协议。它已经这样做了，所以一致性是空的。

extension Auth: AuthProtocol {}

现在在您的视图控制器中，将对 Auth.auth() 的直接调用提取到具有默认值的属性中：

var auth: AuthProtocol = Auth.auth()

与此属性对话，而不是直接与 Auth.auth() 对话：

auth.signIn(withEmail: email, …etc…

这里介绍了一个 Seam。测试可以用作为测试间谍的实现替换 auth，记录如何调用 signIn。

final class SpyAuth: AuthProtocol {
    private(set) var signInCallCount = 0
    private(set) var signInArgsEmail: [String] = []
    private(set) var signInArgsPassword: [String] = []
    private(set) var signInArgsCompletion: [(String, Foundation.NSError?) -> Void] = []

    func signIn(withEmail email: String, password: String, completion: @escaping (String, Foundation.NSError?) -> Void) {
        signInCallCount += 1
        signInArgsEmail.append(email)
        signInArgsPassword.append(password)
        signInArgsCompletion.append(completion)
    }
}

测试可以将 SpyAuth 注入视图控制器，拦截通常会进入 Auth 的所有内容。如您所见，这包括完成关闭。我会写

一次确认调用计数和非闭包参数的测试
获取捕获的闭包并成功调用它的另一个测试。
如果您的代码没有 print(_) 语句，我也会调用它失败。

最后，还有转场的问题。 Apple 没有给我们任何方法来对它们进行单元测试。作为解决方法，您可以进行部分模拟。像这样：

final class TestableLoginViewController: LoginViewController {
    private(set) var performSegueCallCount = 0
    private(set) var performSegueArgsIdentifier: [String] = []
    private(set) var performSegueArgsSender: [Any?] = []

    override func performSegue(withIdentifier identifier: String, sender: Any?) {
        performSegueCallCount += 1
        performSegueArgsIdentifier.append(identifier)
        performSegueArgsSender.append(sender)
    }
}

有了这个，您可以拦截对 performSegue 的调用。这并不理想，因为它是一种遗留代码技术。但它应该可以帮助您入门。

final class LoginViewControllerTests: XCTestCase {
    private var sut: TestableLoginViewController!
    private var spyAuth: SpyAuth!

    override func setUp() {
        super.setUp()
        sut = TestableLoginViewController()
        spyAuth = SpyAuth()
        sut.auth = spyAuth
    }

    override func tearDown() {
        sut = nil
        spyAuth = nil
        super.tearDown()
    }

    func test_login_shouldCallAuthSignIn() {
        sut.login(email: "EMAIL", password: "PASSWORD")
        
        XCTAssertEqual(spyAuth.signInCallCount, 1, "call count")
        XCTAssertEqual(spyAuth.signInArgsEmail.first, "EMAIL", "email")
        XCTAssertEqual(spyAuth.signInArgsPassword.first, "PASSWORD", "password")
    }

    func test_login_withSuccess_shouldPerformSegue() {
        sut.login(email: "EMAIL", password: "PASSWORD")
        let completion = spyAuth.signInArgsCompletion.first
        
        completion?("DUMMY", nil)
        
        XCTAssertEqual(sut.performSegueCallCount, 1, "call count")
        XCTAssertEqual(sut.performSegueArgsIdentifier.first, "loginSeg", "identifier")
        let sender = sut.performSegueArgsSender.first
        XCTAssertTrue(sender as? TestableLoginViewController === sut,
            "Expected sender \(sut!), but was \(String(describing: sender))")
    }
}

这里绝对没有异步，所以没有 waitForExpectations。我们捕获闭包，我们调用闭包。

Answer 2

Jon 的回答非常好，我还不能添加评论，所以我会在这里添加我的建议。对于那些（出于任何原因）具有 static/class 函数而不是单例 或实例函数的人，这可以帮助您：

例如，如果您有 Auth.signIn(withEmail: emai...，其中 signIn 是一个静态函数。而不是使用：

var auth: AuthProtocol = Auth.auth()

使用：

var auth: AuthProtocol.Type = Auth.self

然后这样赋值

sut.auth = SpyAuth.self

Swift - 使用 XCTest 测试包含闭包的函数

Swift - using XCTest to test function containing closure

testing

xcode

ios

xctest