Add MessengerCMix, MessengerE2E, and MessengerUD

Functors for accessing XXClient components

Sources/XXMessengerClient/Messenger/Functors/MessengerCMix.swift

+import XXClient
+import XCTestDynamicOverlay
+
+public struct MessengerCMix {
+  public var run: () -> CMix?
+
+  public func callAsFunction() -> CMix? {
+    run()
+  }
+}
+
+extension MessengerCMix {
+  public static func live(_ env: MessengerEnvironment) -> MessengerCMix {
+    MessengerCMix(run: env.ctx.getCMix)
+  }
+}
+
+extension MessengerCMix {
+  public static let unimplemented = MessengerCMix(
+    run: XCTUnimplemented("\(Self.self)", placeholder: nil)
+  )
+}

Sources/XXMessengerClient/Messenger/Functors/MessengerE2E.swift

+import XXClient
+import XCTestDynamicOverlay
+
+public struct MessengerE2E {
+  public var run: () -> E2E?
+
+  public func callAsFunction() -> E2E? {
+    run()
+  }
+}
+
+extension MessengerE2E {
+  public static func live(_ env: MessengerEnvironment) -> MessengerE2E {
+    MessengerE2E(run: env.ctx.getE2E)
+  }
+}
+
+extension MessengerE2E {
+  public static let unimplemented = MessengerE2E(
+    run: XCTUnimplemented("\(Self.self)", placeholder: nil)
+  )
+}

Sources/XXMessengerClient/Messenger/Functors/MessengerUD.swift

+import XXClient
+import XCTestDynamicOverlay
+
+public struct MessengerUD {
+  public var run: () -> UserDiscovery?
+
+  public func callAsFunction() -> UserDiscovery? {
+    run()
+  }
+}
+
+extension MessengerUD {
+  public static func live(_ env: MessengerEnvironment) -> MessengerUD {
+    MessengerUD(run: env.ctx.getUD)
+  }
+}
+
+extension MessengerUD {
+  public static let unimplemented = MessengerUD(
+    run: XCTUnimplemented("\(Self.self)", placeholder: nil)
+  )
+}

Sources/XXMessengerClient/Messenger/Messenger.swift

 import XXClient
 
 public struct Messenger {
+  public var cMix: MessengerCMix
+  public var e2e: MessengerE2E
+  public var ud: MessengerUD
   public var isCreated: MessengerIsCreated
   public var create: MessengerCreate
   public var isLoaded: MessengerIsLoaded
@@ -16,6 +19,9 @@ public struct Messenger {
 extension Messenger {
   public static func live(_ env: MessengerEnvironment) -> Messenger {
     Messenger(
+      cMix: .live(env),
+      e2e: .live(env),
+      ud: .live(env),
       isCreated: .live(env),
       create: .live(env),
       isLoaded: .live(env),
@@ -32,6 +38,9 @@ extension Messenger {
 
 extension Messenger {
   public static let unimplemented = Messenger(
+    cMix: .unimplemented,
+    e2e: .unimplemented,
+    ud: .unimplemented,
     isCreated: .unimplemented,
     create: .unimplemented,
     isLoaded: .unimplemented,

Tests/XXMessengerClientTests/Messenger/Functors/MessengerCMixTests.swift

+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerCMixTests: XCTestCase {
+  func testCMix() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = { .unimplemented }
+    let cMix: MessengerCMix = .live(env)
+
+    XCTAssertNotNil(cMix())
+  }
+
+  func testCMixWhenNotSet() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getCMix = { nil }
+    let cMix: MessengerCMix = .live(env)
+
+    XCTAssertNil(cMix())
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functors/MessengerE2ETests.swift

+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerE2ETests: XCTestCase {
+  func testE2E() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getE2E = { .unimplemented }
+    let e2e: MessengerE2E = .live(env)
+
+    XCTAssertNotNil(e2e())
+  }
+
+  func testE2EWhenNotSet() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getE2E = { nil }
+    let e2e: MessengerE2E = .live(env)
+
+    XCTAssertNil(e2e())
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functors/MessengerUDTests.swift

+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerUDTests: XCTestCase {
+  func testUD() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getE2E = { .unimplemented }
+    let e2e: MessengerE2E = .live(env)
+
+    XCTAssertNotNil(e2e())
+  }
+
+  func testE2EWhenNotSet() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.ctx.getE2E = { nil }
+    let e2e: MessengerE2E = .live(env)
+
+    XCTAssertNil(e2e())
+  }
+}