Add join failed event

CHANGELOG

@@ -1,6 +1,7 @@
 vNEXT (in development)
 
  * Added SourcedEvent interface for events that have a user source attached
+ * Added ChannelJoinFailed event
 
 v0.10.3
 

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

@@ -27,7 +27,7 @@ internal data class IrcClientConfig(
  *
  * profile {
  *     nickname = "MyBot"           // Required
- *     username = "bot
+ *     username = "bot"
  *     realName = "Botomatic v1.2"
  * }
  *

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

@@ -95,6 +95,39 @@ class PingReceived(metadata: EventMetadata, val nonce: ByteArray) : IrcEvent(met
 /** Raised when a user joins a channel. */
 class ChannelJoined(metadata: EventMetadata, override val user: User, channel: String) : TargetedEvent(metadata, channel), SourcedEvent
 
+/** Raised when an attempt to join a channel fails. */
+class ChannelJoinFailed(metadata: EventMetadata, channel: String, val reason: JoinError) : TargetedEvent(metadata, channel) {
+    /** Reasons a join may fail. */
+    enum class JoinError {
+        /** We are already in the maximum number of channels allowed by the server. */
+        TooManyChannels,
+        /** The channel is no-hiding (+H), but we have invisible join/parts enabled. */
+        NoHiding,
+        /** The channel is keyed (+k) and a valid key was not provided. */
+        NeedKey,
+        /** The channel is invite only (+i) and no invite was received. */
+        NeedInvite,
+        /** The channel is limited to registered users only, and we are not registered. */
+        NeedRegisteredNick,
+        /** The channel is secure-only, and we're not using TLS. */
+        NeedTls,
+        /** The channel is limited to server admins and we are not one. */
+        NeedAdmin,
+        /** The channel is limited to ircops and we are not one. */
+        NeedOper,
+        /** We are banned from the channel. */
+        Banned,
+        /** The channel is limited (+l) and currently full. */
+        ChannelFull,
+        /** The channel name is disallowed by the server. */
+        BadChannelName,
+        /** We're trying to joiin too many channels and have been throttled. */
+        Throttled,
+        /** We don't know why. */
+        Unknown
+    }
+}
+
 /** Raised when a user leaves a channel. */
 class ChannelParted(metadata: EventMetadata, override val user: User, channel: String, val reason: String = "") : TargetedEvent(metadata, channel), SourcedEvent
 

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

@@ -1,5 +1,9 @@
 package com.dmdirc.ktirc.messages
 
+// Sources:
+// ircd-seven: https://github.com/freenode/ircd-seven/blob/master/src/messages.tab
+// unreal: https://github.com/unrealircd/unrealircd/blob/master/src/s_err.c
+
 internal const val CTCP_BYTE : Byte = 1
 
 internal const val RPL_WELCOME = "001"
@@ -15,11 +19,24 @@ internal const val RPL_MOTD = "372"
 internal const val RPL_MOTDSTART = "375"
 internal const val RPL_ENDOFMOTD = "376"
 
+internal const val ERR_TOOMANYCHANNELS = "405"
 internal const val ERR_NOMOTD = "422"
 internal const val ERR_NONICKNAMEGIVEN = "431"
 internal const val ERR_ERRONEUSNICKNAME = "432"
 internal const val ERR_NICKNAMEINUSE = "433"
 internal const val ERR_NICKCOLLISION = "436"
+internal const val ERR_NOHIDING = "459" // Unreal
+internal const val ERR_CHANNELISFULL = "471"
+internal const val ERR_INVITEONLYCHAN = "473"
+internal const val ERR_BANNEDFROMCHAN = "474"
+internal const val ERR_BADCHANNELKEY = "475"
+internal const val ERR_NEEDREGGEDNICK = "477"
+internal const val ERR_BADCHANNAME = "479"
+internal const val ERR_THROTTLE = "480" // ircd-seven
+internal const val ERR_SECUREONLYCHAN = "489" // Unreal, inspircd
+internal const val ERR_TOOMANYJOINS = "500" // Unreal, same as ERR_THROTTLE
+internal const val ERR_ADMINONLY = "519" // Unreal
+internal const val ERR_OPERONLY = "520" // Unreal
 
 internal const val RPL_SASLSUCCESS = "903"
 internal const val ERR_SASLFAIL = "904"

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

@@ -1,17 +1,40 @@
 package com.dmdirc.ktirc.messages.processors
 
+import com.dmdirc.ktirc.events.ChannelJoinFailed
 import com.dmdirc.ktirc.events.ChannelJoined
+import com.dmdirc.ktirc.messages.*
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 
 internal class JoinProcessor : MessageProcessor {
 
-    override val commands = arrayOf("JOIN")
+    override val commands = arrayOf(
+            "JOIN",
+            ERR_TOOMANYCHANNELS,
+            ERR_NOHIDING,
+            ERR_CHANNELISFULL,
+            ERR_INVITEONLYCHAN,
+            ERR_BANNEDFROMCHAN,
+            ERR_BADCHANNELKEY,
+            ERR_NEEDREGGEDNICK,
+            ERR_BADCHANNAME,
+            ERR_THROTTLE,
+            ERR_SECUREONLYCHAN,
+            ERR_TOOMANYJOINS,
+            ERR_ADMINONLY,
+            ERR_OPERONLY)
 
-    override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        user.addExtendedJoinFields(message.params)
-        listOf(ChannelJoined(message.metadata, user, String(message.params[0])))
-    } ?: emptyList()
+    override fun process(message: IrcMessage) = when {
+        message.command == "JOIN" ->
+            message.sourceUser?.let { user ->
+                user.addExtendedJoinFields(message.params)
+                listOf(ChannelJoined(message.metadata, user, String(message.params[0])))
+            } ?: emptyList()
+        message.params.size >= 2 ->
+            listOf(ChannelJoinFailed(message.metadata, String(message.params[1]), message.command.toReason()))
+        else ->
+            emptyList()
+    }
 
     private fun User.addExtendedJoinFields(params: List<ByteArray>) {
         if (params.size == 3) {
@@ -20,4 +43,22 @@ internal class JoinProcessor : MessageProcessor {
         }
     }
 
+    private fun String.toReason() = when (this) {
+        ERR_TOOMANYCHANNELS -> ChannelJoinFailed.JoinError.TooManyChannels
+        ERR_NOHIDING -> ChannelJoinFailed.JoinError.NoHiding
+        ERR_CHANNELISFULL -> ChannelJoinFailed.JoinError.ChannelFull
+        ERR_INVITEONLYCHAN -> ChannelJoinFailed.JoinError.NeedInvite
+        ERR_BANNEDFROMCHAN -> ChannelJoinFailed.JoinError.Banned
+        ERR_BADCHANNELKEY -> ChannelJoinFailed.JoinError.NeedKey
+        ERR_NEEDREGGEDNICK -> ChannelJoinFailed.JoinError.NeedRegisteredNick
+        ERR_BADCHANNAME -> ChannelJoinFailed.JoinError.BadChannelName
+        ERR_THROTTLE -> ChannelJoinFailed.JoinError.Throttled
+        ERR_SECUREONLYCHAN -> ChannelJoinFailed.JoinError.NeedTls
+        ERR_TOOMANYJOINS -> ChannelJoinFailed.JoinError.Throttled
+        ERR_ADMINONLY -> ChannelJoinFailed.JoinError.NeedAdmin
+        ERR_OPERONLY -> ChannelJoinFailed.JoinError.NeedOper
+        else -> ChannelJoinFailed.JoinError.Unknown
+    }
+
 }
+

src/test/kotlin/com/dmdirc/ktirc/messages/processors/JoinProcessorTest.kt

@@ -1,6 +1,8 @@
 package com.dmdirc.ktirc.messages.processors
 
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.ChannelJoinFailed
+import com.dmdirc.ktirc.events.ChannelJoined
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.params
@@ -17,43 +19,200 @@ internal class JoinProcessorTest {
     }
 
     @Test
-    fun `JoinProcessor raises join event`() {
+    fun `raises join event`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
-        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].target)
+        val event = events[0] as ChannelJoined
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
     }
 
     @Test
-    fun `JoinProcessor does nothing if prefix missing`() {
+    fun `does nothing if prefix missing`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), null, "JOIN", params("#crashandburn")))
         assertEquals(0, events.size)
     }
 
     @Test
-    fun `JoinProcessor adds real name and account from extended join`() {
+    fun `adds real name and account from extended join`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "acidBurn", "Libby")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
-        assertEquals(User("acidburn", "libby", "root.localhost", account = "acidBurn", realName = "Libby"), events[0].user)
-        assertEquals("#crashandburn", events[0].target)
+        val event = events[0] as ChannelJoined
+        assertEquals(User("acidburn", "libby", "root.localhost", account = "acidBurn", realName = "Libby"), event.user)
+        assertEquals("#crashandburn", event.target)
     }
 
     @Test
-    fun `JoinProcessor ignores account if the user is not authed`() {
+    fun `ignores account if the user is not authed`() {
         val events = JoinProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "*", "Libby")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].metadata.time)
-        assertEquals(User("acidburn", "libby", "root.localhost", realName = "Libby"), events[0].user)
-        assertEquals("#crashandburn", events[0].target)
+        val event = events[0] as ChannelJoined
+        assertEquals(User("acidburn", "libby", "root.localhost", realName = "Libby"), event.user)
+        assertEquals("#crashandburn", event.target)
+    }
+
+    @Test
+    fun `raises join failed if too many channels reached`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "405", params("acidBurn", "#thegibson", "You have joined too many channels")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.TooManyChannels, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if hiding not allowed`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "459", params("acidBurn", "#thegibson", "You are not allowed to hide")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NoHiding, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if channel is full`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "471", params("acidBurn", "#thegibson", "Channel is full")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.ChannelFull, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if channel is invite only`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "473", params("acidBurn", "#thegibson", "Channel is invite only")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedInvite, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if banned`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "474", params("acidBurn", "#thegibson", "You are banned")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.Banned, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if channel is keyed`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "475", params("acidBurn", "#thegibson", "Bad key (+k)")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedKey, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if need a registered nickname`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "477", params("acidBurn", "#thegibson", "Must be registered")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedRegisteredNick, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if bad channel name`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "479", params("acidBurn", "#thegibson", "Bad channel name")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.BadChannelName, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if throttled`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "480", params("acidBurn", "#thegibson", "You are throttled")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.Throttled, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if secure only`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "489", params("acidBurn", "#thegibson", "You must use a secure connection")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedTls, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if too many joins`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "500", params("acidBurn", "#thegibson", "Too many joins")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.Throttled, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if admin onnly`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "519", params("acidBurn", "#thegibson", "Admins only")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedAdmin, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if oper only`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "520", params("acidBurn", "#thegibson", "Opers only")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.NeedOper, event.reason)
+    }
+
+    @Test
+    fun `raises join failed if unknown numeric`() {
+        val events = JoinProcessor().process(IrcMessage(emptyMap(), null, "999", params("acidBurn", "#thegibson", "Weird")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].metadata.time)
+        val event = events[0] as ChannelJoinFailed
+        assertEquals("#thegibson", event.target)
+        assertEquals(ChannelJoinFailed.JoinError.Unknown, event.reason)
     }
 
 }