Swift how to test async call wrapped in a function

Question

Is there a way to wait for an async call to be finished when this call is wrapped in another method?

class Owner{
   let dataManager = MockDataManager()
   var data: String? = nil

   func refresh() {
        Task {
            self.data = await dataManager.fetchData()
        }
    }
}

class MockDataManager {
    var testData: String = "test"
    func fetchData() async -> String {
       testData
    }
}

class OwnerTests: SKTestCase {
    private var owner = Owner()
    
    func testRefresh() {
        owner.refresh()
        XCTAssertEqual(owner.data, "test") // fail. the value is still nil
    }
}

With callbacks, the tests used to work if everything under the hood was replaced with synchronous calls but here it looks like i am missing an operation to wait for a change to owner.data

Answer 1

Late to this party, but I agree with @Cristik regarding not changing the signature of a function just to accommodate testing. In the chat room conversation, @Cristik also pointed out a valid reason why a function can be set up to invoke an async function but yet not define its signature as async:

• the Owner class may be in the nature of a view model (in an MVVM pattern) that exposes read-only observable/bindable (say @Published let) properties, that are bindable from (a) view(s), and the refresh function allows the view to request data update following a user event;
• the refresh function isn't expected to return any data to the view when invoked, rather the view model (Owner) object will update the observable properties with the data returned while the views bound to (i.e. observing) the properties will be automatically updated.

In this case there's absolutely no need to mark the Owner.refresh() function as async and, thus forcing the view(s) to wrap their invocation of the refresh function in an async or Task (or .task modifier in SwiftUI) construct.

That said, I had similar situation and here's how I implemented the unit (not integration) test:

func testRefreshFunctionFetchesDataAndPopulatesFields() {        
  let expectation = XCTestExpectation(
    description: "Owner fetches data and updates properties."
  )

  // `Owner` is the "subject under test", so use protocol-driven development 
  // and dependency injection to enable focusing on testing just the SUT 
  // unencumbered by peculiarities of the dependency 
  let owner = Owner(mockDataManager: DataManagerProtocol())
        
  // Verify initial state
  XCTAssertNil(owner.data)

  owner.refresh()
        
  let asyncWaitDuration = 0.5 // <= could be even less than 0.5 seconds even
  DispatchQueue.main.asyncAfter(deadline: .now() + asyncWaitDuration) {
    expectation.fulfill()
            
    // Verify state after
    XCTAssertEqual(owner.data, "someString")
  }

  wait(for: [expectation], timeout: asyncWaitDuration)
}

Hope this helps.

Answer 2

The fact that refresh detaches some async code to do its job, is an implementation detail, and your tests should not care about the implementation details.

Instead, focus on the behaviour of the unit. For example, in the scenario you posted, the expected behaviour is that sometime after refresh is called, owner.data should become "test". This is what you should assert against.

Your current test code follows the above good practice, only that, as you observed, it fails because it doesn't wait until the property ends up being set. So, try to fix this, but without caring how the async part is implemented. This will make your tests more robust, and your code easier to refactor.

One possible approach for validating the async update is to use a custom XCTestExpectation:

final class PropertyExpectation<T: AnyObject, V: Equatable>: XCTNSPredicateExpectation {
    init(object: T, keyPath: KeyPath<T, V>, expectedValue: V) {
        let predicate = NSPredicate(block: { _, _ in
            return object[keyPath: keyPath] == expectedValue
        })
        super.init(predicate: predicate, object: nil)
    }
}

func testRefresh() {
    let exp = PropertyExpectation(object: owner, keyPath: \.data, expectedValue: "test")
    owner.refresh()

    wait(for: [exp], timeout: 5)
}

Alternatively, you can use a 3rd party library that comes with support for async assertions, like Nimble:

func testRefresh() {
    owner.refresh()
    expect(self.owner.data).toEventually(equal("test"))
}

As a side note, since your code is multithreaded, strongly recommending to add some synchronization in place, in order to avoid data races. The idiomatic way in regards to the structured concurrency is to convert your class into an actor, however, depending on how you're consuming the class from other parts of the code, it might not be a trivial task. Regardless, you should fix the data races conditions sooner rather than later.

Answer 3

I would like to contribute a solution for a more restricted situation where XCTestExpectation doesn't work, and that's when a view model is bound to the @MainActor, and you can't make every function call async (relying on property didSet). Waiting for expectations will also block the task in question, even a detached task won't help, the task will always execute after the test function. Storing and later awaiting the task solves the problem:

@MainActor
class ViewModel {

  var task : Task<Void, Never>?

  @Published var value1: Int = 0 {
    didSet {
      task = Task {
        await update2()
      }
    }
  }

  @Published var value2: Int = 0

  func update2() async {
    value2 = value1 + 1
  }
}

And then in the test:

func testExample() {
    viewModel.value1 = 1
    let _ = await viewModel.task?.result
    XCTAssertEqual(viewModel.value2, 2)
}

Answer 4

func refresh() async {
    self.data = await dataManager.fetchData()
}

then in the test await owner.refresh()

If you really need to wait synchronously for the async task, you can see this question Swift await/async - how to wait synchronously for an async task to complete?