Add MessengerWaitForNetwork functor

Sources/XXMessengerClient/Messenger/Functors/MessengerWaitForNetwork.swift

+import XXClient
+import XCTestDynamicOverlay
+
+public struct MessengerWaitForNetwork {
+  public enum Error: Swift.Error {
+    case notLoaded
+    case timeout
+  }
+
+  public var run: (Int) throws -> Void
+
+  public func callAsFunction(
+    timeoutMS: Int = 30_000
+  ) throws {
+    try run(timeoutMS)
+  }
+}
+
+extension MessengerWaitForNetwork {
+  public static func live(_ env: MessengerEnvironment) -> MessengerWaitForNetwork {
+    MessengerWaitForNetwork { timeoutMS in
+      guard let cMix = env.ctx.getCMix() else {
+        throw Error.notLoaded
+      }
+      guard cMix.waitForNetwork(timeoutMS: timeoutMS) else {
+        throw Error.timeout
+      }
+    }
+  }
+}
+
+extension MessengerWaitForNetwork {
+  public static let unimplemented = MessengerWaitForNetwork(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Messenger.swift

@@ -15,6 +15,7 @@ public struct Messenger {
   public var register: MessengerRegister
   public var isLoggedIn: MessengerIsLoggedIn
   public var logIn: MessengerLogIn
+  public var waitForNetwork: MessengerWaitForNetwork
 }
 
 extension Messenger {
@@ -33,7 +34,8 @@ extension Messenger {
       isRegistered: .live(env),
       register: .live(env),
       isLoggedIn: .live(env),
-      logIn: .live(env)
+      logIn: .live(env),
+      waitForNetwork: .live(env)
     )
   }
 }
@@ -53,6 +55,7 @@ extension Messenger {
     isRegistered: .unimplemented,
     register: .unimplemented,
     isLoggedIn: .unimplemented,
-    logIn: .unimplemented
+    logIn: .unimplemented,
+    waitForNetwork: .unimplemented
   )
 }

Tests/XXMessengerClientTests/Messenger/Functors/MessengerWaitForNetworkTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerWaitForNetworkTests: XCTestCase {
+  func testWaitSuccess() throws {
+    var didWaitForNetwork: [Int] = []
+
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = {
+      var cMix: CMix = .unimplemented
+      cMix.waitForNetwork.run = { timeoutMS in
+        didWaitForNetwork.append(timeoutMS)
+        return true
+      }
+      return cMix
+    }
+    let waitForNetwork: MessengerWaitForNetwork = .live(env)
+
+    try waitForNetwork(timeoutMS: 123)
+
+    XCTAssertNoDifference(didWaitForNetwork, [123])
+  }
+
+  func testWaitWhenNotLoaded() {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = { nil }
+    let waitForNetwork: MessengerWaitForNetwork = .live(env)
+
+    XCTAssertThrowsError(try waitForNetwork()) { error in
+      XCTAssertEqual(
+        error as? MessengerWaitForNetwork.Error,
+        MessengerWaitForNetwork.Error.notLoaded
+      )
+    }
+  }
+
+  func testWaitTimeout() {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = {
+      var cMix: CMix = .unimplemented
+      cMix.waitForNetwork.run = { _ in false }
+      return cMix
+    }
+    let waitForNetwork: MessengerWaitForNetwork = .live(env)
+
+    XCTAssertThrowsError(try waitForNetwork()) { error in
+      XCTAssertEqual(
+        error as? MessengerWaitForNetwork.Error,
+        MessengerWaitForNetwork.Error.timeout
+      )
+    }
+  }
+}