Introduce event handlers, refactor message processors.

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.io.KtorLineBufferedSocket
+import com.dmdirc.ktirc.io.LineBufferedSocket
+import com.dmdirc.ktirc.io.MessageHandler
+import com.dmdirc.ktirc.io.MessageParser
+import com.dmdirc.ktirc.messages.*
+import com.dmdirc.ktirc.model.Profile
+import com.dmdirc.ktirc.model.Server
+import com.dmdirc.ktirc.model.ServerState
+import kotlinx.coroutines.channels.map
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.runBlocking
+import java.util.logging.Level
+import java.util.logging.LogManager
+
+
+interface IrcClient {
+
+    suspend fun send(message: String)
+
+    val serverState: ServerState
+
+}
+
+// TODO: How should alternative nicknames work?
+// TODO: Should IRC Client take a pool of servers and rotate through, or make the caller do that?
+// TODO: Should there be a default profile?
+class IrcClientImpl(private val server: Server, private val profile: Profile) : IrcClient {
+
+    var socketFactory: (String, Int) -> LineBufferedSocket = ::KtorLineBufferedSocket
+
+    override val serverState = ServerState(profile.initialNick)
+
+    private val messageHandler = MessageHandler(messageProcessors, eventHandlers + object : EventHandler {
+        override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+            when (event) {
+                is ServerWelcome -> client.send(joinMessage("#mdbot"))
+            }
+        }
+    })
+
+    private val parser = MessageParser()
+    private var socket: LineBufferedSocket? = null
+
+    override suspend fun send(message: String) {
+        socket?.sendLine(message)
+    }
+
+    suspend fun connect() {
+        // TODO: Concurrency!
+        check(socket == null)
+        coroutineScope {
+            with(socketFactory(server.host, server.port)) {
+                socket = this
+                connect()
+                // TODO: CAP LS
+                server.password?.let { pass -> sendLine(passwordMessage(pass)) }
+                sendLine(nickMessage(profile.initialNick))
+                // TODO: Send correct host
+                sendLine(userMessage(profile.userName, "localhost", server.host, profile.realName))
+                // TODO: This should be elsewhere
+                messageHandler.processMessages(this@IrcClientImpl, readLines(this@coroutineScope).map { parser.parse(it) })
+            }
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        fun main(args: Array<String>) {
+            val rootLogger = LogManager.getLogManager().getLogger("")
+            rootLogger.level = Level.FINEST
+            for (h in rootLogger.handlers) {
+                h.level = Level.FINEST
+            }
+
+            runBlocking {
+                val client = IrcClientImpl(Server("irc.quakenet.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
+                client.connect()
+            }
+        }
+    }
+
+}

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

+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+
+interface EventHandler {
+
+    suspend fun processEvent(client: IrcClient, event: IrcEvent)
+
+}
+
+val eventHandlers = setOf(
+        PingHandler(),
+        ServerStateHandler()
+)

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

 
 package com.dmdirc.ktirc.events
 
+import com.dmdirc.ktirc.model.ServerFeatureMap
+
 sealed class IrcEvent
+
+/**
+ * Raised when the server initially welcomes us to the IRC network.
+ */
+data class ServerWelcome(val localNick: String): IrcEvent()
+
+/**
+ * Raised when the features supported by the server have changed. This may occur numerous times during the
+ * connection phase.
+ */
+data class ServerFeaturesUpdated(val serverFeatures: ServerFeatureMap) : IrcEvent()
+
+/**
+ * Raised when the connection to the server has been established, configuration information has been received, etc.
+ */
 object ServerConnected : IrcEvent()
+
+/**
+ * Raised whenever a PING is received from the server.
+ */
 data class PingReceived(val nonce: ByteArray): IrcEvent()

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

+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.messages.pongMessage
+
+class PingHandler : EventHandler {
+
+    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+        when (event) {
+            is PingReceived -> client.send(pongMessage(event.nonce))
+        }
+    }
+
+}

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

+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+
+class ServerStateHandler : EventHandler {
+
+    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+        when (event) {
+            is ServerWelcome -> client.serverState.localNickname = event.localNick
+            is ServerFeaturesUpdated -> client.serverState.features.setAll(event.serverFeatures)
+        }
+    }
+
+}

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

 package com.dmdirc.ktirc.io
 
-import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.consumeEach
 
-class MessageHandler(private val processors: Collection<MessageProcessor>, private val eventHandler: (IrcEvent) -> Unit) {
+class MessageHandler(private val processors: Collection<MessageProcessor>, private val handlers: Collection<EventHandler>) {
 
     private val log by logger()
 
-    suspend fun processMessages(messages: ReceiveChannel<IrcMessage>) {
-        messages.consumeEach { it.process().forEach(eventHandler) }
+    suspend fun processMessages(ircClient: IrcClient, messages: ReceiveChannel<IrcMessage>) {
+        messages.consumeEach {
+            it.process().forEach { event ->
+                handlers.forEach { handler ->
+                    handler.processEvent(ircClient, event)
+                }
+            }
+        }
     }
 
     private fun IrcMessage.process() = this.getProcessor()?.process(this) ?: emptyList()

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.events.ServerFeaturesUpdated
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.IrcMessage
-import com.dmdirc.ktirc.state.ServerState
-import com.dmdirc.ktirc.state.serverFeatures
+import com.dmdirc.ktirc.model.ServerFeatureMap
+import com.dmdirc.ktirc.model.serverFeatures
 import com.dmdirc.ktirc.util.logger
 import kotlin.reflect.KClass
 
-class ISupportProcessor(val serverState: ServerState) : MessageProcessor {
+class ISupportProcessor : MessageProcessor {
 
     private val log by logger()
 
     override val commands = arrayOf("005")
 
-    override fun process(message: IrcMessage): List<IrcEvent> {
+    override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(ServerFeatureMap().apply {
         // 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]) {
+    private fun ServerFeatureMap.parseParam(param: ByteArray) = when (param[0]) {
         '-'.toByte() -> resetFeature(param.sliceArray(1 until param.size))
         else -> when (val equals = param.indexOf('='.toByte())) {
             -1 -> enableFeatureWithDefault(param)
         }
     }
 
-    private fun resetFeature(name: ByteArray) = name.asFeature()?.let {
-        serverState.resetFeature(it)
+    private fun ServerFeatureMap.resetFeature(name: ByteArray) = name.asFeature()?.let {
+        reset(it)
         log.finer { "Reset feature ${it::class}" }
     }
 
     @Suppress("UNCHECKED_CAST")
-    private fun enableFeature(name: ByteArray, value: ByteArray) {
+    private fun ServerFeatureMap.enableFeature(name: ByteArray, value: ByteArray) {
         name.asFeature()?.let { feature ->
-            serverState.setFeature(feature, value.cast(feature.type))
+            set(feature, value.cast(feature.type))
             log.finer { "Set feature ${feature::class} to ${String(value)}" }
         }
     }
 
-    private fun enableFeatureWithDefault(name: ByteArray) {
+    private fun ServerFeatureMap.enableFeatureWithDefault(name: ByteArray) {
         name.asFeature()?.let { feature ->
             when (feature.type) {
-                Boolean::class -> serverState.setFeature(feature, true)
+                Boolean::class -> set(feature, true)
                 else -> TODO("not implemented")
             }
         }

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

      */
     fun process(message: IrcMessage): List<IrcEvent>
 
-}
+}
+
+val messageProcessors = setOf(
+        ISupportProcessor(),
+        PingProcessor(),
+        WelcomeProcessor()
+)

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

 package com.dmdirc.ktirc.messages
 
-import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.events.ServerConnected
+import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.IrcMessage
-import com.dmdirc.ktirc.state.ServerState
 
-class WelcomeProcessor(private val serverState: ServerState) : MessageProcessor {
+class WelcomeProcessor : MessageProcessor {
 
     override val commands = arrayOf("001")
 
-    override fun process(message: IrcMessage): List<IrcEvent> {
-        serverState.localNickname = String(message.params[0])
-
-        // TODO: Maybe this should be later, like after the first line received after 001-005
-        return listOf(ServerConnected)
-    }
+    override fun process(message: IrcMessage) = listOf(ServerWelcome(String(message.params[0])))
 
 }

src/main/kotlin/com/dmdirc/ktirc/state/ServerState.kt → src/main/kotlin/com/dmdirc/ktirc/model/ServerState.kt

-package com.dmdirc.ktirc.state
+package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.io.CaseMapping
 import kotlin.reflect.KClass
 
-interface ServerState {
+class ServerState(initialNickname: String) {
 
-    var localNickname: String
-
-    fun <T : Any> getFeature(feature: ServerFeature<T>): T?
-    fun setFeature(feature: ServerFeature<*>, value: Any)
-    fun resetFeature(feature: ServerFeature<*>): Any?
+    var localNickname: String = initialNickname
+    val features = ServerFeatureMap()
 
 }
 
-class IrcServerState(initialNickname: String) : ServerState {
-
-    override var localNickname: String = initialNickname
+class ServerFeatureMap {
 
-    private val features = HashMap<ServerFeature<*>, Any>()
+    private val features = HashMap<ServerFeature<*>, Any?>()
 
     @Suppress("UNCHECKED_CAST")
-    override fun <T : Any> getFeature(feature: ServerFeature<T>) = features.getOrDefault(feature, feature.default) as? T?
+    operator fun <T : Any> get(feature: ServerFeature<T>) = features.getOrDefault(feature, feature.default) as? T? ?: feature.default
 
-    override fun setFeature(feature: ServerFeature<*>, value: Any) {
+    operator fun set(feature: ServerFeature<*>, value: Any) {
         require(feature.type.isInstance(value))
         features[feature] = value
     }
 
-    override fun resetFeature(feature: ServerFeature<*>) = features.remove(feature)
+    fun setAll(featureMap: ServerFeatureMap) = featureMap.features.forEach { feature, value -> features[feature] = value }
+    fun reset(feature: ServerFeature<*>) = features.put(feature, null)
 
 }
 
-
 sealed class ServerFeature<T : Any>(val name: String, val type: KClass<T>, val default: T? = null) {
     object ServerCaseMapping : ServerFeature<CaseMapping>("CASEMAPPING", CaseMapping::class, CaseMapping.Rfc)
     object MaximumChannels : ServerFeature<Int>("CHANLIMIT", Int::class)

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

 package com.dmdirc.ktirc
 
-import com.dmdirc.ktirc.io.KtorLineBufferedSocket
 import com.dmdirc.ktirc.io.LineBufferedSocket
 import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.Server
 import com.nhaarman.mockitokotlin2.*
-import kotlinx.coroutines.channels.ArrayChannel
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.runBlocking
-import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
-import java.lang.IllegalStateException
 
-internal class IrcClientTest {
+internal class IrcClientImplTest {
 
     companion object {
         private const val HOST = "thegibson.com"
     }
 
     @Test
-    fun `IrcClient uses socket factory to create a new socket on connect`() {
+    fun `IrcClientImpl uses socket factory to create a new socket on connect`() {
         runBlocking {
-            val client = IrcClient(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
             client.socketFactory = mockSocketFactory
             readLineChannel.close()
 
     }
 
     @Test
-    fun `IrcClient throws if socket already exists`() {
+    fun `IrcClientImpl throws if socket already exists`() {
         runBlocking {
-            val client = IrcClient(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
             client.socketFactory = mockSocketFactory
             readLineChannel.close()
 
     }
 
     @Test
-    fun `IrcClient sends basic connection strings`() {
+    fun `IrcClientImpl sends basic connection strings`() {
         runBlocking {
-            val client = IrcClient(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
             client.socketFactory = mockSocketFactory
             readLineChannel.close()
 
     }
 
     @Test
-    fun `IrcClient sends password first, when present`() {
+    fun `IrcClientImpl sends password first, when present`() {
         runBlocking {
-            val client = IrcClient(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
             client.socketFactory = mockSocketFactory
             readLineChannel.close()
 

src/test/kotlin/com/dmdirc/ktirc/events/PingHandlerTest.kt

+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Test
+
+internal class PingHandlerTest {
+
+    private val ircClient = mock<IrcClient>()
+
+    private val handler = PingHandler()
+
+    @Test
+    fun `PingHandler responses to pings with a pong`() = runBlocking {
+        handler.processEvent(ircClient, PingReceived("the_plague".toByteArray()))
+        verify(ircClient).send("PONG :the_plague")
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/events/ServerStateHandlerTest.kt

+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.ServerFeatureMap
+import com.dmdirc.ktirc.model.ServerState
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class ServerStateHandlerTest {
+
+    private val serverState = ServerState("")
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+    }
+
+    private val handler = ServerStateHandler()
+
+    @Test
+    fun `ServerStateHandler sets local nickname on welcome event`() = runBlocking {
+        handler.processEvent(ircClient, ServerWelcome("acidBurn"))
+        assertEquals("acidBurn", serverState.localNickname)
+    }
+
+    @Test
+    fun `ServerStateHandler updates features on features event`() = runBlocking {
+        val features = ServerFeatureMap()
+        features[ServerFeature.ChannelModes] = "abc"
+        features[ServerFeature.WhoxSupport] = true
+
+        handler.processEvent(ircClient, ServerFeaturesUpdated(features))
+
+        assertEquals("abc", serverState.features[ServerFeature.ChannelModes])
+        assertEquals(true, serverState.features[ServerFeature.WhoxSupport])
+    }
+
+}

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

 package com.dmdirc.ktirc.io
 
-import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.events.ServerConnected
+import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
 
 internal class MessageHandlerTest {
 
+    private val ircClient = mock<IrcClient>()
+
     private val nickProcessor = mock<MessageProcessor> {
         on { commands } doReturn arrayOf("FOO", "NICK")
     }
 
     @Test
     fun `MessageHandler passes message on to correct processor`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor)) {}
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList())
         val message = IrcMessage(null, null, "JOIN", emptyList())
 
         with(Channel<IrcMessage>(1)) {
             send(message)
             close()
-            handler.processMessages(this)
+            handler.processMessages(ircClient, this)
         }
 
         verify(joinProcessor).process(message)
 
     @Test
     fun `MessageHandler reads multiple messages`() = runBlocking {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor)) {}
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList())
         val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
         val nickMessage = IrcMessage(null, null, "NICK", emptyList())
         val otherMessage = IrcMessage(null, null, "OTHER", emptyList())
             send(nickMessage)
             send(otherMessage)
             close()
-            handler.processMessages(this)
+            handler.processMessages(ircClient, this)
         }
 
         with(inOrder(joinProcessor, nickProcessor)) {
     }
 
     @Test
-    fun `MessageHandler invokes event handler with returned events`() = runBlocking {
-        val eventHandler = mock<(IrcEvent) -> Unit>()
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), eventHandler)
+    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 joinMessage = IrcMessage(null, null, "JOIN", emptyList())
-        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected))
+        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected, ServerWelcome("abc")))
 
         with(Channel<IrcMessage>(1)) {
             send(joinMessage)
             close()
-            handler.processMessages(this)
+            handler.processMessages(ircClient, this)
         }
 
-        verify(eventHandler).invoke(ServerConnected)
+        verify(eventHandler1).processEvent(ircClient, ServerConnected)
+        verify(eventHandler1).processEvent(ircClient, ServerWelcome("abc"))
+        verify(eventHandler2).processEvent(ircClient, ServerConnected)
+        verify(eventHandler2).processEvent(ircClient, ServerWelcome("abc"))
     }
 
 }

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

 
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.IrcMessage
-import com.dmdirc.ktirc.state.ServerFeature
-import com.dmdirc.ktirc.state.ServerState
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
-import org.junit.jupiter.api.Assertions.assertTrue
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.ServerFeatureMap
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ISupportProcessorTest {
 
-    private val state = mock<ServerState>()
-    private val processor = ISupportProcessor(state)
+    private val processor = ISupportProcessor()
 
     @Test
     fun `ISupportProcessor can handle 005s`() {
 
     @Test
     fun `ISupportProcessor handles multiple numeric arguments`() {
-        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
                 listOf("nickname", "CHANLIMIT=123", "CHANNELLEN=456", "are supported blah blah").map { it.toByteArray() }))
 
-        verify(state).setFeature(ServerFeature.MaximumChannels, 123)
-        verify(state).setFeature(ServerFeature.MaximumChannelNameLength, 456)
+        assertEquals(123, events[0].serverFeatures[ServerFeature.MaximumChannels])
+        assertEquals(456, events[0].serverFeatures[ServerFeature.MaximumChannelNameLength])
     }
 
     @Test
     fun `ISupportProcessor handles string arguments`() {
-        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
                 listOf("nickname", "CHANMODES=abcd", "are supported blah blah").map { it.toByteArray() }))
 
-        verify(state).setFeature(ServerFeature.ChannelModes, "abcd")
+        assertEquals("abcd", events[0].serverFeatures[ServerFeature.ChannelModes])
     }
 
     @Test
     fun `ISupportProcessor handles resetting arguments`() {
-        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
                 listOf("nickname", "-CHANMODES", "are supported blah blah").map { it.toByteArray() }))
 
-        verify(state).resetFeature(ServerFeature.ChannelModes)
+        val oldFeatures = ServerFeatureMap()
+        oldFeatures[ServerFeature.ChannelModes] = "abc"
+        oldFeatures.setAll(events[0].serverFeatures)
+        assertNull(oldFeatures[ServerFeature.ChannelModes])
     }
 
     @Test
     fun `ISupportProcessor handles case mapping arguments`() {
-        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
                 listOf("nickname", "CASEMAPPING=rfc1459-strict", "are supported blah blah").map { it.toByteArray() }))
 
-        verify(state).setFeature(ServerFeature.ServerCaseMapping, CaseMapping.RfcStrict)
+        assertEquals(CaseMapping.RfcStrict, events[0].serverFeatures[ServerFeature.ServerCaseMapping])
     }
 
     @Test
     fun `ISupportProcessor handles boolean features with no arguments`() {
-        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
                 listOf("nickname", "WHOX", "are supported blah blah").map { it.toByteArray() }))
 
-        verify(state).setFeature(ServerFeature.WhoxSupport, true)
+        assertEquals(true, events[0].serverFeatures[ServerFeature.WhoxSupport])
     }
 
 }

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.events.ServerConnected
+import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.IrcMessage
-import com.dmdirc.ktirc.state.ServerState
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class WelcomeProcessorTest {
 
-    private val state = mock<ServerState>()
-    private val processor = WelcomeProcessor(state)
+    private val processor = WelcomeProcessor()
 
     @Test
     fun `WelcomeProcessor can handle 001s`() {
     }
 
     @Test
-    fun `WelcomeProcessor parses local nickname`() {
-        processor.process(IrcMessage(null, ":thegibson.com".toByteArray(), "001", listOf(
-                "acidBurn".toByteArray(),
-                "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
-        verify(state).localNickname = "acidBurn"
-    }
-
-    @Test
-    fun `WelcomeProcessor returns server connected event`() {
+    fun `WelcomeProcessor returns server welcome event`() {
         val events = processor.process(IrcMessage(null, ":thegibson.com".toByteArray(), "001", listOf(
                 "acidBurn".toByteArray(),
                 "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
-        assertEquals(listOf<IrcEvent>(ServerConnected), events)
+        assertEquals(listOf<IrcEvent>(ServerWelcome("acidBurn")), events)
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/model/ServerFeatureMapTest.kt

+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+internal class ServerFeatureMapTest {
+
+    @Test
+    fun `ServerFeatureMap should return defaults for unspecified features`() {
+        val featureMap = ServerFeatureMap()
+        assertEquals(200, featureMap[ServerFeature.MaximumChannelNameLength])
+    }
+
+    @Test
+    fun `ServerFeatureMap should return null for unspecified features with no default`() {
+        val featureMap = ServerFeatureMap()
+        assertNull(featureMap[ServerFeature.ChannelModes])
+    }
+
+    @Test
+    fun `ServerFeatureMap should return previously set value for features`() {
+        val featureMap = ServerFeatureMap()
+        featureMap[ServerFeature.MaximumChannels] = 123
+        assertEquals(123, featureMap[ServerFeature.MaximumChannels])
+    }
+
+    @Test
+    fun `ServerFeatureMap should return default set value for features that were reset`() {
+        val featureMap = ServerFeatureMap()
+        featureMap[ServerFeature.MaximumChannels] = 123
+        featureMap.reset(ServerFeature.MaximumChannels)
+        assertNull(featureMap[ServerFeature.MaximumChannels])
+    }
+
+    @Test
+    fun `ServerFeatureMap should throw if a feature is set with the wrong type`() {
+        val featureMap = ServerFeatureMap()
+        assertThrows(IllegalArgumentException::class.java) {
+            featureMap[ServerFeature.MaximumChannels] = "123"
+        }
+    }
+
+    @Test
+    fun `ServerFeatureMap sets all features from another map`() {
+        val featureMap1 = ServerFeatureMap()
+        val featureMap2 = ServerFeatureMap()
+        featureMap2[ServerFeature.WhoxSupport] = true
+        featureMap2[ServerFeature.ChannelModes] = "abc"
+        featureMap1.setAll(featureMap2)
+
+        assertEquals(true, featureMap1[ServerFeature.WhoxSupport])
+        assertEquals("abc", featureMap1[ServerFeature.ChannelModes])
+    }
+
+
+    @Test
+    fun `ServerFeatureMap resets features reset in another map`() {
+        val featureMap1 = ServerFeatureMap()
+        val featureMap2 = ServerFeatureMap()
+        featureMap1[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
+        featureMap2.reset(ServerFeature.ServerCaseMapping)
+        featureMap1.setAll(featureMap2)
+
+        assertEquals(CaseMapping.Rfc, featureMap1[ServerFeature.ServerCaseMapping])
+    }
+    
+}

src/test/kotlin/com/dmdirc/ktirc/model/ServerStateTest.kt

+package com.dmdirc.ktirc.model
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class ServerStateTest {
+
+    @Test
+    fun `IrcServerState should use the initial nickname as local nickname`() {
+        val serverState = ServerState("acidBurn")
+        assertEquals("acidBurn", serverState.localNickname)
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/state/IrcServerStateTest.kt

-package com.dmdirc.ktirc.state
-
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import java.lang.IllegalArgumentException
-
-internal class IrcServerStateTest {
-
-    @Test
-    fun `IrcServerState should return defaults for unspecified features`() {
-        val serverState = IrcServerState("")
-        assertEquals(200, serverState.getFeature(ServerFeature.MaximumChannelNameLength))
-    }
-
-    @Test
-    fun `IrcServerState should return null for unspecified features with no default`() {
-        val serverState = IrcServerState("")
-        assertNull(serverState.getFeature(ServerFeature.ChannelModes))
-    }
-
-    @Test
-    fun `IrcServerState should return previously set value for features`() {
-        val serverState = IrcServerState("")
-        serverState.setFeature(ServerFeature.MaximumChannels, 123)
-        assertEquals(123, serverState.getFeature(ServerFeature.MaximumChannels))
-    }
-
-    @Test
-    fun `IrcServerState should return default set value for features that were reset`() {
-        val serverState = IrcServerState("")
-        serverState.setFeature(ServerFeature.MaximumChannels, 123)
-        serverState.resetFeature(ServerFeature.MaximumChannels)
-        assertNull(serverState.getFeature(ServerFeature.MaximumChannels))
-    }
-
-    @Test
-    fun `IrcServerState should throw if a feature is set with the wrong type`() {
-        val serverState = IrcServerState("")
-        assertThrows(IllegalArgumentException::class.java) {
-            serverState.setFeature(ServerFeature.MaximumChannels, "123")
-        }
-    }
-
-    @Test
-    fun `IrcServerState should use the initial nickname as local nickname`() {
-        val serverState = IrcServerState("acidBurn")
-        assertEquals("acidBurn", serverState.localNickname)
-    }
-
-}