Support for nick changes

CHANGELOG

@@ -8,6 +8,7 @@ vNEXT (in development)
    * The enabled mechanisms can now be configured (in the SASL DSL)
    * Added support for EXTERNAL mechanism, disabled by default
    * Now attempts to renegotiate if the server doesn't recognise the SASL mechanism that was tried
+ * Added UserNickChanged and corresponding ChannelNickChanged events
  * (Internal) Minor version updates for Gradle, Kotlin and JUnit
 
 v0.6.0

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

@@ -18,6 +18,7 @@ internal class ChannelStateHandler : EventHandler {
             is ChannelUserKicked -> handleKick(client, event)
             is ModeChanged -> handleModeChanged(client, event)
             is UserQuit -> return handleQuit(client, event)
+            is UserNickChanged -> return handleNickChanged(client, event)
         }
         return emptyList()
     }
@@ -87,29 +88,28 @@ internal class ChannelStateHandler : EventHandler {
             when (char) {
                 '+' -> adding = true
                 '-' -> adding = false
-                else -> argumentOffset += adjustMode(client, chan, char, event.arguments, argumentOffset, adding)
+                else -> argumentOffset += if (client.serverState.isChannelUserMode(char)) {
+                    adjustUserMode(client, chan, char, adding, event.arguments[argumentOffset])
+                } else {
+                    adjustMode(client, chan, char, event.arguments, argumentOffset, adding)
+                }
             }
         }
     }
 
     private fun adjustMode(client: IrcClient, chan: ChannelState, mode: Char, arguments: Array<String>, argumentOffset: Int, adding: Boolean): Int {
-        return if (client.serverState.isChannelUserMode(mode)) {
-            adjustUserMode(client, chan, mode, adding, arguments[argumentOffset])
-            1
+        val type = client.serverState.channelModeType(mode)
+        val takesParam = if (adding) type.needsParameterToSet else type.needsParameterToUnset
+        val param = if (takesParam) arguments[argumentOffset] else ""
+        if (adding) {
+            chan.modes[mode] = param
         } else {
-            val type = client.serverState.channelModeType(mode)
-            val takesParam = if (adding) type.needsParameterToSet else type.needsParameterToUnset
-            val param = if (takesParam) arguments[argumentOffset] else ""
-            if (adding) {
-                chan.modes[mode] = param
-            } else {
-                chan.modes.remove(mode)
-            }
-            if (takesParam) 1 else 0
+            chan.modes.remove(mode)
         }
+        return if (takesParam) 1 else 0
     }
 
-    private fun adjustUserMode(client: IrcClient, chan: ChannelState, mode: Char, adding: Boolean, user: String) {
+    private fun adjustUserMode(client: IrcClient, chan: ChannelState, mode: Char, adding: Boolean, user: String): Int {
         chan.users[user]?.let { channelUser ->
             // Filter from the master list of mode prefixes so that ordering is consistent
             channelUser.modes = client.serverState.channelModePrefixes.modes.filter {
@@ -120,6 +120,7 @@ internal class ChannelStateHandler : EventHandler {
                 }
             }
         }
+        return 1
     }
 
     private fun handleQuit(client: IrcClient, event: UserQuit) = sequence {
@@ -131,4 +132,13 @@ internal class ChannelStateHandler : EventHandler {
         }
     }.toList()
 
+    private fun handleNickChanged(client: IrcClient, event: UserNickChanged) = sequence {
+        client.channelState.forEach {
+            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/events/Events.kt

@@ -41,6 +41,9 @@ class ChannelUserKicked(time: LocalDateTime, val user: User, val channel: String
 /** Raised when a user quits, and is in a channel. */
 class ChannelQuit(time: LocalDateTime, val user: User, val channel: String, val reason: String = "") : IrcEvent(time)
 
+/** Raised when a user changes nickname, and is in a channel. */
+class ChannelNickChanged(time: LocalDateTime, val user: User, val channel: String, val newNick: String) : IrcEvent(time)
+
 /** Raised when a batch of the channel's member list has been received. More batches may follow. */
 class ChannelNamesReceived(time: LocalDateTime, val channel: String, val names: List<String>) : IrcEvent(time)
 
@@ -69,6 +72,9 @@ class CtcpReplyReceived(time: LocalDateTime, val user: User, val target: String,
 /** Raised when a user quits. */
 class UserQuit(time: LocalDateTime, val user: User, val reason: String = "") : IrcEvent(time)
 
+/** Raised when a user changes nickname. */
+class UserNickChanged(time: LocalDateTime, val user: User, val newNick: String) : IrcEvent(time)
+
 /**
  * Raised when a user's account changes (i.e., they auth'd or deauth'd with services).
  *

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

@@ -12,6 +12,7 @@ internal class UserStateHandler : EventHandler {
             is ChannelUserKicked -> handleKick(client, event)
             is ChannelNamesReceived  -> handleNamesReceived(client, event)
             is UserAccountChanged -> handleAccountChanged(client, event)
+            is UserNickChanged -> handleNickChanged(client, event)
             is UserQuit -> handleQuit(client.userState, event)
         }
         return emptyList()
@@ -63,6 +64,13 @@ internal class UserStateHandler : EventHandler {
         client.userState[event.user]?.details?.account = event.newAccount
     }
 
+    private fun handleNickChanged(client: IrcClient, event: UserNickChanged) {
+        client.userState[event.user]?.details?.nickname = event.newNick
+        if (client.isLocalUser(event.user)) {
+            client.serverState.localNickname = event.newNick
+        }
+    }
+
     private fun handleQuit(state: UserState, event: UserQuit) {
         state -= event.user
     }

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

@@ -27,6 +27,7 @@ internal val messageProcessors = setOf(
         ModeProcessor(),
         MotdProcessor(),
         NamesProcessor(),
+        NickProcessor(),
         NoticeProcessor(),
         PartProcessor(),
         PingProcessor(),

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

@@ -0,0 +1,14 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.UserNickChanged
+import com.dmdirc.ktirc.model.IrcMessage
+
+internal class NickProcessor : MessageProcessor {
+
+    override val commands = arrayOf("NICK")
+
+    override fun process(message: IrcMessage) =
+            message.sourceUser?.let { listOf(UserNickChanged(message.time, it, String(message.params[0]))) }
+                    ?: emptyList()
+
+}

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

@@ -217,6 +217,53 @@ internal class ChannelStateHandlerTest {
         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"))
+
+        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/events/UserStateHandlerTest.kt

@@ -7,7 +7,7 @@ import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.argForWhich
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
-import kotlinx.coroutines.runBlocking
+import com.nhaarman.mockitokotlin2.whenever
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
@@ -33,210 +33,200 @@ internal class UserStateHandlerTest {
 
     @Test
     fun `adds channel to user on join`() {
-        runBlocking {
-            userState += User("acidBurn")
+        userState += User("acidBurn")
 
-            handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
-            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-        }
+        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `updates user info on join`() {
-        runBlocking {
-            userState += User("acidBurn")
+        userState += User("acidBurn")
 
-            handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
-            val details = userState["acidBurn"]?.details!!
-            assertEquals("libby", details.ident)
-            assertEquals("root.localhost", details.hostname)
-        }
+        val details = userState["acidBurn"]?.details!!
+        assertEquals("libby", details.ident)
+        assertEquals("root.localhost", details.hostname)
     }
 
     @Test
     fun `removes channel from user on part`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#thegibson")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#thegibson")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
-            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-        }
+        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `removes user on part from last channel`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
-            assertNull(userState["acidBurn"])
-        }
+        assertNull(userState["acidBurn"])
     }
 
     @Test
     fun `removes channel from all users on local part`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
-            userState.addToChannel(User("acidBurn"), "#thegibson")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState.addToChannel(User("acidBurn"), "#thegibson")
 
-            userState += User("zeroCool")
-            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
-            userState.addToChannel(User("zeroCool"), "#thegibson")
+        userState += User("zeroCool")
+        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        userState.addToChannel(User("zeroCool"), "#thegibson")
 
-            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-            assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
-        }
+        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
     }
 
     @Test
     fun `removes remote users with no remaining channels on local part`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-            assertNull(userState["acidBurn"])
-        }
+        assertNull(userState["acidBurn"])
     }
 
     @Test
     fun `keeps local user with no remaining channels after local part`() {
-        runBlocking {
-            userState += User("zeroCool")
-            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        userState += User("zeroCool")
+        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
-            assertNotNull(userState["zeroCool"])
-        }
+        assertNotNull(userState["zeroCool"])
     }
 
 
     @Test
     fun `removes channel from user on kick`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#thegibson")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#thegibson")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
-            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-        }
+        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `removes user on kick from last channel`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
-            assertNull(userState["acidBurn"])
-        }
+        assertNull(userState["acidBurn"])
     }
 
     @Test
     fun `removes channel from all users on local kick`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
-            userState.addToChannel(User("acidBurn"), "#thegibson")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState.addToChannel(User("acidBurn"), "#thegibson")
 
-            userState += User("zeroCool")
-            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
-            userState.addToChannel(User("zeroCool"), "#thegibson")
+        userState += User("zeroCool")
+        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        userState.addToChannel(User("zeroCool"), "#thegibson")
 
-            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
-            assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
-        }
+        assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
     }
 
     @Test
     fun `removes remote users with no remaining channels on local kick`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-            assertNull(userState["acidBurn"])
-        }
+        assertNull(userState["acidBurn"])
     }
 
     @Test
     fun `keeps local user with no remaining channels after local kick`() {
-        runBlocking {
-            userState += User("zeroCool")
-            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+        userState += User("zeroCool")
+        userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
-            assertNotNull(userState["zeroCool"])
-        }
+        assertNotNull(userState["zeroCool"])
     }
 
     @Test
     fun `removes user entirely on quit`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, UserQuit(TestConstants.time, User("acidBurn", "libby", "root.localhost")))
+        handler.processEvent(ircClient, UserQuit(TestConstants.time, User("acidBurn", "libby", "root.localhost")))
 
-            assertNull(userState["acidBurn"])
-        }
+        assertNull(userState["acidBurn"])
     }
 
     @Test
     fun `adds users to channels on names received`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn")))
 
-            assertEquals(listOf("#dumpsterdiving", "#thegibson"), userState["acidBurn"]?.channels?.toList())
-        }
+        assertEquals(listOf("#dumpsterdiving", "#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
 
     @Test
     fun `updates user details on names received`() {
-        runBlocking {
-            userState += User("acidBurn")
-            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+        userState += User("acidBurn")
+        userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-            handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn!libby@root.localhost")))
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn!libby@root.localhost")))
 
-            val details = userState["acidBurn"]?.details!!
-            assertEquals("libby", details.ident)
-            assertEquals("root.localhost", details.hostname)
-        }
+        val details = userState["acidBurn"]?.details!!
+        assertEquals("libby", details.ident)
+        assertEquals("root.localhost", details.hostname)
     }
 
     @Test
     fun `updates user info on account change`() {
-        runBlocking {
-            userState += User("acidBurn")
+        userState += User("acidBurn")
 
-            handler.processEvent(ircClient, UserAccountChanged(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "acidBurn"))
+        handler.processEvent(ircClient, UserAccountChanged(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "acidBurn"))
 
-            val details = userState["acidBurn"]?.details!!
-            assertEquals("acidBurn", details.account)
-        }
+        val details = userState["acidBurn"]?.details!!
+        assertEquals("acidBurn", details.account)
     }
-}
+
+    @Test
+    fun `updates local nickname for local nick changes`() {
+        val user = User("acidBurn", "libby", "root.localhost")
+        whenever(ircClient.isLocalUser(user)).doReturn(true)
+
+        handler.processEvent(ircClient, UserNickChanged(TestConstants.time, user, "acid~"))
+
+        assertEquals("acid~", serverState.localNickname)
+    }
+
+    @Test
+    fun `updates nickname for remote nick changes`() {
+        val user = User("acidBurn", "libby", "root.localhost")
+        userState += User("AcidBurn")
+
+        handler.processEvent(ircClient, UserNickChanged(TestConstants.time, user, "acid~"))
+
+        assertNotNull(userState["acid~"])
+        assertNull(userState["AcidBurn"])
+        assertEquals("acid~", userState["acid~"]?.details?.nickname)
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.params
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+internal class NickProcessorTest {
+
+    @Test
+    fun `raises UserChangedNick event if prefix is valid`() {
+        val processor = NickProcessor()
+        val events = processor.process(IrcMessage(emptyMap(), "acidBurn!acidb@localhost".toByteArray(), "NICK", params("acidB")))
+
+        assertEquals(1, events.size)
+        val event = events[0]
+        assertEquals("acidBurn", event.user.nickname)
+        assertEquals("acidb", event.user.ident)
+        assertEquals("localhost", event.user.hostname)
+        assertEquals("acidB", event.newNick)
+    }
+
+    @Test
+    fun `does nothing if prefix is missing`() {
+        val processor = NickProcessor()
+        val events = processor.process(IrcMessage(emptyMap(), null, "NICK", params("acidB")))
+        assertTrue(events.isEmpty())
+    }
+
+}