Event mutators

CHANGELOG

    e.g. IrcClient { server("irc.example.com", 6667) }
  * Add behaviour options
    * requestModesOnJoin - automatically sends a MODE request when joining a channel
+ * (Internal) Introduced event mutators
+   * Event mutators are now responsible for handling changing events in response to state
+     e.g. ChannelFanOutMutator creates Channel* events for global quits/nick changes/etc
+   * Event handlers now just handle events, and don't return anything
 
 v0.8.0
 

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

 package com.dmdirc.ktirc
 
 import com.dmdirc.ktirc.events.*
-import com.dmdirc.ktirc.handlers.EventHandler
-import com.dmdirc.ktirc.handlers.eventHandlers
+import com.dmdirc.ktirc.events.handlers.EventHandler
+import com.dmdirc.ktirc.events.handlers.eventHandlers
+import com.dmdirc.ktirc.events.mutators.eventMutators
 import com.dmdirc.ktirc.io.KtorLineBufferedSocket
 import com.dmdirc.ktirc.io.LineBufferedSocket
 import com.dmdirc.ktirc.io.MessageHandler
     override val channelState = ChannelStateMap { caseMapping }
     override val userState = UserState { caseMapping }
 
-    private val messageHandler = MessageHandler(messageProcessors.toList(), eventHandlers.toMutableList())
+    private val messageHandler = MessageHandler(messageProcessors, eventMutators, eventHandlers.toMutableList())
 
     private val parser = MessageParser()
     private var socket: LineBufferedSocket? = null
 
     override fun onEvent(handler: (IrcEvent) -> Unit) {
         messageHandler.handlers.add(object : EventHandler {
-            override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+            override fun processEvent(client: IrcClient, event: IrcEvent) {
                 handler(event)
-                return emptyList()
             }
         })
     }

src/main/kotlin/com/dmdirc/ktirc/handlers/CapabilitiesHandler.kt → src/main/kotlin/com/dmdirc/ktirc/events/handlers/CapabilitiesHandler.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
 
     private val log by logger()
 
-    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+    override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ServerCapabilitiesReceived -> handleCapabilitiesReceived(client.serverState.capabilities, event.capabilities)
             is ServerCapabilitiesFinished -> handleCapabilitiesFinished(client)
             is SaslMechanismNotAvailableError -> handleSaslMechanismChange(client, event.mechanisms)
             is SaslFinished -> handleSaslFinished(client)
         }
-        return emptyList()
     }
 
     private fun handleCapabilitiesReceived(state: CapabilitiesState, capabilities: Map<Capability, String>) {

src/main/kotlin/com/dmdirc/ktirc/handlers/ChannelStateHandler.kt → src/main/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandler.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
 
     private val log by logger()
 
-    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+    override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ChannelJoined -> handleJoin(client, event)
             is ChannelParted -> handlePart(client, event)
             is ChannelTopicDiscovered -> handleTopicDiscovered(client, event)
             is ChannelTopicMetadataDiscovered -> handleTopicMetadata(client, event)
             is ChannelTopicChanged -> handleTopicChanged(client, event)
+            is ChannelQuit -> handleQuit(client, event)
+            is ChannelNickChanged -> handleNickChanged(client, event)
             is ModeChanged -> handleModeChanged(client, event)
-            is UserQuit -> return handleQuit(client, event)
-            is UserNickChanged -> return handleNickChanged(client, event)
         }
-        return emptyList()
     }
 
     private fun handleJoin(client: IrcClient, event: ChannelJoined) {
         return 1
     }
 
-    private fun handleQuit(client: IrcClient, event: UserQuit) = sequence {
-        client.channelState.forEach {
-            if (it.users.contains(event.user.nickname)) {
-                it.users -= event.user.nickname
-                yield(ChannelQuit(event.time, event.user, it.name, event.reason))
-            }
+    private fun handleQuit(client: IrcClient, event: ChannelQuit) {
+        client.channelState[event.channel]?.let {
+            it.users -= event.user.nickname
         }
-    }.toList()
+    }
 
-    private fun handleNickChanged(client: IrcClient, event: UserNickChanged) = sequence {
-        client.channelState.forEach {
+    private fun handleNickChanged(client: IrcClient, event: ChannelNickChanged) {
+        client.channelState[event.channel]?.let {
             it.users[event.user.nickname]?.let { chanUser ->
                 chanUser.nickname = event.newNick
-                yield(ChannelNickChanged(event.time, event.user, it.name, event.newNick))
             }
         }
-    }.toList()
+    }
 
 }

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

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.IrcEvent
 @FunctionalInterface
 internal interface EventHandler {
 
-    fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent>
+    fun processEvent(client: IrcClient, event: IrcEvent)
 
 }
 

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

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.IrcEvent
 
 internal class PingHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+    override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is PingReceived -> client.sendPong(event.nonce)
         }
-        return emptyList()
     }
 
 }

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

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.model.ServerState
 import com.dmdirc.ktirc.model.ServerStatus
-import java.time.LocalDateTime
 
 internal class ServerStateHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+    override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ServerConnecting -> client.serverState.status = ServerStatus.Connecting
             is ServerConnected -> client.serverState.status = ServerStatus.Negotiating
             is ServerDisconnected -> client.serverState.status = ServerStatus.Disconnected
+            is ServerReady -> client.serverState.status = ServerStatus.Ready
             is ServerWelcome -> handleWelcome(client.serverState, event.server, event.localNick)
             is ServerFeaturesUpdated -> client.serverState.features.setAll(event.serverFeatures)
-
-            // Events that won't trigger a server ready event
-            is PingReceived -> Unit
-            is ServerCapabilitiesReceived -> Unit
-            is ServerCapabilitiesAcknowledged -> Unit
-            is ServerCapabilitiesFinished -> Unit
-
-            else -> return checkReadyState(client, event.time)
         }
-        return emptyList()
     }
 
     private fun handleWelcome(serverState: ServerState, server: String, localNick: String) {
         serverState.localNickname = localNick
     }
 
-    private fun checkReadyState(client: IrcClient, time: LocalDateTime): List<IrcEvent> {
-        if (client.serverState.receivedWelcome && client.serverState.status == ServerStatus.Negotiating) {
-            client.serverState.status = ServerStatus.Ready
-            return listOf(ServerReady(time))
-        }
-        return emptyList()
-    }
-
 }

src/main/kotlin/com/dmdirc/ktirc/handlers/UserStateHandler.kt → src/main/kotlin/com/dmdirc/ktirc/events/handlers/UserStateHandler.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
 
 internal class UserStateHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
+    override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ChannelJoined -> handleJoin(client.userState, event)
             is ChannelParted -> handlePart(client, event)
             is UserNickChanged -> handleNickChanged(client, event)
             is UserQuit -> handleQuit(client.userState, event)
         }
-        return emptyList()
     }
 
     private fun handleJoin(state: UserState, event: ChannelJoined) {

src/main/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutator.kt

+package com.dmdirc.ktirc.events.mutators
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.events.*
+
+/**
+ * "Fans out" global events such as quits and nick changes to each channel a user is in.
+ */
+internal class ChannelFanOutMutator : EventMutator {
+
+    override fun mutateEvent(client: IrcClient, event: IrcEvent) = sequence<IrcEvent> {
+        yield(event)
+        when (event) {
+            is UserQuit -> handleQuit(client, event)
+            is UserNickChanged -> handleNickChanged(client, event)
+        }
+    }.toList()
+
+    private suspend fun SequenceScope<IrcEvent>.handleQuit(client: IrcClient, event: UserQuit) {
+        client.channelState.forEach {
+            if (it.users.contains(event.user.nickname)) {
+                yield(ChannelQuit(event.time, event.user, it.name, event.reason))
+            }
+        }
+    }
+
+    private suspend fun SequenceScope<IrcEvent>.handleNickChanged(client: IrcClient, event: UserNickChanged) {
+        client.channelState.forEach {
+            it.users[event.user.nickname]?.let { chanUser ->
+                chanUser.nickname = event.newNick
+                yield(ChannelNickChanged(event.time, event.user, it.name, event.newNick))
+            }
+        }
+    }
+
+}

src/main/kotlin/com/dmdirc/ktirc/events/mutators/EventMutator.kt

+package com.dmdirc.ktirc.events.mutators
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.events.IrcEvent
+
+@FunctionalInterface
+internal interface EventMutator {
+
+    fun mutateEvent(client: IrcClient, event: IrcEvent): List<IrcEvent>
+
+}
+
+internal val eventMutators = listOf(
+        ServerReadyMutator(),
+        ChannelFanOutMutator()
+)

src/main/kotlin/com/dmdirc/ktirc/events/mutators/ServerReadyMutator.kt

+package com.dmdirc.ktirc.events.mutators
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.events.*
+import com.dmdirc.ktirc.model.ServerStatus
+
+/**
+ * Sends a [ServerReady] event once the first line has been received post 001/005/etc.
+ */
+internal class ServerReadyMutator : EventMutator {
+
+    /** Events that won't trigger a 'server ready' event to be sent. */
+    private val excludedEvents = listOf(
+            ServerConnecting::class,
+            ServerConnected::class,
+            ServerDisconnected::class,
+            ServerWelcome::class,
+            ServerReady::class,
+            ServerFeaturesUpdated::class,
+
+            PingReceived::class,
+            ServerCapabilitiesReceived::class,
+            ServerCapabilitiesAcknowledged::class,
+            ServerCapabilitiesFinished::class
+    )
+
+    override fun mutateEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> = sequence {
+        if (client.serverState.receivedWelcome
+                && client.serverState.status == ServerStatus.Negotiating
+                && event::class !in excludedEvents) {
+            yield(ServerReady(event.time))
+        }
+        yield(event)
+    }.toList()
+
+}

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

 package com.dmdirc.ktirc.io
 
 import com.dmdirc.ktirc.IrcClient
-import com.dmdirc.ktirc.handlers.EventHandler
 import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.events.handlers.EventHandler
+import com.dmdirc.ktirc.events.mutators.EventMutator
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.channels.ReceiveChannel
 
-internal class MessageHandler(private val processors: List<MessageProcessor>, val handlers: MutableList<EventHandler>) {
+internal class MessageHandler(
+        private val processors: List<MessageProcessor>,
+        private val mutators: List<EventMutator>,
+        val handlers: MutableList<EventHandler>) {
 
     private val log by logger()
 
     suspend fun processMessages(ircClient: IrcClient, messages: ReceiveChannel<IrcMessage>) {
         for (message in messages) {
-            message.toEvents().forEach { event -> emitEvent(ircClient, event) }
+            emitEvents(ircClient, message.toEvents())
         }
     }
 
-    fun emitEvent(ircClient: IrcClient, ircEvent: IrcEvent) {
-        log.fine { "Dispatching event of type ${ircEvent::class}" }
-        handlers.forEach { handler ->
-            handler.processEvent(ircClient, ircEvent).forEach {
-                emitEvent(ircClient, it)
-            }
+    fun emitEvent(ircClient: IrcClient, ircEvent: IrcEvent) = emitEvents(ircClient, listOf(ircEvent))
+
+    fun emitEvents(ircClient: IrcClient, ircEvents: List<IrcEvent>) {
+        mutators.fold(ircEvents) { events, mutator ->
+            events.flatMap { mutator.mutateEvent(ircClient, it) }
+        }.forEach { event ->
+            log.fine { "Dispatching event of type ${event::class}" }
+            handlers.forEach { it.processEvent(ircClient, event) }
         }
     }
 

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

 
 }
 
-internal val messageProcessors = setOf(
+internal val messageProcessors = listOf(
         AccountProcessor(),
         AuthenticationProcessor(),
         CapabilityProcessor(),

src/test/kotlin/com/dmdirc/ktirc/handlers/CapabilitiesHandlerTest.kt → src/test/kotlin/com/dmdirc/ktirc/events/handlers/CapabilitiesHandlerTest.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants

src/test/kotlin/com/dmdirc/ktirc/handlers/ChannelStateHandlerTest.kt → src/test/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandlerTest.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.BehaviourConfig
 import com.dmdirc.ktirc.IrcClient
     }
 
     @Test
-    fun `removes user from all channel member lists for quits`() {
+    fun `removes user from channel member lists for quits`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
             channelStateMap += this
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, UserQuit(TestConstants.time, User("zerocool", "dade", "root.localhost")))
+        handler.processEvent(ircClient, ChannelQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#dumpsterdiving"))
 
         assertFalse("zerocool" in channelStateMap["#thegibson"]!!.users)
         assertFalse("zerocool" in channelStateMap["#dumpsterdiving"]!!.users)
         assertTrue("acidburn" in channelStateMap["#chat"]!!.users)
     }
 
-
-    @Test
-    fun `raises ChannelQuit event for each channel a user quits from`() {
-        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
-            users += ChannelUser("ZeroCool")
-            channelStateMap += this
-        }
-
-        with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
-            users += ChannelUser("ZeroCool")
-            channelStateMap += this
-        }
-
-        with (ChannelState("#chat") { CaseMapping.Rfc }) {
-            users += ChannelUser("AcidBurn")
-            channelStateMap += this
-        }
-
-        val events = handler.processEvent(ircClient, UserQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "Hack the planet!"))
-
-        val names = mutableListOf<String>()
-        assertEquals(2, events.size)
-        events.forEach { event ->
-            (event as ChannelQuit).let {
-                assertEquals(TestConstants.time, it.time)
-                assertEquals("zerocool", it.user.nickname)
-                assertEquals("Hack the planet!", it.reason)
-                names.add(it.channel)
-            }
-        }
-
-        assertTrue("#thegibson" in names)
-        assertTrue("#dumpsterdiving" in names)
-    }
-
     @Test
     fun `renames user in channel member list for nick changes`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("acidBurn")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, UserNickChanged(TestConstants.time, User("acidburn", "libby", "root.localhost"), "acidB"))
+        handler.processEvent(ircClient, ChannelNickChanged(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson", "acidB"))
+        handler.processEvent(ircClient, ChannelNickChanged(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#dumpsterdiving", "acidB"))
 
         assertFalse("acidBurn" in channel.users)
         assertTrue("acidB" in channel.users)
         assertEquals("acidB", channel.users["acidB"]?.nickname)
     }
 
-    @Test
-    fun `raises ChannelNickChanged event for each channel a user changes nicks in`() {
-        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
-            users += ChannelUser("ZeroCool")
-            channelStateMap += this
-        }
-
-        with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
-            users += ChannelUser("ZeroCool")
-            channelStateMap += this
-        }
-
-        with (ChannelState("#chat") { CaseMapping.Rfc }) {
-            users += ChannelUser("AcidBurn")
-            channelStateMap += this
-        }
-
-        val events = handler.processEvent(ircClient, UserNickChanged(TestConstants.time, User("zerocool", "dade", "root.localhost"), "zer0c00l"))
-
-        val names = mutableListOf<String>()
-        assertEquals(2, events.size)
-        events.forEach { event ->
-            (event as ChannelNickChanged).let {
-                assertEquals(TestConstants.time, it.time)
-                assertEquals("zerocool", it.user.nickname)
-                assertEquals("zer0c00l", it.newNick)
-                names.add(it.channel)
-            }
-        }
-
-        assertTrue("#thegibson" in names)
-        assertTrue("#dumpsterdiving" in names)
-    }
-
     @Test
     fun `sets mode discovered flag when discovered mode event received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }

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

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants

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

+package com.dmdirc.ktirc.events.handlers
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.*
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.ServerFeatureMap
+import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.ServerStatus
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.jupiter.api.Assertions.*
+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 `sets local nickname on welcome event`() {
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        assertEquals("acidBurn", serverState.localNickname)
+    }
+
+    @Test
+    fun `sets server name on welcome event`() {
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        assertEquals("the.gibson", serverState.serverName)
+    }
+
+    @Test
+    fun `sets receivedWelcome on welcome event`() {
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        assertTrue(serverState.receivedWelcome)
+    }
+
+    @Test
+    fun `sets state to connecting on event`() {
+        handler.processEvent(ircClient, ServerConnecting(TestConstants.time))
+        assertEquals(ServerStatus.Connecting, serverState.status)
+    }
+
+    @Test
+    fun `sets state to disconnected on event`() {
+        serverState.status = ServerStatus.Ready
+        handler.processEvent(ircClient, ServerDisconnected(TestConstants.time))
+        assertEquals(ServerStatus.Disconnected, serverState.status)
+    }
+
+    @Test
+    fun `sets state to negotiating on connected`() {
+        handler.processEvent(ircClient, ServerConnected(TestConstants.time))
+        assertEquals(ServerStatus.Negotiating, serverState.status)
+    }
+
+    @Test
+    fun `sets state to ready on ServerReady`() {
+        handler.processEvent(ircClient, ServerReady(TestConstants.time))
+        assertEquals(ServerStatus.Ready, serverState.status)
+    }
+
+    @Test
+    fun `updates features on features event`() {
+        val features = ServerFeatureMap()
+        features[ServerFeature.ChannelModes] = arrayOf("abc", "def")
+        features[ServerFeature.WhoxSupport] = true
+
+        handler.processEvent(ircClient, ServerFeaturesUpdated(TestConstants.time, features))
+
+        assertArrayEquals(arrayOf("abc", "def"), serverState.features[ServerFeature.ChannelModes])
+        assertEquals(true, serverState.features[ServerFeature.WhoxSupport])
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/handlers/UserStateHandlerTest.kt → src/test/kotlin/com/dmdirc/ktirc/events/handlers/UserStateHandlerTest.kt

-package com.dmdirc.ktirc.handlers
+package com.dmdirc.ktirc.events.handlers
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutatorTest.kt

+package com.dmdirc.ktirc.events.mutators
+
+import com.dmdirc.ktirc.BehaviourConfig
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.ChannelNickChanged
+import com.dmdirc.ktirc.events.ChannelQuit
+import com.dmdirc.ktirc.events.UserNickChanged
+import com.dmdirc.ktirc.events.UserQuit
+import com.dmdirc.ktirc.io.CaseMapping
+import com.dmdirc.ktirc.model.*
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class ChannelFanOutMutatorTest {
+
+    private val mutator = ChannelFanOutMutator()
+    private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+    private val serverState = ServerState("", "")
+    private val behaviour = BehaviourConfig()
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+        on { channelState } doReturn channelStateMap
+        on { behaviour } doReturn behaviour
+        on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
+        on { isLocalUser("acidburn") } doReturn  true
+    }
+
+    @Test
+    fun `raises ChannelQuit event for each channel a user quits from`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        with (ChannelState("#chat") { CaseMapping.Rfc }) {
+            users += ChannelUser("AcidBurn")
+            channelStateMap += this
+        }
+
+        val quitEvent = UserQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "Hack the planet!")
+        val events = mutator.mutateEvent(ircClient, quitEvent)
+
+        val names = mutableListOf<String>()
+        Assertions.assertEquals(3, events.size)
+        Assertions.assertSame(quitEvent, events[0])
+        events.subList(1, events.size).forEach { event ->
+            (event as ChannelQuit).let {
+                Assertions.assertEquals(TestConstants.time, it.time)
+                Assertions.assertEquals("zerocool", it.user.nickname)
+                Assertions.assertEquals("Hack the planet!", it.reason)
+                names.add(it.channel)
+            }
+        }
+
+        Assertions.assertTrue("#thegibson" in names)
+        Assertions.assertTrue("#dumpsterdiving" in names)
+    }
+
+    @Test
+    fun `raises ChannelNickChanged event for each channel a user changes nicks in`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        with (ChannelState("#dumpsterdiving") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        with (ChannelState("#chat") { CaseMapping.Rfc }) {
+            users += ChannelUser("AcidBurn")
+            channelStateMap += this
+        }
+
+        val nickEvent = UserNickChanged(TestConstants.time, User("zerocool", "dade", "root.localhost"), "zer0c00l")
+        val events = mutator.mutateEvent(ircClient, nickEvent)
+
+        val names = mutableListOf<String>()
+        Assertions.assertEquals(3, events.size)
+        Assertions.assertSame(nickEvent, events[0])
+        events.subList(1, events.size).forEach { event ->
+            (event as ChannelNickChanged).let {
+                Assertions.assertEquals(TestConstants.time, it.time)
+                Assertions.assertEquals("zerocool", it.user.nickname)
+                Assertions.assertEquals("zer0c00l", it.newNick)
+                names.add(it.channel)
+            }
+        }
+
+        Assertions.assertTrue("#thegibson" in names)
+        Assertions.assertTrue("#dumpsterdiving" in names)
+    }
+}

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ServerReadyMutatorTest.kt

+package com.dmdirc.ktirc.events.mutators
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.*
+import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.ServerStatus
+import com.dmdirc.ktirc.model.User
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+internal class ServerReadyMutatorTest {
+
+    private val serverState = ServerState("", "")
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+    }
+
+    private val mutator = ServerReadyMutator()
+
+
+    @Test
+    fun `emits event on receiving post-005 line`() {
+        ircClient.serverState.receivedWelcome = true
+        ircClient.serverState.status = ServerStatus.Negotiating
+
+        listOf(
+                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
+                PingReceived(TestConstants.time, "1234".toByteArray()),
+                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
+                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
+                ServerCapabilitiesFinished(TestConstants.time)
+        ).forEach {
+            assertEquals(1, mutator.mutateEvent(ircClient, it).size)
+        }
+
+        val event = MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!")
+        val events = mutator.mutateEvent(ircClient, event)
+        assertEquals(2, events.size)
+        assertSame(event, events[1])
+        assertTrue(events[0] is ServerReady)
+    }
+
+}

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

-package com.dmdirc.ktirc.handlers
-
-import com.dmdirc.ktirc.IrcClient
-import com.dmdirc.ktirc.TestConstants
-import com.dmdirc.ktirc.events.*
-import com.dmdirc.ktirc.model.*
-import com.nhaarman.mockitokotlin2.doReturn
-import com.nhaarman.mockitokotlin2.mock
-import kotlinx.coroutines.runBlocking
-import org.junit.jupiter.api.Assertions.*
-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(TestConstants.time, "the.gibson", "acidBurn"))
-        assertEquals("acidBurn", serverState.localNickname)
-    }
-
-    @Test
-    fun `ServerStateHandler sets server name on welcome event`() = runBlocking {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
-        assertEquals("the.gibson", serverState.serverName)
-    }
-
-    @Test
-    fun `ServerStateHandler sets receivedWelcome on welcome event`() = runBlocking {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
-        assertTrue(serverState.receivedWelcome)
-    }
-
-    @Test
-    fun `ServerStateHandler sets state to connecting on event`() = runBlocking {
-        handler.processEvent(ircClient, ServerConnecting(TestConstants.time))
-        assertEquals(ServerStatus.Connecting, serverState.status)
-    }
-
-    @Test
-    fun `ServerStateHandler sets state to disconnected on event`() = runBlocking {
-        serverState.status = ServerStatus.Ready
-        handler.processEvent(ircClient, ServerDisconnected(TestConstants.time))
-        assertEquals(ServerStatus.Disconnected, serverState.status)
-    }
-
-    @Test
-    fun `ServerStateHandler sets state to negotiating on connected`() = runBlocking {
-        handler.processEvent(ircClient, ServerConnected(TestConstants.time))
-        assertEquals(ServerStatus.Negotiating, serverState.status)
-    }
-
-    @Test
-    fun `ServerStateHandler sets server state to ready on receiving post-005 line`() = runBlocking {
-        ircClient.serverState.status = ServerStatus.Negotiating
-
-        listOf(
-                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
-                PingReceived(TestConstants.time, "1234".toByteArray()),
-                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
-                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
-                ServerCapabilitiesFinished(TestConstants.time),
-                MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!")
-        ).forEach {
-            assertEquals(ServerStatus.Negotiating, serverState.status)
-            handler.processEvent(ircClient, it)
-        }
-
-        assertEquals(ServerStatus.Ready, serverState.status)
-    }
-
-    @Test
-    fun `ServerStateHandler emits event on receiving post-005 line`() = runBlocking {
-        ircClient.serverState.status = ServerStatus.Negotiating
-
-        listOf(
-                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
-                PingReceived(TestConstants.time, "1234".toByteArray()),
-                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
-                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
-                ServerCapabilitiesFinished(TestConstants.time)
-        ).forEach {
-            assertTrue(handler.processEvent(ircClient, it).isEmpty())
-        }
-
-        val events = handler.processEvent(ircClient, MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!"))
-        assertEquals(1, events.size)
-        assertTrue(events[0] is ServerReady)
-    }
-
-    @Test
-    fun `ServerStateHandler updates features on features event`() = runBlocking {
-        val features = ServerFeatureMap()
-        features[ServerFeature.ChannelModes] = arrayOf("abc", "def")
-        features[ServerFeature.WhoxSupport] = true
-
-        handler.processEvent(ircClient, ServerFeaturesUpdated(TestConstants.time, features))
-
-        assertArrayEquals(arrayOf("abc", "def"), serverState.features[ServerFeature.ChannelModes])
-        assertEquals(true, serverState.features[ServerFeature.WhoxSupport])
-    }
-
-}

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

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
-import com.dmdirc.ktirc.handlers.EventHandler
 import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.events.ServerReady
 import com.dmdirc.ktirc.events.ServerWelcome
+import com.dmdirc.ktirc.events.handlers.EventHandler
+import com.dmdirc.ktirc.events.mutators.EventMutator
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.model.IrcMessage
 import com.nhaarman.mockitokotlin2.*
     }
 
     @Test
-    fun `MessageHandler passes message on to correct processor`() = runBlocking<Unit> {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
+    fun `passes message on to correct processor`() = runBlocking<Unit> {
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf())
         val message = IrcMessage(emptyMap(), null, "JOIN", emptyList())
 
         with(Channel<IrcMessage>(1)) {
     }
 
     @Test
-    fun `MessageHandler reads multiple messages`() = runBlocking<Unit> {
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
+    fun `reads multiple messages`() = runBlocking<Unit> {
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf())
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
         val nickMessage = IrcMessage(emptyMap(), null, "NICK", emptyList())
         val otherMessage = IrcMessage(emptyMap(), null, "OTHER", emptyList())
     }
 
     @Test
-    fun `MessageHandler invokes all event handler with all returned events`() = runBlocking<Unit> {
+    fun `invokes all event handler with all returned events`() = runBlocking {
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
-        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
+        val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
         whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(TestConstants.time), ServerWelcome(TestConstants.time, "the.gibson", "acidBurn")))
 
     }
 
     @Test
-    fun `MessageHandler emits custom events to all handlers`() = runBlocking<Unit> {
+    fun `emits custom events to all handlers`() {
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
-        val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
+        val handler = MessageHandler(emptyList(), emptyList(), mutableListOf(eventHandler1, eventHandler2))
         handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
 
         verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
     }
 
     @Test
-    fun `MessageHandler emits events returned from handler`() = runBlocking<Unit> {
-        val eventHandler1 = mock<EventHandler> {
-            on { processEvent(any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(TestConstants.time))
+    fun `mutates events in order`() {
+        val eventMutator1 = mock<EventMutator> {
+            on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(TestConstants.time))
         }
-        val eventHandler2 = mock<EventHandler>()
-        val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
+        val eventMutator2 = mock<EventMutator> {
+            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerConnected(TestConstants.time))
+        }
+        val eventHandler = mock<EventHandler>()
+
+        val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+
+        verify(eventMutator1).mutateEvent(same(ircClient), isA<ServerWelcome>())
+        verify(eventMutator2).mutateEvent(same(ircClient), isA<ServerReady>())
+        verify(eventHandler).processEvent(same(ircClient), isA<ServerConnected>())
+        verifyNoMoreInteractions(eventHandler)
+    }
+
+    @Test
+    fun `allows mutators to fan out events`() {
+        val eventMutator1 = mock<EventMutator> {
+            on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn listOf(
+                    ServerReady(TestConstants.time),
+                    ServerConnected(TestConstants.time)
+            )
+        }
+        val eventMutator2 = mock<EventMutator> {
+            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerReady(TestConstants.time))
+            on { mutateEvent(any(), isA<ServerConnected>()) } doReturn listOf(ServerConnected(TestConstants.time))
+        }
+        val eventHandler = mock<EventHandler>()
+
+        val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+
+        with (inOrder(eventMutator2, eventHandler)) {
+            verify(eventMutator2).mutateEvent(same(ircClient), isA<ServerReady>())
+            verify(eventMutator2).mutateEvent(same(ircClient), isA<ServerConnected>())
+            verify(eventHandler).processEvent(same(ircClient), isA<ServerReady>())
+            verify(eventHandler).processEvent(same(ircClient), isA<ServerConnected>())
+        }
+    }
+
+    @Test
+    fun `allows mutators to suppress events`() {
+        val eventMutator1 = mock<EventMutator> {
+            on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn emptyList()
+        }
+        val eventMutator2 = mock<EventMutator>()
+        val eventHandler = mock<EventHandler>()
+
+        val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
         handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
 
-        verify(eventHandler1).processEvent(same(ircClient), isA<ServerReady>())
-        verify(eventHandler2).processEvent(same(ircClient), isA<ServerReady>())
+        verify(eventMutator2, never()).mutateEvent(any(), any())
+        verify(eventHandler, never()).processEvent(any(), any())
     }
 
-}
+}