Add rudimentary PRIVMSG handling

src/main/kotlin/com/dmdirc/ktirc/IrcClient.kt

 package com.dmdirc.ktirc
 
-import com.dmdirc.ktirc.events.EventHandler
-import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.events.ServerWelcome
-import com.dmdirc.ktirc.events.eventHandlers
+import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.*
 import com.dmdirc.ktirc.messages.*
 import com.dmdirc.ktirc.model.*
     val caseMapping: CaseMapping
         get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
 
+    var eventHandler: EventHandler?
+
     fun isLocalUser(user: User): Boolean = caseMapping.areEquivalent(user.nickname, serverState.localNickname)
 
 }
     override val serverState = ServerState(profile.initialNick)
     override val channelState = ChannelStateMap { caseMapping }
 
-    private val messageHandler = MessageHandler(messageProcessors, eventHandlers + object : EventHandler {
-        override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
-            when (event) {
-                is ServerWelcome -> client.send(joinMessage("#mdbot"))
-            }
+    override var eventHandler: EventHandler? = null
+        set(value) {
+            field?.let { messageHandler.handlers.remove(it) }
+            field = value
+            field?.let { messageHandler.handlers.add(it) }
         }
-    })
+
+    private val messageHandler = MessageHandler(messageProcessors.toList(), eventHandlers.toMutableList())
 
     private val parser = MessageParser()
     private var socket: LineBufferedSocket? = null
             }
 
             runBlocking {
-                val client = IrcClientImpl(Server("irc.quakenet.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
+                val client = IrcClientImpl(Server("uk.quakenet.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
+                client.eventHandler = object : EventHandler {
+                    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+                        when (event) {
+                            is ServerWelcome -> client.send(joinMessage("#mdbot"))
+                            is MessageReceived -> if (event.message == "!test") client.send(privmsgMessage(event.target, "Test successful!"))
+                        }
+                    }
+                }
                 client.connect()
             }
         }

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

 
 /** Raised when the entirety of the channel's member list has been received. */
 data class ChannelNamesFinished(val channel: String) : IrcEvent()
+
+/** Raised when a message is received. */
+data class MessageReceived(val user: User, val target: String, val message: String) : IrcEvent()

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

 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.consumeEach
 
-class MessageHandler(private val processors: Collection<MessageProcessor>, private val handlers: Collection<EventHandler>) {
+class MessageHandler(private val processors: List<MessageProcessor>, val handlers: MutableList<EventHandler>) {
 
     private val log by logger()
 

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

 import com.dmdirc.ktirc.util.logger
 import kotlin.reflect.KClass
 
-class ISupportProcessor : MessageProcessor {
+internal class ISupportProcessor : MessageProcessor {
 
     private val log by logger()
 

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

 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
-class JoinProcessor : MessageProcessor {
+internal class JoinProcessor : MessageProcessor {
 
     override val commands = arrayOf("JOIN")
 

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

 fun nickMessage(nick: String) = "NICK :$nick"
 fun passwordMessage(password: String) = "PASS :$password"
 fun pongMessage(nonce: ByteArray) = "PONG :${String(nonce)}"
+fun privmsgMessage(target: String, message: String) = "PRIVMSG $target :$message"
 fun userMessage(userName: String, localHostName: String, serverHostName: String, realName: String) = "USER $userName $localHostName $serverHostName :$realName"

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

         NamesProcessor(),
         PartProcessor(),
         PingProcessor(),
+        PrivmsgProcessor(),
         WelcomeProcessor()
 )

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

 import com.dmdirc.ktirc.events.ChannelNamesReceived
 import com.dmdirc.ktirc.io.IrcMessage
 
-class NamesProcessor : MessageProcessor {
+internal class NamesProcessor : MessageProcessor {
 
     override val commands = arrayOf("353", "366")
 

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

 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
-class PartProcessor : MessageProcessor {
+internal class PartProcessor : MessageProcessor {
 
     override val commands = arrayOf("PART")
 

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

 import com.dmdirc.ktirc.events.PingReceived
 import com.dmdirc.ktirc.io.IrcMessage
 
-class PingProcessor : MessageProcessor {
+internal class PingProcessor : MessageProcessor {
 
     override val commands = arrayOf("PING")
 

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

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.MessageReceived
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.asUser
+
+internal class PrivmsgProcessor : MessageProcessor {
+
+    override val commands = arrayOf("PRIVMSG")
+
+    override fun process(message: IrcMessage) = message.prefix?.let {
+        listOf(MessageReceived(it.asUser(), String(message.params[0]), String(message.params[1])))
+    } ?: emptyList()
+
+}

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

 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.IrcMessage
 
-class WelcomeProcessor : MessageProcessor {
+internal class WelcomeProcessor : MessageProcessor {
 
     override val commands = arrayOf("001")
 

src/test/kotlin/com/dmdirc/ktirc/IrcClientTest.kt

 package com.dmdirc.ktirc
 
+import com.dmdirc.ktirc.events.EventHandler
+import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
 import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.User
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
         on { invoke(HOST, PORT) } doReturn mockSocket
     }
 
+    private val mockEventHandler = mock<EventHandler>()
+
     @Test
     fun `IrcClientImpl uses socket factory to create a new socket on connect`() {
         runBlocking {
         }
     }
 
+    @Test
+    fun `IrcClientImpl sends events to provided event handler`() {
+        runBlocking {
+            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+            client.socketFactory = mockSocketFactory
+            client.eventHandler = mockEventHandler
+
+            launch {
+                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
+                readLineChannel.close()
+            }
+
+            client.connect()
+
+            verify(mockEventHandler).processEvent(client, ServerWelcome("acidBurn"))
+        }
+    }
+
+    @Test
+    fun `IrcClientImpl removes old event handlers when new one is added`() {
+        runBlocking {
+            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+            client.socketFactory = mockSocketFactory
+            client.eventHandler = mockEventHandler
+            client.eventHandler = mock()
+
+            launch {
+                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
+                readLineChannel.close()
+            }
+
+            client.connect()
+
+            verify(mockEventHandler, never()).processEvent(client, ServerWelcome("acidBurn"))
+        }
+    }
+
+    @Test
+    fun `IrcClientImpl removes old event handlers when it is set to null`() {
+        runBlocking {
+            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+            client.socketFactory = mockSocketFactory
+            client.eventHandler = mockEventHandler
+            client.eventHandler = null
+
+            launch {
+                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
+                readLineChannel.close()
+            }
+
+            client.connect()
+
+            verify(mockEventHandler, never()).processEvent(client, ServerWelcome("acidBurn"))
+        }
+    }
+
     @Test
     fun `IrcClient gets case mapping from server features`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))

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

 
     @Test
     fun `MessageHandler passes message on to correct processor`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList())
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
         val message = IrcMessage(null, null, "JOIN", emptyList())
 
         with(Channel<IrcMessage>(1)) {
 
     @Test
     fun `MessageHandler reads multiple messages`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList())
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
         val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
         val nickMessage = IrcMessage(null, null, "NICK", emptyList())
         val otherMessage = IrcMessage(null, null, "OTHER", emptyList())
     fun `MessageHandler invokes all event handler with all returned events`() = runBlocking {
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), listOf(eventHandler1, eventHandler2))
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
         whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected, ServerWelcome("abc")))
 

src/test/kotlin/com/dmdirc/ktirc/messages/PrivmsgProcessorTest.kt

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.MessageReceived
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.User
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class PrivmsgProcessorTest {
+
+    @Test
+    fun `PrivsgProcessor raises message received event`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+        Assertions.assertEquals(1, events.size)
+        Assertions.assertEquals(MessageReceived(User("acidburn", "libby", "root.localhost"), "#crashandburn", "hack the planet!"), events[0])
+    }
+
+    @Test
+    fun `PrivsgProcessor does nothing if prefix missing`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(null, null, "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+        Assertions.assertEquals(0, events.size)
+    }
+}