allow preventing delayed dispatches from running, or to execute immed…

…iately

Tests/SentryTests/Helper/SentryFileManagerTests.swift

@@ -30,6 +30,7 @@ class SentryFileManagerTests: XCTestCase {
         init() {
             currentDateProvider = TestCurrentDateProvider()
             dispatchQueueWrapper = TestSentryDispatchQueueWrapper()
+            dispatchQueueWrapper.dispatchAfterExecutesBlock = true
 
             eventIds = (0...(maxCacheItems + 10)).map { _ in SentryId() }
 

Tests/SentryTests/Networking/SentryHttpTransportTests.swift

@@ -23,7 +23,11 @@ class SentryHttpTransportTests: XCTestCase {
         let requestManager: TestRequestManager
         let requestBuilder = TestNSURLRequestBuilder()
         let rateLimits: DefaultRateLimits
-        let dispatchQueueWrapper = TestSentryDispatchQueueWrapper()
+        let dispatchQueueWrapper: TestSentryDispatchQueueWrapper = {
+            let dqw = TestSentryDispatchQueueWrapper()
+            dqw.dispatchAfterExecutesBlock = true
+            return dqw
+        }()
         let reachability = TestSentryReachability()
         let flushTimeout: TimeInterval = 0.5
 

Tests/SentryTests/Networking/TestSentryDispatchQueueWrapper.swift

@@ -1,17 +1,25 @@
 import Foundation
 
+/// A wrapper around `SentryDispatchQueueWrapper` that memoized invocations to its methods and allows customization of async logic, specifically: dispatch-after calls can be made to run immediately, or not at all.
 class TestSentryDispatchQueueWrapper: SentryDispatchQueueWrapper {
-    
+
     var dispatchAsyncCalled = 0
-
+
+    /// Whether or not delayed dispatches should execute.
+    /// - SeeAlso: `delayDispatches`, which controls whether the block should execute immediately or with the requested delay.
+    var dispatchAfterExecutesBlock = false
+
+    /// If `true`, delay dispatched block execution by the specified duration. Be sure to set expectations in test code that relies on delayed dispatches.
+    var delayDispatches = false
+
     override func dispatchAsync(_ block: @escaping () -> Void) {
         dispatchAsyncCalled += 1
         block()
     }
-    
+
     var blockOnMainInvocations = Invocations<() -> Void>()
     var blockBeforeMainBlock: () -> Bool = { true }
-    
+
     override func dispatchAsync(onMainQueue block: @escaping () -> Void) {
         blockOnMainInvocations.record(block)
         if blockBeforeMainBlock() {
@@ -25,24 +33,30 @@ class TestSentryDispatchQueueWrapper: SentryDispatchQueueWrapper {
             block()
         }
     }
-    
+
     var dispatchAfterInvocations = Invocations<(interval: TimeInterval, block: () -> Void)>()
     override func dispatch(after interval: TimeInterval, block: @escaping () -> Void) {
         dispatchAfterInvocations.record((interval, block))
         if blockBeforeMainBlock() {
-            block()
+            if dispatchAfterExecutesBlock {
+                if delayDispatches {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + interval, execute: .init(block: block))
+                } else {
+                    block()
+                }
+            }
         }
     }
-    
+
     func invokeLastDispatchAfter() {
         dispatchAfterInvocations.invocations.last?.block()
     }
-    
+
     var dispatchCancelInvocations = Invocations<() -> Void>()
     override func dispatchCancel(_ block: @escaping () -> Void) {
         dispatchCancelInvocations.record(block)
     }
-    
+
     override func dispatchOnce(_ predicate: UnsafeMutablePointer<Int>, block: @escaping () -> Void) {
         block()
     }