Pass events back from processors

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

+package com.dmdirc.ktirc.events
+
+sealed class IrcEvent
+object ServerConnected : IrcEvent()

src/main/kotlin/com/dmdirc/ktirc/io/MessageHandler.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.messages.MessageProcessor
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.consumeEach
 
-class MessageHandler(private val processors: Collection<MessageProcessor>) {
+class MessageHandler(private val processors: Collection<MessageProcessor>, private val eventHandler: (IrcEvent) -> Unit) {
 
     suspend fun processMessages(messages: ReceiveChannel<IrcMessage>) {
-        messages.consumeEach { it.process() }
+        messages.consumeEach { it.process().forEach(eventHandler) }
     }
 
-    private fun IrcMessage.process() = this.getProcessor()?.process(this)
+    private fun IrcMessage.process() = this.getProcessor()?.process(this) ?: emptyList()
     private fun IrcMessage.getProcessor() = processors.firstOrNull { it.commands.contains(this.command) }
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/ISupportProcessor.kt

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.state.ServerState
 
     override val commands = arrayOf("005")
 
-    override fun process(message: IrcMessage) {
+    override fun process(message: IrcMessage): List<IrcEvent> {
         // Ignore the first (nickname) and last ("are supported by this server") params
         for (i in 1 until message.params.size - 1) {
             parseParam(message.params[i])
         }
+        return emptyList()
     }
 
     private fun parseParam(param: ByteArray) = when (param[0]) {

src/main/kotlin/com/dmdirc/ktirc/messages/MessageProcessor.kt

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.io.IrcMessage
 
 interface MessageProcessor {
     /**
      * Processes the given message.
      */
-    fun process(message: IrcMessage)
+    fun process(message: IrcMessage): List<IrcEvent>
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessor.kt

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.state.ServerState
 
 
     override val commands = arrayOf("001")
 
-    override fun process(message: IrcMessage) {
+    override fun process(message: IrcMessage): List<IrcEvent> {
         serverState.localNickname = String(message.params[0])
+        return emptyList()
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/io/MessageHandlerTest.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.messages.MessageProcessor
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.inOrder
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
 
     @Test
     fun `MessageHandler passes message on to correct processor`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor))
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor)) {}
         val message = IrcMessage(null, null, "JOIN", emptyList())
 
         with(Channel<IrcMessage>(1)) {
         }
 
         verify(joinProcessor).process(message)
+        Unit
     }
 
     @Test
     fun `MessageHandler reads multiple messages`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor))
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor)) {}
         val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
         val nickMessage = IrcMessage(null, null, "NICK", emptyList())
         val otherMessage = IrcMessage(null, null, "OTHER", emptyList())
             verify(joinProcessor).process(joinMessage)
             verify(nickProcessor).process(nickMessage)
         }
+        Unit
+    }
+
+    @Test
+    fun `MessageHandler invokes event handler with returned events`() = runBlocking {
+        val eventHandler = mock<(IrcEvent) -> Unit>()
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), eventHandler)
+        val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
+        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected))
+
+        with(Channel<IrcMessage>(1)) {
+            send(joinMessage)
+            close()
+            handler.processMessages(this)
+        }
+
+        verify(eventHandler).invoke(ServerConnected)
     }
 
 }