How to assert an error is thrown async when testing?

Question

We can test thrown errors with XCTAssertThrowsError. Async things can be tested with expectation. I have some method which dispatch work to a background thread and can at some point throw an error.

Is it possible to expect an error be thrown somewhere in the future? I need to combine expectation and XCTAssertThrowsError I think, but I do not know how.

Reproduction project: https://github.com/Jasperav/ThrowingAsyncError. Just clone the project and run the tests, one of them will fail. I made a class which will crash after a few seconds after it has been allocated. I want to make sure it keeps crashing after a few seconds, so I want a test case for it.

Answer 1

Using the other answers here, I wrote a helper function that works as a drop-in replacement for XCTAssertThrowsError when working with async functions.

import XCTest

/// Asserts that an asynchronous expression throws an error.
/// (Intended to function as a drop-in asynchronous version of `XCTAssertThrowsError`.)
///
/// Example usage:
///
///     await assertThrowsAsyncError(
///         try await sut.function()
///     ) { error in
///         XCTAssertEqual(error as? MyError, MyError.specificError)
///     }
///
/// - Parameters:
///   - expression: An asynchronous expression that can throw an error.
///   - message: An optional description of a failure.
///   - file: The file where the failure occurs.
///     The default is the filename of the test case where you call this function.
///   - line: The line number where the failure occurs.
///     The default is the line number where you call this function.
///   - errorHandler: An optional handler for errors that expression throws.
func assertThrowsAsyncError<T>(
    _ expression: @autoclosure () async throws -> T,
    _ message: @autoclosure () -> String = "",
    file: StaticString = #filePath,
    line: UInt = #line,
    _ errorHandler: (_ error: Error) -> Void = { _ in }
) async {
    do {
        _ = try await expression()
        // expected error to be thrown, but it was not
        let customMessage = message()
        if customMessage.isEmpty {
            XCTFail("Asynchronous call did not throw an error.", file: file, line: line)
        } else {
            XCTFail(customMessage, file: file, line: line)
        }
    } catch {
        errorHandler(error)
    }
}

I’ve posted this as a file that can be added to the unit test target of your projects: https://gitlab.com/-/snippets/2567566

Answer 2

I took the sample code from David B.'s answer and changed it, because expectations are not needed when the unit test method is annotated with async.

func testFailingAsyncCode() async { // async is important here
    let dataFetcher = DataFetcher()
    
    var didFailWithError: Error?
    do {
        // This call is expected to fail
        _ = try await dataFetcher.fetchData(withRequest: request, validStatusCodes: [200])
    } catch {
        didFailWithError = error
        // Here you could do more assertions with the non-nil error object
    }

    XCTAssertNotNil(didFailWithError)
}

Answer 3

You could fulfill an expectation in the catch block of a call that is expected to fail.

func testFailingAsyncCode() async throws {
    let expectation = expectation(description: "expect call to throw error")
    let dataFetcher = DataFetcher()
    
    do {
        // This call is expected to fail
        let data = try await dataFetcher.fetchData(withRequest: request, validStatusCodes: [200])
    } catch {
        // Expectation is fulfilled when call fails
        expectation.fulfill()
    }
    
    wait(for: [expectation], timeout: 3)
}

Answer 4

Approach:

• Use async
• Use XCTFail

func testFailingAsyncCode() async {
    let dataFetcher = DataFetcher()
    
    do {
        _ = try await dataFetcher.fetchData(withRequest: request, validStatusCodes: [200])
        XCTFail("Error needs to be thrown")
    } catch {
        //Do nothing, if error is thrown then it matches expected result
    }
}

Answer 5

I took a look at the reproduction project to see what you were trying to accomplish here...

To my understanding:

XCTAssertThrowsError are assertions that takes in a block that can throw. They just happen to assert that an error is thrown in a synchronous block when it's done running.

XCTestExpectation are classes that keep track of whether or not requested conditions are met. They are for keeping track of asynchronous code behavior objects/references need to be kept and checked later.

What you seem to be trying to do is make something like XCTestExpectation work the same way XCTAssertThrowsError does, as in make an synchronous assertion that an asynchronous block will throw. It won't work quite that way because of how the code runs and returns.

The asynchronous code you refer to does not throw (timer initializer). As far as I know, there aren't any asynchronous blocks that can throw. Perhaps the question you should be asking is how can we make a synchronous operation choose to run synchronously sometimes, but also asynchronously when it feels like...

Alternatively for some additional complexity in every class you would like to test I've made a solution with what is almost bare minimum to make this easily testable and portable...

https://github.com/Jasperav/ThrowingAsyncError/pull/1/files

May I ask why you would ever want to do something like this?