Add kick processing and event

Closes #7

CHANGELOG

  * Other new events:
     * Added MotdFinished event
     * Added UserAccountChanged event
+    * Added ChannelUserKicked event
  * Improved some documentation
 
 v0.4.0

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

     /**
      * Utility method to determine if the given user is the one we are connected to IRC as.
      */
-    fun isLocalUser(user: User) = caseMapping.areEquivalent(user.nickname, serverState.localNickname)
+    fun isLocalUser(user: User) = isLocalUser(user.nickname)
+
+    /**
+     * Utility method to determine if the given user is the one we are connected to IRC as.
+     */
+    fun isLocalUser(nickname: String) = caseMapping.areEquivalent(nickname, serverState.localNickname)
 
 }
 

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

             is ChannelParted -> handlePart(client, event)
             is ChannelNamesReceived -> handleNamesReceived(client, event)
             is ChannelNamesFinished -> handleNamesFinished(client, event)
+            is ChannelUserKicked -> handleKick(client, event)
             is ModeChanged -> handleModeChanged(client, event)
             is UserQuit -> return handleQuit(client, event)
         }
         }
     }
 
+    private fun handleKick(client: IrcClient, event: ChannelUserKicked) {
+        if (client.isLocalUser(event.victim)) {
+            log.info { "Kicked from channel: ${event.channel}" }
+            client.channelState -= event.channel
+        } else {
+            client.channelState[event.channel]?.let {
+                it.users -= event.victim
+            }
+        }
+    }
+
     private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
         val channel = client.channelState[event.channel] ?: return
 

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

 /** Raised when a user leaves a channel. */
 class ChannelParted(time: LocalDateTime, val user: User, val channel: String, val reason: String = "") : IrcEvent(time)
 
+/** Raised when a [victim] is kicked from a channel. */
+class ChannelUserKicked(time: LocalDateTime, val user: User, val channel: String, val victim: String, val reason: String = ""): IrcEvent(time)
+
 /** 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)
 

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

         when (event) {
             is ChannelJoined -> handleJoin(client.userState, event)
             is ChannelParted -> handlePart(client, event)
+            is ChannelUserKicked -> handleKick(client, event)
             is ChannelNamesReceived  -> handleNamesReceived(client, event)
             is UserAccountChanged -> handleAccountChanged(client, event)
             is UserQuit -> handleQuit(client.userState, event)
         }
     }
 
+    private fun handleKick(client: IrcClient, event: ChannelUserKicked) {
+        if (client.isLocalUser(event.victim)) {
+            // Remove channel from all users
+            client.userState.forEach { it.channels -= event.channel }
+            client.userState.removeIf { it.channels.isEmpty() && !client.isLocalUser(it.details) }
+        } else {
+            client.userState[event.victim]?.channels?.let {
+                it -= event.channel
+                if (it.isEmpty()) {
+                    client.userState -= event.victim
+                }
+            }
+        }
+    }
+
     private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
         event.toModesAndUsers(client).forEach { (_, user) ->
             client.userState.addToChannel(user, event.channel)

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

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ChannelUserKicked
+import com.dmdirc.ktirc.model.IrcMessage
+
+internal class KickProcessor : MessageProcessor {
+
+    override val commands = arrayOf("KICK")
+
+    override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
+        listOf(ChannelUserKicked(message.time, user, message.channel, message.victim, message.reason))
+    } ?: emptyList()
+
+    private val IrcMessage.channel
+        get() = String(params[0])
+
+    private val IrcMessage.victim
+        get() = String(params[1])
+
+    private val IrcMessage.reason
+        get() = if (params.size > 2) String(params[2]) else ""
+
+}

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

         CapabilityProcessor(),
         ISupportProcessor(),
         JoinProcessor(),
+        KickProcessor(),
         ModeProcessor(),
         MotdProcessor(),
         NamesProcessor(),

src/main/kotlin/com/dmdirc/ktirc/model/UserState.kt

 
     internal operator fun plusAssign(details: User) { users += KnownUser(caseMappingProvider, details) }
     internal operator fun minusAssign(details: User) { users -= details.nickname }
+    internal operator fun minusAssign(nickname: String) { users -= nickname }
 
     /** Provides a read-only iterator of all users. */
     override operator fun iterator() = users.iterator().iterator()

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

         assertFalse(client.isLocalUser(User("acid-Burn", "libby", "root.localhost")))
     }
 
+    @Test
+    fun `IrcClient indicates if nickname is local user or not`() {
+        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        client.serverState.localNickname = "[acidBurn]"
+
+        assertTrue(client.isLocalUser("{acidBurn}"))
+        assertFalse(client.isLocalUser("acid-Burn"))
+    }
+
     @Test
     fun `IrcClient uses current case mapping to check local user`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))

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

         on { serverState } doReturn serverState
         on { channelState } doReturn channelStateMap
         on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
+        on { isLocalUser("acidburn") } doReturn  true
     }
 
     @Test
-    fun `ChannelStateHandler creates new state object for local joins`() {
+    fun `creates new state object for local joins`() {
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
         assertTrue("#thegibson" in channelStateMap)
     }
 
     @Test
-    fun `ChannelStateHandler does not create new state object for remote joins`() {
+    fun `does not create new state object for remote joins`() {
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
         assertFalse("#thegibson" in channelStateMap)
     }
 
     @Test
-    fun `ChannelStateHandler adds joiners to channel state`() {
+    fun `adds joiners to channel state`() {
         channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
 
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
     }
 
     @Test
-    fun `ChannelStateHandler clears existing users when getting a new list`() {
+    fun `clears existing users when getting a new list`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("acidBurn")
         channel.users += ChannelUser("thePlague")
     }
 
     @Test
-    fun `ChannelStateHandler adds users from multiple name received events`() {
+    fun `adds users from multiple name received events`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler clears and readds users on additional names received`() {
+    fun `clears and readds users on additional names received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler adds users with mode prefixes`() {
+    fun `adds users with mode prefixes`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
-    fun `ChannelStateHandler adds users with full hosts`() {
+    fun `adds users with full hosts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
-    fun `ChannelStateHandler removes state object for local parts`() {
+    fun `removes state object for local parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler removes user from channel member list for remote parts`() {
+    fun `removes user from channel member list for remote parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("ZeroCool")
         channelStateMap += channel
     }
 
     @Test
-    fun `ChannelStateHandler removes user from all channel member lists for quits`() {
+    fun `removes state object for local kicks`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson", "acidburn", "Bye!"))
+
+        assertFalse("#thegibson" in channelStateMap)
+    }
+
+    @Test
+    fun `removes user from channel member list for remote kicks`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channel.users += ChannelUser("ZeroCool")
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson", "zerocool", "Bye!"))
+
+        assertFalse("zerocool" in channel.users)
+    }
+
+    @Test
+    fun `removes user from all channel member lists for quits`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
             channelStateMap += this
 
 
     @Test
-    fun `ChannelStateHandler raises ChannelQuit event for each channel a user quits from`() {
+    fun `raises ChannelQuit event for each channel a user quits from`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
             channelStateMap += this

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

     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
         on { userState } doReturn userState
-        on { isLocalUser(argForWhich { nickname == "zeroCool" }) } doReturn true
+        on { isLocalUser(argForWhich<User> { nickname == "zeroCool" }) } doReturn true
+        on { isLocalUser("zeroCool") } doReturn true
     }
 
     private val handler = UserStateHandler()
         }
     }
 
+
+    @Test
+    fun `removes channel from user on kick`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#thegibson")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
+
+            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")
+
+            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "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("zeroCool")
+            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+            userState.addToChannel(User("zeroCool"), "#thegibson")
+
+            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+
+            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")
+
+            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+
+            assertNull(userState["acidBurn"])
+        }
+    }
+
+    @Test
+    fun `keeps local user with no remaining channels after local kick`() {
+        runBlocking {
+            userState += User("zeroCool")
+            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+
+            assertNotNull(userState["zeroCool"])
+        }
+    }
+
     @Test
     fun `removes user entirely on quit`() {
         runBlocking {

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

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
+import com.dmdirc.ktirc.util.currentTimeProvider
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class KickProcessorTest {
+
+    @BeforeEach
+    fun setUp() {
+        currentTimeProvider = { TestConstants.time }
+    }
+
+    @Test
+    fun `raises kick event without message`() {
+        val events = KickProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "KICK", params("#crashandburn", "zeroCool")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("zeroCool", events[0].victim)
+        assertEquals("", events[0].reason)
+    }
+
+    @Test
+    fun `raises kick event with message`() {
+        val events = KickProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "KICK", params("#crashandburn", "zeroCool", "Hack the planet!")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
+        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("zeroCool", events[0].victim)
+        assertEquals("Hack the planet!", events[0].reason)
+    }
+
+    @Test
+    fun `does nothing if prefix missing`() {
+        val events = KickProcessor().process(
+                IrcMessage(emptyMap(), null, "KICK", params("#crashandburn", "zeroCool")))
+        assertEquals(0, events.size)
+    }
+
+}

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

         assertNull(userState["acidburn"])
     }
 
+    @Test
+    fun `UserState removes users by nickname`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState -= "ACIDBURN"
+        assertNull(userState["acidburn"])
+    }
+
     @Test
     fun `UserState updates existing user with same nickname`() {
         userState += User("acidBurn", "libby", "root.localhost")