[ECO-5196] updated EventTypes.kt, Messages.kt, refactored integration…

… tests

- Added map for messageActionToEventType, used the same for emitting
related message create, update and delete events
- Refactored SandboxTest.kt, moved all of tests under `integration` package.

chat-android/src/main/java/com/ably/chat/EventTypes.kt

@@ -42,6 +42,12 @@ internal val messageActionNameToAction = mapOf(
     "message.summary" to MessageAction.MESSAGE_SUMMARY,
 )
 
+internal val messageActionToEventType = mapOf(
+    MessageAction.MESSAGE_CREATE to MessageEventType.Created,
+    MessageAction.MESSAGE_UPDATE to MessageEventType.Updated,
+    MessageAction.MESSAGE_DELETE to MessageEventType.Deleted,
+)
+
 /**
  * Enum representing presence events.
  */

chat-android/src/main/java/com/ably/chat/Messages.kt

@@ -361,6 +361,8 @@ internal class DefaultMessages(
     override fun subscribe(listener: Messages.Listener): MessagesSubscription {
         val messageListener = PubSubMessageListener {
             val pubSubMessage = it ?: throw clientError("Got empty pubsub channel message")
+            val eventType = messageActionToEventType[pubSubMessage.action]
+                ?: throw clientError("Received Unknown message action ${pubSubMessage.action}")
 
             val data = parsePubSubMessageData(pubSubMessage.data)
             val chatMessage = Message(
@@ -376,8 +378,7 @@ internal class DefaultMessages(
                 timestamp = pubSubMessage.timestamp,
                 operation = pubSubMessage.operation,
             )
-            // TODO - Update to respective event type
-            listener.onEvent(MessageEvent(type = MessageEventType.Created, message = chatMessage))
+            listener.onEvent(MessageEvent(type = eventType, message = chatMessage))
         }
         channelSerialMap[messageListener] = deferredChannelSerial
         // (CHA-M4d)

chat-android/src/test/java/com/ably/chat/integration/ConnectionIntegrationTest.kt

@@ -0,0 +1,40 @@
+package com.ably.chat.integration
+
+import com.ably.chat.ConnectionStatus
+import com.ably.chat.ConnectionStatusChange
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.BeforeClass
+import org.junit.Test
+
+class ConnectionIntegrationTest {
+
+    @Test
+    fun `should observe connection status`() = runTest {
+        val chatClient = sandbox.createSandboxChatClient()
+        val connectionStatusChange = CompletableDeferred<ConnectionStatusChange>()
+        chatClient.connection.onStatusChange {
+            if (it.current == ConnectionStatus.Connected) connectionStatusChange.complete(it)
+        }
+        assertEquals(
+            ConnectionStatusChange(
+                current = ConnectionStatus.Connected,
+                previous = ConnectionStatus.Connecting,
+                error = null,
+                retryIn = 0,
+            ),
+            connectionStatusChange.await(),
+        )
+    }
+
+    companion object {
+        private lateinit var sandbox: Sandbox
+
+        @JvmStatic
+        @BeforeClass
+        fun setUp() = runTest {
+            sandbox = Sandbox.createInstance()
+        }
+    }
+}

chat-android/src/test/java/com/ably/chat/integration/MessagesIntegrationTest.kt

@@ -0,0 +1,100 @@
+package com.ably.chat.integration
+
+import com.ably.chat.Message
+import com.ably.chat.MessageEvent
+import com.ably.chat.MessageMetadata
+import com.ably.chat.RoomOptions
+import com.ably.chat.assertWaiter
+import io.ably.lib.types.MessageAction
+import java.util.UUID
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.BeforeClass
+import org.junit.Test
+
+class MessagesIntegrationTest {
+
+    @Test
+    fun `should be able to send and retrieve messages without room features`() = runTest {
+        val chatClient = sandbox.createSandboxChatClient()
+        val roomId = UUID.randomUUID().toString()
+
+        val room = chatClient.rooms.get(roomId)
+
+        room.attach()
+
+        val messageEvent = CompletableDeferred<MessageEvent>()
+
+        room.messages.subscribe { messageEvent.complete(it) }
+        room.messages.send("hello")
+
+        assertEquals(
+            "hello",
+            messageEvent.await().message.text,
+        )
+    }
+
+    @Test
+    fun `should be able to send and retrieve messages with all room features enabled`() = runTest {
+        val chatClient = sandbox.createSandboxChatClient()
+        val roomId = UUID.randomUUID().toString()
+
+        val room = chatClient.rooms.get(roomId, RoomOptions.default)
+
+        room.attach()
+
+        val messageEvent = CompletableDeferred<MessageEvent>()
+
+        room.messages.subscribe { messageEvent.complete(it) }
+        room.messages.send("hello")
+
+        assertEquals(
+            "hello",
+            messageEvent.await().message.text,
+        )
+    }
+
+    @Test
+    fun `should be able to send and retrieve messages from history`() = runTest {
+        val chatClient = sandbox.createSandboxChatClient()
+        val roomId = UUID.randomUUID().toString()
+
+        val room = chatClient.rooms.get(roomId)
+
+        room.attach()
+        val metadata = MessageMetadata()
+        metadata.addProperty("foo", "bar")
+
+        room.messages.send("hello", metadata)
+
+        lateinit var messages: List<Message>
+
+        assertWaiter {
+            messages = room.messages.get().items
+            messages.isNotEmpty()
+        }
+        assertEquals(1, messages.size)
+        val message = messages.first()
+
+        assertEquals(roomId, message.roomId)
+        assertEquals(MessageAction.MESSAGE_CREATE, message.action)
+        assertEquals("hello", message.text)
+        assertEquals("sandbox-client", message.clientId)
+        assertTrue(message.serial.isNotEmpty())
+        assertEquals(message.serial, message.version)
+        assertEquals(message.createdAt, message.timestamp)
+        assertEquals(metadata.toString(), message.metadata.toString())
+    }
+
+    companion object {
+        private lateinit var sandbox: Sandbox
+
+        @JvmStatic
+        @BeforeClass
+        fun setUp() = runTest {
+            sandbox = Sandbox.createInstance()
+        }
+    }
+}