Add MessengerListenForMessages function

Sources/XXMessengerClient/Messenger/Functions/MessengerListenForMessages.swift

+import XCTestDynamicOverlay
+import XXClient
+
+public struct MessengerListenForMessages {
+  public enum Error: Swift.Error {
+    case notConnected
+  }
+
+  public var run: () throws -> Void
+
+  public func callAsFunction() throws -> Void {
+    try run()
+  }
+}
+
+extension MessengerListenForMessages {
+  public static func live(_ env: MessengerEnvironment) -> MessengerListenForMessages {
+    MessengerListenForMessages {
+      guard let e2e = env.e2e() else {
+        throw Error.notConnected
+      }
+      try e2e.registerListener(
+        senderId: nil,
+        messageType: 2,
+        callback: env.messageListeners.registered()
+      )
+    }
+  }
+}
+
+extension MessengerListenForMessages {
+  public static let unimplemented = MessengerListenForMessages(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerListenForMessagesTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerListenForMessagesTests: XCTestCase {
+  func testListen() throws {
+    struct RegisterListenerParams: Equatable {
+      var senderId: Data?
+      var messageType: Int
+    }
+    var didRegisterListenerWithParams: [RegisterListenerParams] = []
+    var didRegisterListenerWithCallback: [Listener] = []
+    var didHandleMessage: [Message] = []
+
+    var env: MessengerEnvironment = .unimplemented
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.registerListener.run = { senderId, messageType, callback in
+        didRegisterListenerWithParams.append(.init(senderId: senderId, messageType: messageType))
+        didRegisterListenerWithCallback.append(callback)
+      }
+      return e2e
+    }
+    env.messageListeners.registered = {
+      Listener { message in didHandleMessage.append(message) }
+    }
+    let listen: MessengerListenForMessages = .live(env)
+
+    try listen()
+
+    XCTAssertNoDifference(didRegisterListenerWithParams, [
+      .init(senderId: nil, messageType: 2)
+    ])
+
+    let message = Message.stub(123)
+    didRegisterListenerWithCallback.first?.handle(message)
+
+    XCTAssertNoDifference(didHandleMessage, [message])
+  }
+
+  func testListenWhenNotLoggedIn() {
+    var env: MessengerEnvironment = .unimplemented
+    env.e2e.get = { nil }
+    let listen: MessengerListenForMessages = .live(env)
+
+    XCTAssertThrowsError(try listen()) { error in
+      XCTAssertNoDifference(error as? MessengerListenForMessages.Error, .notConnected)
+    }
+  }
+
+  func testListenFailure() {
+    struct Failure: Error, Equatable {}
+    let error = Failure()
+
+    var env: MessengerEnvironment = .unimplemented
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.registerListener.run = { _, _, _ in throw error }
+      return e2e
+    }
+    env.messageListeners.registered = { Listener.unimplemented }
+    let listen: MessengerListenForMessages = .live(env)
+
+    XCTAssertThrowsError(try listen()) { err in
+      XCTAssertNoDifference(err as? Failure, error)
+    }
+  }
+}