Added presence tests.

Author: maratal

Sources/AblyChat/Dependencies.swift

@@ -25,6 +25,8 @@ public protocol RealtimeChannelsProtocol: ARTRealtimeChannelsProtocol, Sendable
 /// Expresses the requirements of the object returned by ``RealtimeChannelsProtocol/get(_:options:)``.
 public protocol RealtimeChannelProtocol: ARTRealtimeChannelProtocol, Sendable {}
 
+public protocol RealtimePresenceProtocol: ARTRealtimePresenceProtocol, Sendable {}
+
 public protocol ConnectionProtocol: ARTConnectionProtocol, Sendable {}
 
 /// Like (a subset of) `ARTRealtimeChannelOptions` but with value semantics. (It’s unfortunate that `ARTRealtimeChannelOptions` doesn’t have a `-copy` method.)

Sources/AblyChat/RoomFeature.swift

@@ -63,7 +63,7 @@ internal protocol FeatureChannel: Sendable, EmitsDiscontinuities {
 
 internal struct DefaultFeatureChannel: FeatureChannel {
     internal var channel: RealtimeChannelProtocol
-    internal var contributor: DefaultRoomLifecycleContributor
+    internal var contributor: any RoomLifecycleContributor & EmitsDiscontinuities
     internal var roomLifecycleManager: RoomLifecycleManager
 
     internal func onDiscontinuity(bufferingPolicy: BufferingPolicy) async -> Subscription<DiscontinuityEvent> {

Tests/AblyChatTests/DefaultMessagesTests.swift

@@ -10,7 +10,7 @@ struct DefaultMessagesTests {
         // Given
         let realtime = MockRealtime.create()
         let chatAPI = ChatAPI(realtime: realtime)
-        let channel = MockRealtimeChannel()
+        let channel = MockRealtimeChannel(attachResult: .success)
         let featureChannel = MockFeatureChannel(channel: channel)
         let defaultMessages = await DefaultMessages(featureChannel: featureChannel, chatAPI: chatAPI, roomID: "basketball", clientID: "clientId", logger: TestLogger())
 
@@ -28,7 +28,7 @@ struct DefaultMessagesTests {
         // Given
         let realtime = MockRealtime.create { (MockHTTPPaginatedResponse.successGetMessagesWithNoItems, nil) }
         let chatAPI = ChatAPI(realtime: realtime)
-        let channel = MockRealtimeChannel()
+        let channel = MockRealtimeChannel(attachResult: .success)
         let featureChannel = MockFeatureChannel(channel: channel)
         let defaultMessages = await DefaultMessages(featureChannel: featureChannel, chatAPI: chatAPI, roomID: "basketball", clientID: "clientId", logger: TestLogger())
 
@@ -52,7 +52,8 @@ struct DefaultMessagesTests {
             properties: .init(
                 attachSerial: "001",
                 channelSerial: "001"
-            )
+            ),
+            attachResult: .success
         )
         let featureChannel = MockFeatureChannel(channel: channel)
         let defaultMessages = await DefaultMessages(featureChannel: featureChannel, chatAPI: chatAPI, roomID: "basketball", clientID: "clientId", logger: TestLogger())
@@ -80,6 +81,7 @@ struct DefaultMessagesTests {
                 attachSerial: "001",
                 channelSerial: "001"
             ),
+            attachResult: .success,
             messageToEmitOnSubscribe: .init(
                 action: .create, // arbitrary
                 serial: "", // arbitrary
@@ -114,6 +116,7 @@ struct DefaultMessagesTests {
                 attachSerial: "001",
                 channelSerial: "001"
             ),
+            attachResult: .success,
             messageToEmitOnSubscribe: .init(
                 action: .create, // arbitrary
                 serial: "", // arbitrary
@@ -142,7 +145,7 @@ struct DefaultMessagesTests {
         // Given: A DefaultMessages instance
         let realtime = MockRealtime.create()
         let chatAPI = ChatAPI(realtime: realtime)
-        let channel = MockRealtimeChannel()
+        let channel = MockRealtimeChannel(attachResult: .success)
         let featureChannel = MockFeatureChannel(channel: channel)
         let messages = await DefaultMessages(featureChannel: featureChannel, chatAPI: chatAPI, roomID: "basketball", clientID: "clientId", logger: TestLogger())
 

Tests/AblyChatTests/DefaultRoomPresenceTests.swift

@@ -21,3 +21,62 @@ func isChatError(_ maybeError: (any Error)?, withCodeAndStatusCode codeAndStatus
             return ablyError.message == message
         }()
 }
+
+extension ARTPresenceMessage {
+    convenience init(clientId: String, data: Any? = [:], timestamp: Date = Date()) {
+        self.init()
+        self.clientId = clientId
+        self.data = data
+        self.timestamp = timestamp
+    }
+}
+
+extension [PresenceEventType] {
+    static let all = [
+        PresenceEventType.present,
+        PresenceEventType.enter,
+        PresenceEventType.leave,
+        PresenceEventType.update,
+    ]
+}
+
+enum RoomLifecycleHelper {
+    static let fakeNetworkDelay: UInt64 = 10 // milliseconds; without this delay (or with a very low value such as 1) most of the time attach happens before lifecycleManager has a chance to start waiting.
+
+    static func createManager(
+        forTestingWhatHappensWhenCurrentlyIn status: DefaultRoomLifecycleManager<MockRoomLifecycleContributor>.Status? = nil,
+        forTestingWhatHappensWhenHasPendingDiscontinuityEvents pendingDiscontinuityEvents: [MockRoomLifecycleContributor.ID: DiscontinuityEvent]? = nil,
+        forTestingWhatHappensWhenHasTransientDisconnectTimeoutForTheseContributorIDs idsOfContributorsWithTransientDisconnectTimeout: Set<MockRoomLifecycleContributor.ID>? = nil,
+        contributors: [MockRoomLifecycleContributor] = [],
+        clock: SimpleClock = MockSimpleClock()
+    ) async -> DefaultRoomLifecycleManager<MockRoomLifecycleContributor> {
+        await .init(
+            testsOnly_status: status,
+            testsOnly_pendingDiscontinuityEvents: pendingDiscontinuityEvents,
+            testsOnly_idsOfContributorsWithTransientDisconnectTimeout: idsOfContributorsWithTransientDisconnectTimeout,
+            contributors: contributors,
+            logger: TestLogger(),
+            clock: clock
+        )
+    }
+
+    static func createContributor(
+        initialState: ARTRealtimeChannelState = .initialized,
+        initialErrorReason: ARTErrorInfo? = nil,
+        feature: RoomFeature = .messages, // Arbitrarily chosen, its value only matters in test cases where we check which error is thrown
+        attachBehavior: MockRoomLifecycleContributorChannel.AttachOrDetachBehavior? = nil,
+        detachBehavior: MockRoomLifecycleContributorChannel.AttachOrDetachBehavior? = nil,
+        subscribeToStateBehavior: MockRoomLifecycleContributorChannel.SubscribeToStateBehavior? = nil
+    ) -> MockRoomLifecycleContributor {
+        .init(
+            feature: feature,
+            channel: .init(
+                initialState: initialState,
+                initialErrorReason: initialErrorReason,
+                attachBehavior: attachBehavior,
+                detachBehavior: detachBehavior,
+                subscribeToStateBehavior: subscribeToStateBehavior
+            )
+        )
+    }
+}

Tests/AblyChatTests/Helpers/Helpers.swift

@@ -2,16 +2,15 @@ import Ably
 import AblyChat
 
 final class MockRealtimeChannel: NSObject, RealtimeChannelProtocol {
-    var presence: ARTRealtimePresenceProtocol {
-        fatalError("Not implemented")
-    }
-
     private let attachSerial: String?
     private let channelSerial: String?
     private let _name: String?
+    private let mockPresence: MockRealtimePresence!
 
     var properties: ARTChannelProperties { .init(attachSerial: attachSerial, channelSerial: channelSerial) }
 
+    var presence: ARTRealtimePresenceProtocol { mockPresence }
+
     // I don't see why the nonisolated(unsafe) keyword would cause a problem when used for tests in this context.
     nonisolated(unsafe) var lastMessagePublishedName: String?
     nonisolated(unsafe) var lastMessagePublishedData: Any?
@@ -32,14 +31,16 @@ final class MockRealtimeChannel: NSObject, RealtimeChannelProtocol {
         state _: ARTRealtimeChannelState = .suspended,
         attachResult: AttachOrDetachResult? = nil,
         detachResult: AttachOrDetachResult? = nil,
-        messageToEmitOnSubscribe: MessageToEmit? = nil
+        messageToEmitOnSubscribe: MessageToEmit? = nil,
+        mockPresence: MockRealtimePresence! = nil
     ) {
         _name = name
         self.attachResult = attachResult
         self.detachResult = detachResult
         self.messageToEmitOnSubscribe = messageToEmitOnSubscribe
         attachSerial = properties.attachSerial
         channelSerial = properties.channelSerial
+        self.mockPresence = mockPresence
     }
 
     /// A threadsafe counter that starts at zero.
@@ -71,7 +72,7 @@ final class MockRealtimeChannel: NSObject, RealtimeChannelProtocol {
     }
 
     var state: ARTRealtimeChannelState {
-        .attached
+        attachResult == .success ? .attached : .failed
     }
 
     var errorReason: ARTErrorInfo? {
@@ -86,7 +87,7 @@ final class MockRealtimeChannel: NSObject, RealtimeChannelProtocol {
         fatalError("Not implemented")
     }
 
-    enum AttachOrDetachResult {
+    enum AttachOrDetachResult: Equatable {
         case success
         case failure(ARTErrorInfo)
 
@@ -183,7 +184,7 @@ final class MockRealtimeChannel: NSObject, RealtimeChannelProtocol {
     }
 
     func on(_: @escaping (ARTChannelStateChange) -> Void) -> ARTEventListener {
-        fatalError("Not implemented")
+        ARTEventListener()
     }
 
     func once(_: ARTChannelEvent, callback _: @escaping (ARTChannelStateChange) -> Void) -> ARTEventListener {

Tests/AblyChatTests/Mocks/MockRealtimeChannel.swift

@@ -0,0 +1,128 @@
+import Ably
+import AblyChat
+
+final class MockRealtimePresence: NSObject, @unchecked Sendable, RealtimePresenceProtocol {
+    let syncComplete: Bool
+    private var members: [ARTPresenceMessage]
+    private var currentMember: ARTPresenceMessage?
+    private var subscribeCallback: ARTPresenceMessageCallback?
+    private var presenceGetError: ARTErrorInfo?
+
+    init(syncComplete: Bool = true, members: [ARTPresenceMessage], presenceGetError: ARTErrorInfo? = nil) {
+        self.syncComplete = syncComplete
+        self.members = members
+        currentMember = members.count == 1 ? members[0] : nil
+        self.presenceGetError = presenceGetError
+    }
+
+    func get(_ callback: @escaping ARTPresenceMessagesCallback) {
+        callback(presenceGetError == nil ? members : nil, presenceGetError)
+    }
+
+    func get(_ query: ARTRealtimePresenceQuery, callback: @escaping ARTPresenceMessagesCallback) {
+        callback(members.filter { $0.clientId == query.clientId }, nil)
+    }
+
+    func enter(_: Any?) {
+        fatalError("Not implemented")
+    }
+
+    func enter(_: Any?, callback _: ARTCallback? = nil) {
+        fatalError("Not implemented")
+    }
+
+    func update(_ data: Any?) {
+        currentMember?.data = data
+    }
+
+    func update(_ data: Any?, callback: ARTCallback? = nil) {
+        currentMember?.data = data
+        callback?(nil)
+    }
+
+    func leave(_: Any?) {
+        members.removeAll { $0.clientId == currentMember?.clientId }
+    }
+
+    func leave(_: Any?, callback: ARTCallback? = nil) {
+        members.removeAll { $0.clientId == currentMember?.clientId }
+        callback?(nil)
+    }
+
+    func enterClient(_ clientId: String, data: Any?) {
+        currentMember = ARTPresenceMessage(clientId: clientId, data: data)
+        members.append(currentMember!)
+        currentMember!.action = .enter
+        subscribeCallback?(currentMember!)
+    }
+
+    func enterClient(_ clientId: String, data: Any?, callback: ARTCallback? = nil) {
+        currentMember = ARTPresenceMessage(clientId: clientId, data: data)
+        members.append(currentMember!)
+        callback?(nil)
+        currentMember!.action = .enter
+        subscribeCallback?(currentMember!)
+    }
+
+    func updateClient(_ clientId: String, data: Any?) {
+        members.first { $0.clientId == clientId }?.data = data
+    }
+
+    func updateClient(_ clientId: String, data: Any?, callback: ARTCallback? = nil) {
+        guard let member = members.first(where: { $0.clientId == clientId }) else {
+            preconditionFailure("Client \(clientId) doesn't exist in this presence set.")
+        }
+        member.action = .update
+        member.data = data
+        subscribeCallback?(member)
+        callback?(nil)
+    }
+
+    func leaveClient(_ clientId: String, data _: Any?) {
+        members.removeAll { $0.clientId == clientId }
+    }
+
+    func leaveClient(_ clientId: String, data _: Any?, callback _: ARTCallback? = nil) {
+        members.removeAll { $0.clientId == clientId }
+    }
+
+    func subscribe(_ callback: @escaping ARTPresenceMessageCallback) -> ARTEventListener? {
+        subscribeCallback = callback
+        for member in members {
+            subscribeCallback?(member)
+        }
+        return ARTEventListener()
+    }
+
+    func subscribe(attachCallback _: ARTCallback?, callback _: @escaping ARTPresenceMessageCallback) -> ARTEventListener? {
+        ARTEventListener()
+    }
+
+    func subscribe(_: ARTPresenceAction, callback _: @escaping ARTPresenceMessageCallback) -> ARTEventListener? {
+        ARTEventListener()
+    }
+
+    func subscribe(_: ARTPresenceAction, onAttach _: ARTCallback?, callback _: @escaping ARTPresenceMessageCallback) -> ARTEventListener? {
+        ARTEventListener()
+    }
+
+    func unsubscribe() {
+        fatalError("Not implemented")
+    }
+
+    func unsubscribe(_: ARTEventListener) {
+        subscribeCallback = nil
+    }
+
+    func unsubscribe(_: ARTPresenceAction, listener _: ARTEventListener) {
+        fatalError("Not implemented")
+    }
+
+    func history(_: @escaping ARTPaginatedPresenceCallback) {
+        fatalError("Not implemented")
+    }
+
+    func history(_: ARTRealtimeHistoryQuery?, callback _: @escaping ARTPaginatedPresenceCallback) throws {
+        fatalError("Not implemented")
+    }
+}

Tests/AblyChatTests/Mocks/MockRealtimePresence.swift

@@ -1,7 +1,7 @@
 import Ably
 @testable import AblyChat
 
-actor MockRoomLifecycleContributor: RoomLifecycleContributor {
+actor MockRoomLifecycleContributor: RoomLifecycleContributor, EmitsDiscontinuities {
     nonisolated let feature: RoomFeature
     nonisolated let channel: MockRoomLifecycleContributorChannel
 
@@ -15,4 +15,8 @@ actor MockRoomLifecycleContributor: RoomLifecycleContributor {
     func emitDiscontinuity(_ discontinuity: DiscontinuityEvent) async {
         emitDiscontinuityArguments.append(discontinuity)
     }
+
+    func onDiscontinuity(bufferingPolicy _: AblyChat.BufferingPolicy) async -> AblyChat.Subscription<AblyChat.DiscontinuityEvent> {
+        fatalError("Not implemented")
+    }
 }

Tests/AblyChatTests/Mocks/MockRoomLifecycleContributor.swift

@@ -45,7 +45,7 @@ final actor MockRoomLifecycleContributorChannel: RoomLifecycleContributorChannel
         /// Receives an argument indicating how many times (including the current call) the method for which this is providing a mock implementation has been called.
         case fromFunction(@Sendable (Int) async -> AttachOrDetachBehavior)
         case complete(AttachOrDetachResult)
-        case completeAndChangeState(AttachOrDetachResult, newState: ARTRealtimeChannelState)
+        case completeAndChangeState(AttachOrDetachResult, newState: ARTRealtimeChannelState, delayInMilliseconds: UInt64 = 0) // emulating network delay before going to the new state
 
         static var success: Self {
             .complete(.success)
@@ -90,7 +90,10 @@ final actor MockRoomLifecycleContributorChannel: RoomLifecycleContributorChannel
             return
         case let .complete(completeResult):
             result = completeResult
-        case let .completeAndChangeState(completeResult, newState):
+        case let .completeAndChangeState(completeResult, newState, milliseconds):
+            if milliseconds > 0 {
+                try! await Task.sleep(nanoseconds: milliseconds * 1_000_000)
+            }
             state = newState
             if case let .failure(error) = completeResult {
                 errorReason = error