Add reaction tests.

Author: maratal

Sources/AblyChat/DefaultRoomReactions.swift

@@ -11,6 +11,7 @@ internal final class DefaultRoomReactions: RoomReactions {
         try await implementation.send(params: params)
     }
 
+    @discardableResult
     internal func subscribe(_ callback: @escaping @MainActor (Reaction) -> Void) -> SubscriptionHandle {
         implementation.subscribe(callback)
     }

Tests/AblyChatTests/DefaultRoomReactionsTests.swift

@@ -29,20 +29,72 @@ struct DefaultRoomReactionsTests {
         #expect(channel.publishedMessages.last?.extras == ["headers": ["someHeadersKey": "someHeadersValue"], "ephemeral": true])
     }
 
-    // @spec CHA-ER4
+    // @spec CHA-ER4a
+    // @spec CHA-ER4b
     @Test
-    func subscribe_returnsSubscription() async throws {
-        // all setup values here are arbitrary
+    func subscriptionCanBeRegisteredToReceiveReactionEvents() async throws {
         // Given
-        let channel = MockRealtimeChannel(name: "basketball::$chat")
+        func generateMessage(serial: String, reactionType: String) -> ARTMessage {
+            let message = ARTMessage()
+            message.action = .create // arbitrary
+            message.serial = serial // arbitrary
+            message.clientId = "" // arbitrary
+            message.data = [
+                "type": reactionType,
+            ]
+            message.version = "0"
+            return message
+        }
 
-        // When
+        let channel = MockRealtimeChannel(
+            messageToEmitOnSubscribe: generateMessage(serial: "1", reactionType: ":like:")
+        )
         let defaultRoomReactions = DefaultRoomReactions(channel: channel, clientID: "mockClientId", roomID: "basketball", logger: TestLogger())
 
         // When
-        let subscription: Subscription<Reaction>? = defaultRoomReactions.subscribe()
+        let subscriptionHandle = defaultRoomReactions.subscribe { reaction in
+            // Then
+            #expect(reaction.type == ":like:")
+        }
 
-        // Then
-        #expect(subscription != nil)
+        // CHA-ER4b
+        subscriptionHandle.unsubscribe()
+
+        // will not be received and expectations above will not fail
+        channel.simulateIncomingMessage(
+            generateMessage(serial: "2", reactionType: ":dislike:"),
+            for: RoomReactionEvents.reaction.rawValue
+        )
+    }
+
+    // CHA-ER4c is currently untestable due to not subscribing to those events on lower level
+    // @spec CHA-ER4d
+    @Test
+    func malformedRealtimeEventsShallNotBeEmittedToSubscribers() async throws {
+        // Given
+        let channel = MockRealtimeChannel(
+            messageJSONToEmitOnSubscribe: [
+                "foo": "bar", // malformed reaction message
+            ],
+            messageToEmitOnSubscribe: {
+                let message = ARTMessage()
+                message.action = .create // arbitrary
+                message.serial = "123" // arbitrary
+                message.clientId = "" // arbitrary
+                message.data = [
+                    "type": ":like:",
+                ]
+                message.extras = [:] as any ARTJsonCompatible
+                message.version = "0"
+                return message
+            }()
+        )
+        let defaultRoomReactions = DefaultRoomReactions(channel: channel, clientID: "mockClientId", roomID: "basketball", logger: TestLogger())
+
+        // When
+        defaultRoomReactions.subscribe { reaction in
+            // Then: `messageJSONToEmitOnSubscribe` is processed ahead of `messageToEmitOnSubscribe` in the mock, but the first message is not the malformed one
+            #expect(reaction.type == ":like:")
+        }
     }
 }

Tests/AblyChatTests/Mocks/MockRealtimeChannel.swift

@@ -29,7 +29,7 @@ final class MockRealtimeChannel: InternalRealtimeChannelProtocol {
         initialErrorReason: ARTErrorInfo? = nil,
         attachBehavior: AttachOrDetachBehavior? = nil,
         detachBehavior: AttachOrDetachBehavior? = nil,
-        messageJSONToEmitOnSubscribe: [String: Sendable]? = nil,
+        messageJSONToEmitOnSubscribe: [String: JSONValue]? = nil,
         messageToEmitOnSubscribe: ARTMessage? = nil,
         stateChangeToEmitForListener: ARTChannelStateChange? = nil
     ) {
@@ -133,28 +133,28 @@ final class MockRealtimeChannel: InternalRealtimeChannelProtocol {
         try result.get()
     }
 
-    let messageJSONToEmitOnSubscribe: [String: Sendable]?
+    let messageJSONToEmitOnSubscribe: [String: JSONValue]?
     let messageToEmitOnSubscribe: ARTMessage?
 
     // Added the ability to emit a message whenever we want instead of just on subscribe... I didn't want to dig into what the messageToEmitOnSubscribe is too much so just if/else between the two.
     private var channelSubscriptions: [(String, (ARTMessage) -> Void)] = []
 
     func subscribe(_ name: String, callback: @escaping @MainActor (ARTMessage) -> Void) -> ARTEventListener? {
         if let json = messageJSONToEmitOnSubscribe {
-            let message = ARTMessage(name: nil, data: json["data"] ?? "")
-            if let action = json["action"] as? UInt {
+            let message = ARTMessage(name: nil, data: json["data"]?.toAblyCocoaData ?? "")
+            if let action = json["action"]?.numberValue as? UInt {
                 message.action = ARTMessageAction(rawValue: action) ?? .create
             }
-            if let serial = json["serial"] as? String {
+            if let serial = json["serial"]?.stringValue {
                 message.serial = serial
             }
-            if let clientId = json["clientId"] as? String {
+            if let clientId = json["clientId"]?.stringValue {
                 message.clientId = clientId
             }
-            if let extras = json["extras"] as? ARTJsonCompatible {
+            if let extras = json["extras"]?.objectValue?.toARTJsonCompatible {
                 message.extras = extras
             }
-            if let ts = json["timestamp"] as? String {
+            if let ts = json["timestamp"]?.stringValue {
                 message.timestamp = Date(timeIntervalSince1970: TimeInterval(ts)!)
             }
             callback(message)