Add MessengerStart functor

Sources/XXMessengerClient/Messenger/Functors/MessengerStart.swift

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

Sources/XXMessengerClient/Messenger/Messenger.swift

@@ -8,6 +8,7 @@ public struct Messenger {
   public var create: MessengerCreate
   public var isLoaded: MessengerIsLoaded
   public var load: MessengerLoad
+  public var start: MessengerStart
   public var isConnected: MessengerIsConnected
   public var connect: MessengerConnect
   public var isRegistered: MessengerIsRegistered
@@ -26,6 +27,7 @@ extension Messenger {
       create: .live(env),
       isLoaded: .live(env),
       load: .live(env),
+      start: .live(env),
       isConnected: .live(env),
       connect: .live(env),
       isRegistered: .live(env),
@@ -45,6 +47,7 @@ extension Messenger {
     create: .unimplemented,
     isLoaded: .unimplemented,
     load: .unimplemented,
+    start: .unimplemented,
     isConnected: .unimplemented,
     connect: .unimplemented,
     isRegistered: .unimplemented,

Tests/XXMessengerClientTests/Messenger/Functors/MessengerStartTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerStartTests: XCTestCase {
+  func testStart() throws {
+    var didStartNetworkFollower: [Int] = []
+
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = {
+      var cMix: CMix = .unimplemented
+      cMix.networkFollowerStatus.run = { .stopped }
+      cMix.startNetworkFollower.run = { timeoutMS in
+        didStartNetworkFollower.append(timeoutMS)
+      }
+      return cMix
+    }
+    let start: MessengerStart = .live(env)
+
+    try start(timeoutMS: 123)
+
+    XCTAssertNoDifference(didStartNetworkFollower, [123])
+  }
+
+  func testStartWhenNotLoaded() {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = { nil }
+    let start: MessengerStart = .live(env)
+
+    XCTAssertThrowsError(try start()) { error in
+      XCTAssertEqual(
+        error as? MessengerStart.Error,
+        MessengerStart.Error.notLoaded
+      )
+    }
+  }
+
+  func testStartWhenRunning() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = {
+      var cMix: CMix = .unimplemented
+      cMix.networkFollowerStatus.run = { .running }
+      return cMix
+    }
+    let start: MessengerStart = .live(env)
+
+    try start()
+  }
+
+  func testStartNetworkFollowerFailure() {
+    struct Error: Swift.Error, Equatable {}
+    let error = Error()
+
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = {
+      var cMix: CMix = .unimplemented
+      cMix.networkFollowerStatus.run = { .stopped }
+      cMix.startNetworkFollower.run = { _ in throw error }
+      return cMix
+    }
+    let start: MessengerStart = .live(env)
+
+    XCTAssertThrowsError(try start()) { err in
+      XCTAssertEqual(err as? Error, error)
+    }
+  }
+}