Add xcDeferFulfillment to help with tests that have publishers. (#1278)

* Add xcAwaitDeferred to aid with tests that have publishers.

* Improve naming

* Address Comments

- Fix naming
- Add optional expectation message
- Use trailing closure syntax

UnitTests/Sources/Extensions/XCTestCase.swift

@@ -0,0 +1,63 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Combine
+import XCTest
+
+extension XCTestCase {
+    /// XCTest utility that assists in subscribing to a publisher and deferring the fulfilment and results until some other actions have been performed.
+    ///
+    ///  ```
+    /// let collectedEvents = somePublisher.collect(3).first()
+    /// let awaitDeferred = deferFulfillment(collectedEvents)
+    /// // Do some other work that publishes to somePublisher
+    /// XCTAssertEqual(try await awaitDeferred.execute(), [expected, values, here])
+    ///  ```
+    /// - Parameters:
+    ///   - publisher: The publisher to wait on.
+    ///   - timeout: A timeout after which we give up.
+    /// - Returns: The deferred fulfilment to be executed after some actions and that returns the result of the publisher.
+    func deferFulfillment<T: Publisher>(_ publisher: T, timeout: TimeInterval = 10, message: String? = nil) -> DeferredFulfillment<T.Output> {
+        var result: Result<T.Output, Error>?
+        let expectation = expectation(description: message ?? "Awaiting publisher")
+        let cancellable = publisher
+            .sink { completion in
+                switch completion {
+                case .failure(let error):
+                    result = .failure(error)
+                case .finished:
+                    break
+                }
+                expectation.fulfill()
+            } receiveValue: { value in
+                result = .success(value)
+            }
+        
+        return DeferredFulfillment<T.Output> {
+            await self.fulfillment(of: [expectation], timeout: timeout)
+            cancellable.cancel()
+            let unwrappedResult = try XCTUnwrap(result, "Awaited publisher did not produce any output")
+            return try unwrappedResult.get()
+        }
+    }
+    
+    struct DeferredFulfillment<T> {
+        let closure: () async throws -> T
+        @discardableResult func fulfill() async throws -> T {
+            try await closure()
+        }
+    }
+}

UnitTests/Sources/HomeScreenViewModelTests.swift

@@ -87,8 +87,9 @@ class HomeScreenViewModelTests: XCTestCase {
         let room: RoomProxyMock = .init(with: .init(id: mockRoomId, displayName: "Some room"))
         room.leaveRoomClosure = { .failure(.failedLeavingRoom) }
         clientProxy.roomForIdentifierMocks[mockRoomId] = room
+        let deferred = deferFulfillment(context.$viewState.first(), message: "viewState should be published.")
         context.send(viewAction: .confirmLeaveRoom(roomIdentifier: mockRoomId))
-        await context.nextViewState()
+        try await deferred.fulfill()
         XCTAssertNotNil(context.alertInfo)
     }
     

UnitTests/Sources/ReportContentViewModelTests.swift

@@ -14,9 +14,8 @@
 // limitations under the License.
 //
 
-import XCTest
-
 @testable import ElementX
+import XCTest
 
 @MainActor
 class ReportContentScreenViewModelTests: XCTestCase {
@@ -24,7 +23,7 @@ class ReportContentScreenViewModelTests: XCTestCase {
     let senderID = "@meany:server.com"
     let reportReason = "I don't like it."
     
-    func testReportContent() async {
+    func testReportContent() async throws {
         // Given the report content view for some content.
         let roomProxy = RoomProxyMock(with: .init(displayName: "test"))
         roomProxy.reportContentReasonReturnValue = .success(())
@@ -32,13 +31,16 @@ class ReportContentScreenViewModelTests: XCTestCase {
                                                      senderID: senderID,
                                                      roomProxy: roomProxy)
         
+        let deferred = deferFulfillment(viewModel.actions.collect(2).first(), message: "2 actions should be published.")
+        
         // When reporting the content without ignoring the user.
         viewModel.state.bindings.reasonText = reportReason
         viewModel.state.bindings.ignoreUser = false
         viewModel.context.send(viewAction: .submit)
         
-        _ = await viewModel.actions.values.first()
-        
+        let actions = try await deferred.fulfill()
+        XCTAssertEqual(actions, [.submitStarted, .submitFinished])
+   
         // Then the content should be reported, but the user should not be included.
         XCTAssertEqual(roomProxy.reportContentReasonCallsCount, 1, "The content should always be reported.")
         XCTAssertEqual(roomProxy.reportContentReasonReceivedArguments?.eventID, itemID, "The event ID should match the content being reported.")

UnitTests/Sources/RoomScreenViewModelTests.swift

@@ -213,9 +213,10 @@ class RoomScreenViewModelTests: XCTestCase {
         let roomProxyMock = RoomProxyMock(with: .init(displayName: ""))
         let roomMemberMock = RoomMemberProxyMock()
         roomMemberMock.userID = "bob"
+        let expectation = XCTestExpectation(description: "Go to user details")
+        
         roomProxyMock.getMemberUserIDClosure = { _ in
-            try? await Task.sleep(for: .milliseconds(200))
-            return .success(roomMemberMock)
+            .success(roomMemberMock)
         }
 
         let viewModel = RoomScreenViewModel(timelineController: timelineController,
@@ -229,6 +230,7 @@ class RoomScreenViewModelTests: XCTestCase {
             switch action {
             case .displayRoomMemberDetails(let member):
                 XCTAssert(member === roomMemberMock)
+                expectation.fulfill()
             default:
                 XCTFail("Did not received the expected action")
             }
@@ -236,7 +238,8 @@ class RoomScreenViewModelTests: XCTestCase {
 
         // Test
         viewModel.context.send(viewAction: .tappedOnUser(userID: "bob"))
-        try? await Task.sleep(for: .milliseconds(300))
+        await fulfillment(of: [expectation])
+        
         XCTAssert(userIndicatorControllerMock.submitIndicatorDelayCallsCount == 1)
         XCTAssert(userIndicatorControllerMock.retractIndicatorWithIdCallsCount == 1)
         XCTAssert(roomProxyMock.getMemberUserIDCallsCount == 1)