#158: Use abstraction for send messages

src/main/kotlin/chatroom/sendmessages/SendMessagePresenter.kt

@@ -4,13 +4,14 @@ import arch.Presenter
 import arch.RokyDispatchers
 import chatroom.sendmessages.SendMessageEvent.SendMessage
 import chatroom.sendmessages.SendMessageViewState.Clear
+import chatserver.WriteChatRepository
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
 class SendMessagePresenter(
     private val windowScope: CoroutineScope,
-    private val send: (String) -> Unit = ::println,
+    private val message: WriteChatRepository<String>,
     dispatchers: RokyDispatchers,
 ) : Presenter<SendMessagesView>(dispatchers) {
     override fun onAttach(view: SendMessagesView) {
@@ -24,7 +25,7 @@ class SendMessagePresenter(
     fun onEvent(event: SendMessageEvent) {
         if (event is SendMessage) {
             windowScope.launch(dispatchers.io) {
-                send(event.message)
+                message.write(event.message)
                 withContext(dispatchers.main) {
                     withView { it.show(Clear) }
                 }

src/main/kotlin/chatroom/sendmessages/SendMessages.kt

@@ -1,6 +1,7 @@
 package chatroom.sendmessages
 
 import chatroom.ChatroomWindow
+import chatserver.ChatRepositories
 import org.koin.dsl.module
 
 val sendMessagesModule =
@@ -9,6 +10,7 @@ val sendMessagesModule =
             scoped {
                 SendMessagePresenter(
                     dispatchers = get(),
+                    message = get<ChatRepositories>().writeMessages(),
                     windowScope = get<ChatroomWindow>().windowScope,
                 )
             }

src/main/kotlin/chatserver/ChatRepositories.kt

@@ -16,4 +16,6 @@ class ChatRepositories(
     fun readMessages(): ReadChatRepository<ChatMessageResult> = messages
 
     fun subscribeMessages(): SubscribeChatRepository = messages
+
+    fun writeMessages(): WriteChatRepository<String> = messages
 }

src/main/kotlin/chatserver/messages/LocalChatMessages.kt

@@ -4,6 +4,7 @@ import arch.RokyDispatchers
 import chatserver.ChatMessageResult
 import chatserver.ReadChatRepository
 import chatserver.SubscribeChatRepository
+import chatserver.WriteChatRepository
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -15,7 +16,7 @@ class LocalChatMessages(
     private val dispatchers: RokyDispatchers,
     private val scope: CoroutineScope = CoroutineScope(dispatchers.default + Job()),
     private val source: () -> Flow<String> = { emitEveryThreeSeconds(sampleUsers, sampleMessages) },
-) : ReadChatRepository<ChatMessageResult>, SubscribeChatRepository {
+) : ReadChatRepository<ChatMessageResult>, SubscribeChatRepository, WriteChatRepository<String> {
     private var samples: Job? = null
     private val _events = MutableStateFlow("")
     private val events = _events.asStateFlow()
@@ -89,4 +90,8 @@ class LocalChatMessages(
             }
         }
     }
+
+    override fun write(item: String) {
+        _events.value = "Me: $item"
+    }
 }

src/test/kotlin/chatserver/messages/LocalChatMessagesTest.kt

@@ -82,6 +82,25 @@ class LocalChatMessagesTest {
             messages.unsubscribe()
         }
 
+    @Test
+    fun `when writing message, then receive same message`() =
+        runTest(dispatcher) {
+            messages = LocalChatMessages(dispatchers, scope) { flowOf() }
+
+            val emissions = mutableListOf<String>()
+            backgroundScope.launch {
+                messages.observe().map { it.item }.collect(emissions::add)
+            }
+            messages.subscribe()
+            advanceTimeBy(10.seconds)
+            messages.write("Barry is the best.")
+
+            advanceTimeBy(10.seconds)
+
+            emissions.shouldContainInOrder("", "Me: Barry is the best.")
+            messages.unsubscribe()
+        }
+
     companion object {
         private val dispatcher = StandardTestDispatcher()
         private val dispatchers: RokyDispatchers