Fix one more flaky test

Sources/Misc/Concurrency/OperationDispatcher.swift

@@ -65,8 +65,9 @@ class OperationDispatcher {
         }
     }
 
+    @discardableResult
     func dispatchOnWorkerThread(jitterableDelay delay: JitterableDelay = .none,
-                                block: @escaping @Sendable () async -> Void) {
+                                block: @escaping @Sendable () async -> Void) -> Task<Void, Never> {
         Task.detached(priority: .background) {
             if delay.hasDelay {
                 try? await Task.sleep(nanoseconds: DispatchTimeInterval(delay.random()).nanoseconds)

Sources/Purchasing/Purchases/Purchases.swift

@@ -1442,8 +1442,9 @@ public extension Purchases {
     }
 
     /// Used by `RevenueCatUI` to keep track of ``CustomerCenterEvent``s.
-    @_spi(Internal) func track(customerCenterEvent: any CustomerCenterEventType) {
-        operationDispatcher.dispatchOnWorkerThread {
+    @discardableResult
+    @_spi(Internal) func track(customerCenterEvent: any CustomerCenterEventType) -> Task<Void, Never> {
+        return operationDispatcher.dispatchOnWorkerThread {
             // If we make CustomerCenterEventType implement FeatureEvent, we have to make FeatureEvent public
             guard let event = customerCenterEvent as? FeatureEvent else { return }
             await self.eventsManager?.track(featureEvent: event)

Tests/BackendIntegrationTests/EventsManagerIntegrationTests.swift

@@ -48,9 +48,10 @@ final class EventsManagerIntegrationTests: BaseBackendIntegrationTests {
     func testPostingCustomerCenterDoesNotFail() async throws {
         let locale = Locale(identifier: "es_ES")
 
-        Purchases.shared.track(
+        let data = Self.customerCenterCreationData
+        let task0 = Purchases.shared.track(
             customerCenterEvent: CustomerCenterEvent.impression(
-                Self.customerCenterCreationData,
+                data,
                 CustomerCenterEvent.Data(
                     locale: locale,
                     darkMode: true,
@@ -60,9 +61,9 @@ final class EventsManagerIntegrationTests: BaseBackendIntegrationTests {
             )
         )
 
-        Purchases.shared.track(
+        let task1 = Purchases.shared.track(
             customerCenterEvent: CustomerCenterAnswerSubmittedEvent.answerSubmitted(
-                Self.customerCenterCreationData,
+                data,
                 CustomerCenterAnswerSubmittedEvent.Data(
                     locale: locale,
                     darkMode: true,
@@ -76,13 +77,13 @@ final class EventsManagerIntegrationTests: BaseBackendIntegrationTests {
             )
         )
         // give background task a chance to run
-        await Task.yield()
+        _ = await (task0.value, task1.value)
 
-        try await self.logger.verifyMessageIsEventuallyLogged(
-            "Storing event:",
-            expectedCount: 2,
-            timeout: .seconds(3),
-            pollInterval: .seconds(1)
+        self.logger.verifyMessageWasLogged(
+            regexPattern: "Storing event:.*impression.*\(data.id.uuidString)"
+        )
+        self.logger.verifyMessageWasLogged(
+            regexPattern: "Storing event:.*answer_submitted.*\(data.id.uuidString)"
         )
 
         try await flushAndVerify(eventsCount: 2)

Tests/UnitTests/Mocks/MockOperationDispatcher.swift

@@ -80,26 +80,31 @@ class MockOperationDispatcher: OperationDispatcher {
     var invokedDispatchAsyncOnWorkerThreadCount = 0
     var invokedDispatchAsyncOnWorkerThreadDelayParam: JitterableDelay?
 
+    @discardableResult
     override func dispatchOnWorkerThread(
         jitterableDelay delay: JitterableDelay = .none,
         block: @escaping @Sendable () async -> Void
-    ) {
+    ) -> Task<Void, Never> {
         self.invokedDispatchAsyncOnWorkerThreadDelayParam = delay
         self.invokedDispatchAsyncOnWorkerThread = true
         self.invokedDispatchAsyncOnWorkerThreadCount += 1
 
         if self.forwardToOriginalDispatchOnWorkerThread {
-            super.dispatchOnWorkerThread(jitterableDelay: delay, block: block)
+            return super.dispatchOnWorkerThread(jitterableDelay: delay, block: block)
         } else if self.shouldInvokeDispatchOnWorkerThreadBlock {
             // We want to wait for the async task to finish before leaving this function
             // Use a dispatch group to wait for the async task to finish    
             let dispatchGroup = DispatchGroup()
             dispatchGroup.enter()
 
+            let task: Task<Void, Never> = Task {
+                await block()
+            }
+
             // Execute the async task on a background queue to avoid blocking
             DispatchQueue.global(qos: .userInitiated).async {
                 Task {
-                    await block()
+                    await task.value
                     dispatchGroup.leave()
                 }
             }
@@ -110,6 +115,9 @@ class MockOperationDispatcher: OperationDispatcher {
             if result == .timedOut {
                 XCTFail("Dispatch on worker thread timed out")
             }
+            return task
+        } else {
+            return super.dispatchOnWorkerThread(jitterableDelay: delay, block: block)
         }
     }