Add behaviour config, and option to send modes on join

CHANGELOG

 
  * Improve DSL for creating an IrcClient to allow parameters to be passed to server and profile
    e.g. IrcClient { server("irc.example.com", 6667) }
+ * Add behaviour options
+   * requestModesOnJoin - automatically sends a MODE request when joining a channel
 
 v0.8.0
 

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

 @DslMarker
 annotation class IrcClientDsl
 
-internal data class IrcClientConfig(val server: ServerConfig, val profile: ProfileConfig, val sasl: SaslConfig?)
+internal data class IrcClientConfig(
+        val server: ServerConfig,
+        val profile: ProfileConfig,
+        val behaviour: ClientBehaviour,
+        val sasl: SaslConfig?)
 
 /**
  * Dsl for configuring an IRC Client.
  *     realName = "Botomatic v1.2"
  * }
  *
+ * behaviour {
+ *     requestModesOnJoin = true
+ * }
+ *
  * sasl {
  *     mechanisms += "PLAIN" // or to set the list from scratch:
  *     mechanisms("PLAIN")
             field = value
         }
 
+    private var behaviour: BehaviourConfig? = null
+        set(value) {
+            check(field == null) { "behaviour may only be specified once" }
+            field = value
+        }
+
     private var sasl: SaslConfig? = null
         set(value) {
             check(field == null) { "sasl may only be specified once" }
         }
     }
 
+    /**
+     * Configures the behaviour of the client (optional).
+     */
+    @IrcClientDsl
+    fun behaviour(block: BehaviourConfig.() -> Unit) {
+        behaviour = BehaviourConfig().apply(block)
+    }
+
     /**
      * Configures SASL authentication (optional).
      */
             IrcClientConfig(
                     checkNotNull(server) { "Server must be specified " },
                     checkNotNull(profile) { "Profile must be specified" },
+                    behaviour ?: BehaviourConfig(),
                     sasl)
 
 }
         }
     }
 }
+
+/**
+ * Dsl for configuring the behaviour of an [IrcClient].
+ */
+@IrcClientDsl
+class BehaviourConfig : ClientBehaviour {
+    override var requestModesOnJoin = false
+}

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

      */
     val userState: UserState
 
+    /**
+     * The configured behaviour of the client.
+     */
+    val behaviour: ClientBehaviour
+
     val caseMapping: CaseMapping
         get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
 
 
 }
 
+/**
+ * Defines the behaviour of an [IrcClient].
+ */
+interface ClientBehaviour {
+
+    /** Whether or not to request channel modes when we join a channel. */
+    val requestModesOnJoin: Boolean
+
+}
+
 /**
  * Constructs a new [IrcClient] using a configuration DSL.
  *

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

     @KtorExperimentalAPI
     internal var socketFactory: (CoroutineScope, String, Int, Boolean) -> LineBufferedSocket = ::KtorLineBufferedSocket
 
+    override var behaviour = config.behaviour
+
     override val serverState = ServerState(config.profile.nickname, config.server.host, config.sasl)
     override val channelState = ChannelStateMap { caseMapping }
     override val userState = UserState { caseMapping }

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

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
+import com.dmdirc.ktirc.messages.sendModeRequest
 import com.dmdirc.ktirc.model.ChannelState
 import com.dmdirc.ktirc.model.ChannelTopic
 import com.dmdirc.ktirc.model.ChannelUser
         client.channelState[event.channel]?.let {
             it.receivingUserList = false
             log.finest { "Finished receiving names in ${event.channel}. Users: ${it.users.toList()}" }
+            if (client.behaviour.requestModesOnJoin && !it.modesDiscovered) {
+                client.sendModeRequest(it.name)
+            }
         }
     }
 

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

 /** Sends a request to join the given channel. */
 fun IrcClient.sendJoin(channel: String) = send("JOIN :$channel")
 
+/** Sends a request to see the modes of a given target. */
+fun IrcClient.sendModeRequest(target: String) = send("MODE :$target")
+
 /** Sends a request to change to the given nickname. */
 fun IrcClient.sendNickChange(nick: String) = send("NICK :$nick")
 

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

 package com.dmdirc.ktirc
 
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
         }
     }
 
+    @Test
+    fun `throws if behaviour is defined twice`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                behaviour {}
+                behaviour {}
+            }
+        }
+    }
+
     @Test
     fun `throws if sasl is defined twice`() {
         assertThrows<IllegalStateException> {
         assertEquals("Kate", config.profile.realName)
     }
 
+    @Test
+    fun `applies behaviour settings`() {
+        val config = IrcClientConfigBuilder().apply {
+            profile { nickname = "acidBurn" }
+            server { host = "thegibson.com" }
+            behaviour {
+                requestModesOnJoin = true
+            }
+        }.build()
+
+        assertTrue(config.behaviour.requestModesOnJoin)
+    }
+
+    @Test
+    fun `falls back to default behaviour settings`() {
+        val config = IrcClientConfigBuilder().apply {
+            profile { nickname = "acidBurn" }
+            server { host = "thegibson.com" }
+        }.build()
+
+        assertFalse(config.behaviour.requestModesOnJoin)
+    }
+
     @Test
     fun `applies sasl settings`() {
         val config = IrcClientConfigBuilder().apply {

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

     private val normalConfig = IrcClientConfig(ServerConfig().apply {
         host = HOST
         port = PORT
-    }, profileConfig, null)
+    }, profileConfig, BehaviourConfig(), null)
 
     @BeforeEach
     fun setUp() {
             host = HOST
             port = PORT
             useTls = true
-        }, profileConfig, null))
+        }, profileConfig, BehaviourConfig(), null))
         client.socketFactory = mockSocketFactory
         client.connect()
 
             host = HOST
             port = PORT
             password = PASSWORD
-        }, profileConfig, null))
+        }, profileConfig, BehaviourConfig(), null))
         client.socketFactory = mockSocketFactory
         client.connect()
 
     }
 
     @Test
+    @ObsoleteCoroutinesApi
     fun `sends messages in order`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
     }
 
     @Test
-    fun `defaults local nickname to profile`() = runBlocking {
+    fun `defaults local nickname to profile`() {
         val client = IrcClientImpl(normalConfig)
         assertEquals(NICK, client.serverState.localNickname)
     }
 
     @Test
-    fun `defaults server name to host name`() = runBlocking {
+    fun `defaults server name to host name`() {
         val client = IrcClientImpl(normalConfig)
         assertEquals(HOST, client.serverState.serverName)
     }
 
+    @Test
+    fun `exposes behaviour config`() {
+        val client = IrcClientImpl(IrcClientConfig(
+                ServerConfig().apply { host = HOST },
+                profileConfig,
+                BehaviourConfig().apply { requestModesOnJoin = true },
+                null))
+
+        assertTrue(client.behaviour.requestModesOnJoin)
+    }
+
     @Test
     fun `reset clears all state`() {
         with(IrcClientImpl(normalConfig)) {

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

 package com.dmdirc.ktirc.handlers
 
+import com.dmdirc.ktirc.BehaviourConfig
 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 com.nhaarman.mockitokotlin2.never
+import com.nhaarman.mockitokotlin2.verify
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
     private val handler = ChannelStateHandler()
     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
     }
         assertEquals("v", channel.users["acidBurn"]?.modes)
     }
 
+    @Test
+    fun `updates receiving user list state`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+
+        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
+
+        assertTrue(channel.receivingUserList)
+
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+
+        assertFalse(channel.receivingUserList)
+    }
+
+    @Test
+    fun `requests modes on end of names if configured and undiscovered`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviour.requestModesOnJoin = true
+
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+
+        verify(ircClient).send("MODE :#thegibson")
+    }
+
+    @Test
+    fun `does not request modes on end of names if already discovered`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviour.requestModesOnJoin = true
+        channel.modesDiscovered = true
+
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+
+        verify(ircClient, never()).send("MODE :#thegibson")
+    }
+
+    @Test
+    fun `does not request modes on end of names if not configured`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+        behaviour.requestModesOnJoin = false
+
+        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+
+        verify(ircClient, never()).send("MODE :#thegibson")
+    }
+
     @Test
     fun `removes state object for local parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }

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

         verify(mockClient).send("JOIN :#TheGibson")
     }
 
+    @Test
+    fun `sendModeRequest sends correct MODE message`() {
+        mockClient.sendModeRequest("#TheGibson")
+        verify(mockClient).send("MODE :#TheGibson")
+    }
+
     @Test
     fun `sendNickChange sends correct NICK message`() {
         mockClient.sendNickChange("AcidBurn")