Construct IrcClient with a DSL.

This allows more options to be added nicely in the future,
and hides the implementation details from library users.

CHANGELOG

 vNEXT (in development)
 
  * Fixed experimental API warnings when using IrcClient
+ * IrcClients are now constructed using a DSL
+   * Users of the library no longer need to care about the implementing class
+   * Facilitates adding more options in the future without breaking existing implementations
  * (Internal) Minor version updates for Gradle, Kotlin and JUnit
 
 v0.6.0

README.md

 KtIrc is a Kotlin JVM library for connecting to and interacting with IRC servers.
 It is still in an early stage of development.
 
+## Features
+
+#### Built for Kotlin
+
+KtIrc is written in and designed for use in Kotlin; it uses extension methods,
+DSLs, sealed classes, and so on, to make it much easier to use than an
+equivalent Java library.
+
+#### Coroutine-powered
+
+KtIrc uses co-routines for all of its input/output which lets it deal with
+IRC messages in the background while your app does other things, without
+the overhead of creating a new thread per IRC client.
+
+#### Modern IRC standards
+
+KtIrc supports many IRCv3 features such as SASL authentication, message IDs,
+server timestamps, replies, reactions, account tags, and more. These features
+(where server support is available) make it easier to develop bots and
+clients, and enhance IRC with new user-facing functionality.
+
 ## Setup
 
 KtIrc is published to JCenter, so adding it to a gradle build is as simple as:
 
 ## Usage
 
-The main interface for interacting with KtIrc is the `IrcClientImpl` class. A
-simple bot might look like:
+Clients are created using a DSL and the `IrcClient` function. At a minimum
+you must specify a server and a profile. A simple bot might look like:
 
 ```kotlin
-with(IrcClientImpl(Server("my.server.com", 6667), Profile("nick", "realName", "userName"))) {
-    onEvent { event ->
-        when (event) {
-            is ServerReady -> sendJoin("#ktirc")
-            is MessageReceived ->
-                if (event.message == "!test")
-                    reply(event, "Test successful!")
-        }
+val client = IrcClient {
+    server {
+        host = "my.server.com"
+    } 
+    profile {
+        nickname = "nick"
+        username = "username"
+        realName = "Hi there"
     }
-    connect()
 }
+
+client.onEvent { event ->
+    when (event) {
+        is ServerReady ->
+            client.sendJoin("#ktirc")
+        is ServerDisconnected ->
+            client.connect()
+        is MessageReceived ->
+            if (event.message == "!test")
+                client.reply(event, "Test successful!")
+    }
+}
+
+client.connect()
 ```
 
 ## Known issues / FAQ
 
 This happens when the IRC server requests an optional client certificate (for use
 in SASL auth, usually). At present there is no support for client certificates in
-the networking library used by KtIrc. This is tracked upstream in
-[ktor#641](https://github.com/ktorio/ktor/issues/641). There is no workaround
-other than using an insecure connection.
+the networking library used by KtIrc. This is fixed in the
+[upstream library](https://github.com/ktorio/ktor/issues/641) and will be included
+as soon as snapshot builds are available. There is no workaround other than using
+an insecure connection.
 
 ### KtIrc connects over IPv4 even when host has IPv6
 

src/itest/kotlin/com/dmdirc/ktirc/KtIrcIntegrationTest.kt

 package com.dmdirc.ktirc
 
 import com.dmdirc.irctest.IrcLibraryTests
-import com.dmdirc.ktirc.model.Profile
-import com.dmdirc.ktirc.model.Server
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.TestFactory
 
     @TestFactory
     fun dynamicTests() = IrcLibraryTests().getTests(object : IrcLibraryTests.IrcLibrary {
 
-        private lateinit var ircClient : IrcClientImpl
+        private lateinit var ircClient : IrcClient
 
         override fun connect(nick: String, ident: String, realName: String, password: String?) {
-            ircClient = IrcClientImpl(Server("localhost", 12321, password = password), Profile(nick, ident, realName))
+            ircClient = IrcClient {
+                server {
+                    host = "localhost"
+                    port = 12321
+                    this.password = password
+                }
+                profile {
+                    nickname = nick
+                    username = ident
+                    this.realName = realName
+                }
+            }
             ircClient.connect()
         }
 

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

+package com.dmdirc.ktirc
+
+/**
+ * Dsl marker for [IrcClient] dsl.
+ */
+@DslMarker
+annotation class IrcClientDsl
+
+internal data class IrcClientConfig(val server: ServerConfig, val profile: ProfileConfig, val sasl: SaslConfig?)
+
+/**
+ * Dsl for configuring an IRC Client.
+ *
+ * [server] and [profile] blocks are required. The full range of configuration options are:
+ *
+ * ```
+ * server {
+ *     host = "irc.example.com"     // Required
+ *     port = 6667
+ *     useTls = true
+ *     password = "H4ckTh3Pl4n3t"
+ * }
+ *
+ * profile {
+ *     nickname = "MyBot"           // Required
+ *     username = "bot
+ *     realName = "Botomatic v1.2"
+ * }
+ *
+ * sasl {
+ *     username = "botaccount"
+ *     password = "s3cur3"
+ * }
+ * ```
+ */
+@IrcClientDsl
+class IrcClientConfigBuilder {
+
+    private var server: ServerConfig? = null
+    private var profile: ProfileConfig? = null
+    private var sasl: SaslConfig? = null
+
+    /**
+     * Configures the server that the IrcClient will connect to.
+     *
+     * At a minimum, [ServerConfig.host] must be supplied.
+     */
+    @IrcClientDsl
+    fun server(block: ServerConfig.() -> Unit) {
+        check(server == null) { "server may only be specified once" }
+        server = ServerConfig().apply(block).also { check(it.host.isNotEmpty()) { "server.host must be specified" } }
+    }
+
+    /**
+     * Configures the profile of the IrcClient user.
+     *
+     * At a minimum, [ProfileConfig.nickName] must be supplied.
+     */
+    @IrcClientDsl
+    fun profile(block: ProfileConfig.() -> Unit) {
+        check(profile == null) { "profile may only be specified once" }
+        profile = ProfileConfig().apply(block).also { check(it.nickname.isNotEmpty()) { "profile.nickname must be specified" } }
+    }
+
+    /**
+     * Configures SASL authentication (optional).
+     */
+    @IrcClientDsl
+    fun sasl(block: SaslConfig.() -> Unit) {
+        check(sasl == null) { "sasl may only be specified once" }
+        sasl = SaslConfig().apply(block)
+    }
+
+    internal fun build() =
+            IrcClientConfig(
+                    checkNotNull(server) { "Server must be specified " },
+                    checkNotNull(profile) { "Profile must be specified" },
+                    sasl)
+
+}
+
+/**
+ * Dsl for configuring a server.
+ */
+@IrcClientDsl
+class ServerConfig {
+    /** The hostname (or IP address) of the server to connect to. */
+    var host: String = ""
+    /** The port to connect on. Defaults to 6667. */
+    var port: Int = 6667
+    /** Whether or not to use TLS (an encrypted connection). */
+    var useTls: Boolean = false
+    /** The password required to connect to the server, if any. */
+    var password: String? = null
+}
+
+/**
+ * Dsl for configuring a profile.
+ */
+@IrcClientDsl
+class ProfileConfig {
+    /** The initial nickname to use when connecting. */
+    var nickname: String = ""
+    /** The username (used in place of an ident response) to provide to the server. */
+    var username: String = "KtIrc"
+    /** The "real name" to provide to the server. */
+    var realName: String = "KtIrc User"
+}
+
+/**
+ * Dsl for configuring SASL authentication.
+ */
+@IrcClientDsl
+class SaslConfig {
+    /** The username to provide when authenticating using SASL. */
+    var username: String = ""
+    /** The username to provide when authenticating using SASL. */
+    var password: String = ""
+}

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

 import com.dmdirc.ktirc.io.*
 import com.dmdirc.ktirc.messages.*
 import com.dmdirc.ktirc.model.*
+import com.dmdirc.ktirc.sasl.PlainMechanism
+import com.dmdirc.ktirc.sasl.SaslMechanism
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.dmdirc.ktirc.util.logger
 import io.ktor.util.KtorExperimentalAPI
     val serverState: ServerState
     val channelState: ChannelStateMap
     val userState: UserState
-    val profile: Profile
+    val hasSaslConfig: Boolean
 
     val caseMapping: CaseMapping
         get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
 }
 
 /**
- * Concrete implementation of an [IrcClient].
+ * Constructs a new [IrcClient] using a configuration DSL.
  *
- * @param server The server to connect to.
- * @param profile The user details to use when connecting.
+ * See [IrcClientConfigBuilder] for details of all options
+ */
+@IrcClientDsl
+@Suppress("FunctionName")
+fun IrcClient(block: IrcClientConfigBuilder.() -> Unit): IrcClient =
+        IrcClientImpl(IrcClientConfigBuilder().apply(block).build())
+
+/**
+ * Concrete implementation of an [IrcClient].
  */
 // TODO: How should alternative nicknames work?
 // TODO: Should IRC Client take a pool of servers and rotate through, or make the caller do that?
 // TODO: Should there be a default profile?
-class IrcClientImpl(private val server: Server, override val profile: Profile) : IrcClient, CoroutineScope {
+internal class IrcClientImpl(private val config: IrcClientConfig) : IrcClient, CoroutineScope {
 
     private val log by logger()
 
     @KtorExperimentalAPI
     internal var socketFactory: (CoroutineScope, String, Int, Boolean) -> LineBufferedSocket = ::KtorLineBufferedSocket
 
-    override val serverState = ServerState(profile.initialNick, server.host)
+    override val serverState = ServerState(config.profile.nickname, config.server.host, getSaslMechanisms())
     override val channelState = ChannelStateMap { caseMapping }
     override val userState = UserState { caseMapping }
+    override val hasSaslConfig = config.sasl != null
 
     private val messageHandler = MessageHandler(messageProcessors.toList(), eventHandlers.toMutableList())
 
     private val connecting = AtomicBoolean(false)
 
     override fun send(message: String) {
-        socket?.sendChannel?.offer(message.toByteArray()) ?: log.warning { "No send channel for message: $message"}
+        socket?.sendChannel?.offer(message.toByteArray()) ?: log.warning { "No send channel for message: $message" }
     }
 
     override fun connect() {
         check(!connecting.getAndSet(true))
 
         @Suppress("EXPERIMENTAL_API_USAGE")
-        with(socketFactory(this, server.host, server.port, server.tls)) {
+        with(socketFactory(this, config.server.host, config.server.port, config.server.useTls)) {
             // TODO: Proper error handling - what if connect() fails?
             socket = this
 
                 emitEvent(ServerConnected(currentTimeProvider()))
                 sendCapabilityList()
                 sendPasswordIfPresent()
-                sendNickChange(profile.initialNick)
-                // TODO: Send correct host
-                sendUser(profile.userName, profile.realName)
+                sendNickChange(config.profile.nickname)
+                sendUser(config.profile.username, config.profile.realName)
                 messageHandler.processMessages(this@IrcClientImpl, receiveChannel.map { parser.parse(it) })
                 reset()
                 emitEvent(ServerDisconnected(currentTimeProvider()))
     }
 
     private fun emitEvent(event: IrcEvent) = messageHandler.emitEvent(this, event)
-    private fun sendPasswordIfPresent() = server.password?.let(this::sendPassword)
+    private fun sendPasswordIfPresent() = config.server.password?.let(this::sendPassword)
 
     internal fun reset() {
         serverState.reset()
         connecting.set(false)
     }
 
+    private fun getSaslMechanisms(): Collection<SaslMechanism> {
+        // TODO: Move this somewhere else
+        // TODO: Allow mechanisms to be configured
+        config.sasl?.let {
+            return listOf(PlainMechanism(it))
+        } ?: return emptyList()
+    }
+
 }

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

             log.info { "Acknowledged capabilities: ${capabilities.keys.map { it.name }.toList()}" }
             enabledCapabilities.putAll(capabilities)
 
-            if (client.hasCredentials) {
+            if (client.hasSaslConfig) {
                 client.serverState.sasl.getPreferredSaslMechanism(enabledCapabilities[Capability.SaslAuthentication])?.let { mechanism ->
                     log.info { "Attempting SASL authentication using ${mechanism.ircName}" }
                     client.serverState.sasl.currentMechanism = mechanism
         return if (data.isEmpty()) null else data
     }
 
-    private val IrcClient.hasCredentials
-            get() = profile.authUsername != null && profile.authPassword != null
-
 }

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

-package com.dmdirc.ktirc.model
-
-/**
- * Describes the client's profile information that will be provided to a server.
- *
- * @param initialNick The initial nickname to attempt to use
- * @param realName The real name to provide to the IRC server
- * @param userName The username to use if your system doesn't supply an IDENT response (or the server doesn't ask)
- * @param authUsername The username to authenticate over SASL with (e.g. services account)
- * @param authPassword The password to authenticate the [authUsername] account with
- */
-data class Profile(
-        val initialNick: String,
-        val realName: String,
-        val userName: String,
-        val authUsername: String? = null,
-        val authPassword: String? = null
-)

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

-package com.dmdirc.ktirc.model
-
-/**
- * Describes a server to connect to.
- */
-data class Server(val host: String, val port: Int, val tls: Boolean = false, val password: String? = null)

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

 
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.sasl.SaslMechanism
-import com.dmdirc.ktirc.sasl.supportedSaslMechanisms
 import com.dmdirc.ktirc.util.logger
 import kotlin.reflect.KClass
 
 class ServerState internal constructor(
         private val initialNickname: String,
         private val initialServerName: String,
-        saslMechanisms: Collection<SaslMechanism> = supportedSaslMechanisms) {
+        saslMechanisms: Collection<SaslMechanism>) {
 
     private val log by logger()
 
     /**
      * What we believe our current nickname to be on the server.
      *
-     * Initially this will be the nickname provided in the [Profile]. It will be updated to the actual nickname
+     * Initially this will be the nickname provided in the config. It will be updated to the actual nickname
      * in use when connecting. Once you have received a [com.dmdirc.ktirc.events.ServerWelcome] event you can
      * rely on this value being current.
      * */
     /**
      * The name of the server we are connected to.
      *
-     * Initially this will be the hostname or IP address provided in the [Server]. It will be updated to the server's
+     * Initially this will be the hostname or IP address provided in the config. It will be updated to the server's
      * self-reported hostname when connecting. Once you have received a [com.dmdirc.ktirc.events.ServerWelcome] event
      * you can rely on this value being current.
      */

src/main/kotlin/com/dmdirc/ktirc/sasl/Plain.kt

 package com.dmdirc.ktirc.sasl
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.SaslConfig
 import com.dmdirc.ktirc.messages.sendAuthenticationMessage
 
-internal class PlainMechanism : SaslMechanism {
+internal class PlainMechanism(private val saslConfig: SaslConfig) : SaslMechanism {
 
     override val ircName = "PLAIN"
     override val priority = 0
 
     override fun handleAuthenticationEvent(client: IrcClient, data: ByteArray?) {
-        with (client.profile) {
-            client.sendAuthenticationMessage("$authUsername\u0000$authUsername\u0000$authPassword".toByteArray().toBase64())
+        with (saslConfig) {
+            client.sendAuthenticationMessage("$username\u0000$username\u0000$password".toByteArray().toBase64())
         }
     }
 

src/main/kotlin/com/dmdirc/ktirc/sasl/SaslMechanism.kt

     fun handleAuthenticationEvent(client: IrcClient, data: ByteArray?)
 
 }
-
-internal val supportedSaslMechanisms = listOf<SaslMechanism>(
-        PlainMechanism()
-)

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.Test
+import org.junit.jupiter.api.assertThrows
+
+internal class IrcClientConfigBuilderTest {
+
+    @Test
+    fun `throws if server is defined twice`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                server { host = "1" }
+                server { host = "2" }
+            }
+        }
+    }
+
+    @Test
+    fun `throws if no host is provided`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                server {}
+            }
+        }
+    }
+
+    @Test
+    fun `throws if profile is defined twice`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                profile { nickname = "acidBurn" }
+                profile { nickname = "zeroCool" }
+            }
+        }
+    }
+
+    @Test
+    fun `throws if no nickname is provided`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                profile {}
+            }
+        }
+    }
+
+    @Test
+    fun `throws if sasl is defined twice`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                sasl {}
+                sasl {}
+            }
+        }
+    }
+
+    @Test
+    fun `throws if server is not defined`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                profile { nickname = "acidBurn" }
+            }.build()
+        }
+    }
+
+    @Test
+    fun `throws if profile is not defined`() {
+        assertThrows<IllegalStateException> {
+            IrcClientConfigBuilder().apply {
+                server { host = "thegibson.com" }
+            }.build()
+        }
+    }
+
+    @Test
+    fun `applies server settings`() {
+        val config = IrcClientConfigBuilder().apply {
+            profile { nickname = "acidBurn" }
+            server {
+                host = "thegibson.com"
+                port = 1337
+                password = "h4cktheplan3t"
+                useTls = true
+            }
+        }.build()
+
+        assertEquals("thegibson.com", config.server.host)
+        assertEquals(1337, config.server.port)
+        assertEquals("h4cktheplan3t", config.server.password)
+        assertTrue(config.server.useTls)
+    }
+
+    @Test
+    fun `applies profile settings`() {
+        val config = IrcClientConfigBuilder().apply {
+            profile {
+                nickname = "acidBurn"
+                username = "acidB"
+                realName = "Kate"
+            }
+            server { host = "thegibson.com" }
+        }.build()
+
+        assertEquals("acidBurn", config.profile.nickname)
+        assertEquals("acidB", config.profile.username)
+        assertEquals("Kate", config.profile.realName)
+    }
+
+    @Test
+    fun `applies sasl settings`() {
+        val config = IrcClientConfigBuilder().apply {
+            profile { nickname = "acidBurn" }
+            server { host = "thegibson.com" }
+            sasl {
+                username = "acidBurn"
+                password = "h4ckthepl@net"
+            }
+        }.build()
+
+        assertEquals("acidBurn", config.sasl?.username)
+        assertEquals("h4ckthepl@net", config.sasl?.password)
+    }
+
+}

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

 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
-import com.dmdirc.ktirc.model.*
+import com.dmdirc.ktirc.model.ChannelState
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.nhaarman.mockitokotlin2.*
 import io.ktor.util.KtorExperimentalAPI
 
     private val mockEventHandler = mock<(IrcEvent) -> Unit>()
 
+    private val profileConfig = ProfileConfig().apply {
+        nickname = NICK
+        realName = REAL_NAME
+        username = USER_NAME
+    }
+
+    private val normalConfig = IrcClientConfig(ServerConfig().apply {
+        host = HOST
+        port = PORT
+    }, profileConfig, null)
+
     @BeforeEach
     fun setUp() {
         currentTimeProvider = { TestConstants.time }
 
     @Test
     fun `uses socket factory to create a new socket on connect`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `uses socket factory to create a new tls on connect`() {
-        val client = IrcClientImpl(Server(HOST, PORT, true), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST
+            port = PORT
+            useTls = true
+        }, profileConfig, null))
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `throws if socket already exists`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
     @Test
     fun `emits connection events with local time`() = runBlocking {
         currentTimeProvider = { TestConstants.time }
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.onEvent(mockEventHandler)
         client.connect()
 
     @Test
     fun `sends basic connection strings`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `sends password first, when present`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(IrcClientConfig(ServerConfig().apply {
+            host = HOST
+            port = PORT
+            password = PASSWORD
+        }, profileConfig, null))
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `sends events to provided event handler`() {
-        val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.onEvent(mockEventHandler)
 
 
     @Test
     fun `gets case mapping from server features`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
         assertEquals(CaseMapping.RfcStrict, client.caseMapping)
     }
 
     @Test
     fun `indicates if user is local user or not`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.serverState.localNickname = "[acidBurn]"
 
         assertTrue(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
 
     @Test
     fun `indicates if nickname is local user or not`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.serverState.localNickname = "[acidBurn]"
 
         assertTrue(client.isLocalUser("{acidBurn}"))
 
     @Test
     fun `uses current case mapping to check local user`() {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.serverState.localNickname = "[acidBurn]"
         client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.Ascii
         assertFalse(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
 
     @Test
     fun `sends text to socket`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `disconnects the socket`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `sends messages in order`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         client.connect()
 
 
     @Test
     fun `defaults local nickname to profile`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         assertEquals(NICK, client.serverState.localNickname)
     }
 
     @Test
     fun `defaults server name to host name`() = runBlocking {
-        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        val client = IrcClientImpl(normalConfig)
         assertEquals(HOST, client.serverState.serverName)
     }
 
     @Test
     fun `reset clears all state`() {
-        with (IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))) {
+        with(IrcClientImpl(normalConfig)) {
             userState += User("acidBurn")
             channelState += ChannelState("#thegibson") { CaseMapping.Rfc }
             serverState.serverName = "root.$HOST"

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
 import com.dmdirc.ktirc.model.Capability
-import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.ServerState
 import com.dmdirc.ktirc.sasl.SaslMechanism
 import com.dmdirc.ktirc.sasl.fromBase64
 
     private val handler = CapabilitiesHandler()
     private val serverState = ServerState("", "", listOf(saslMech1, saslMech2, saslMech3))
-    private val nonSaslProfile = Profile("acidBurn", "Kate Libby", "acidB")
-    private val saslProfile = Profile("acidBurn", "Kate Libby", "acidB", "acidB", "HackThePlan3t!")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
-        on { profile } doReturn nonSaslProfile
     }
 
     @Test
 
     @Test
     fun `sends END when capabilities acknowledged and no sasl state`() {
-        whenever(ircClient.profile).thenReturn(saslProfile)
+        whenever(ircClient.hasSaslConfig).thenReturn(true)
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to "123"
 
     @Test
     fun `sends END when capabilities acknowledged and no shared mechanism`() {
-        whenever(ircClient.profile).thenReturn(saslProfile)
+        whenever(ircClient.hasSaslConfig).thenReturn(true)
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                 Capability.SaslAuthentication to "fake1,fake2",
                 Capability.HostsInNamesReply to "123"
 
     @Test
     fun `sends AUTHENTICATE when capabilities acknowledged with shared mechanism`() {
-        whenever(ircClient.profile).thenReturn(saslProfile)
+        whenever(ircClient.hasSaslConfig).thenReturn(true)
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                 Capability.SaslAuthentication to "mech1,fake2",
                 Capability.HostsInNamesReply to "123"
 
     @Test
     fun `sets current SASL mechanism when capabilities acknowledged with shared mechanism`() {
-        whenever(ircClient.profile).thenReturn(saslProfile)
+        whenever(ircClient.hasSaslConfig).thenReturn(true)
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                 Capability.SaslAuthentication to "mech1,fake2",
                 Capability.HostsInNamesReply to "123"
 
     @Test
     fun `updates negotiation state when capabilities acknowledged with shared mechanism`() {
-        whenever(ircClient.profile).thenReturn(saslProfile)
+        whenever(ircClient.hasSaslConfig).thenReturn(true)
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
                 Capability.SaslAuthentication to "mech1,fake2",
                 Capability.HostsInNamesReply to "123"

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

 
     private val handler = ChannelStateHandler()
     private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-    private val serverState = ServerState("", "")
+    private val serverState = ServerState("", "", emptyList())
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
         on { channelState } doReturn channelStateMap

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

 
 internal class EventUtilsTest {
 
-    private val serverState = ServerState("", "")
+    private val serverState = ServerState("", "", emptyList())
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
         on { caseMapping } doReturn CaseMapping.Ascii

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

 
 internal class ServerStateHandlerTest {
 
-    private val serverState = ServerState("", "")
+    private val serverState = ServerState("", "", emptyList())
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
     }

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

 
 internal class UserStateHandlerTest {
 
-    private val serverState = ServerState("", "")
+    private val serverState = ServerState("", "", emptyList())
     private val userState = UserState { CaseMapping.Rfc }
 
     private val ircClient = mock<IrcClient> {

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

 
     @Test
     fun `ServerState should use the initial nickname as local nickname`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         assertEquals("acidBurn", serverState.localNickname)
     }
 
     @Test
     fun `ServerState should use the initial name as server name`() {
-        val serverState = ServerState("", "the.gibson")
+        val serverState = ServerState("", "the.gibson", emptyList())
         assertEquals("the.gibson", serverState.serverName)
     }
 
     @Test
     fun `ServerState should default status to disconnected`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         assertEquals(ServerStatus.Disconnected, serverState.status)
     }
 
     @Test
     fun `returns mode type for known channel mode`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
         assertEquals(ChannelModeType.List, serverState.channelModeType('a'))
         assertEquals(ChannelModeType.SetUnsetParameter, serverState.channelModeType('d'))
 
     @Test
     fun `returns whether a mode is a channel user mode or not`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("oqv", "@~+")
         assertTrue(serverState.isChannelUserMode('o'))
         assertTrue(serverState.isChannelUserMode('q'))
 
     @Test
     fun `returns NoParameter for unknown channel mode`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
         assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('z'))
     }
 
     @Test
     fun `returns NoParameter for channel modes if feature doesn't exist`() {
-        val serverState = ServerState("acidBurn", "")
+        val serverState = ServerState("acidBurn", "", emptyList())
         assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('b'))
     }
 
     @Test
-    fun `reset clears all state`() = with(ServerState("acidBurn", "")) {
+    fun `reset clears all state`() = with(ServerState("acidBurn", "", emptyList())) {
         receivedWelcome = true
         status = ServerStatus.Connecting
         localNickname = "acidBurn3"

src/test/kotlin/com/dmdirc/ktirc/sasl/PlainMechanismTest.kt

 package com.dmdirc.ktirc.sasl
 
 import com.dmdirc.ktirc.IrcClient
-import com.dmdirc.ktirc.model.Profile
+import com.dmdirc.ktirc.SaslConfig
 import com.dmdirc.ktirc.model.ServerState
 import com.nhaarman.mockitokotlin2.argumentCaptor
 import com.nhaarman.mockitokotlin2.doReturn
 internal class PlainMechanismTest {
 
     private val serverState = ServerState("", "", emptyList())
-    private val saslProfile = Profile("acidBurn", "Kate Libby", "acidB", "acidB", "HackThePlan3t!")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
-        on { profile } doReturn saslProfile
     }
 
-    private val mechanism = PlainMechanism()
+    private val mechanism = PlainMechanism(SaslConfig().apply {
+        username = "acidB"
+        password = "HackThePlan3t!"
+    })
 
     @Test
     fun `sends encoded username and password when first message received`() {