Reset state on disconnect

CHANGELOG

     * Added sendTagMessage() to send message tags without any content
     * The reply() utility automatically marks messages as a reply
     * Added react() utility to send a reaction client tag
+ * State is now reset when the client is disconnected, so you can immediately reconnect
  * (Internal) improved how coroutines and channels are used in LineBufferedSocket
 
 v0.5.0

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

 import com.dmdirc.ktirc.messages.*
 import com.dmdirc.ktirc.model.*
 import com.dmdirc.ktirc.util.currentTimeProvider
+import com.dmdirc.ktirc.util.logger
 import io.ktor.util.KtorExperimentalAPI
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.map
 @ExperimentalCoroutinesApi
 class IrcClientImpl(private val server: Server, override val profile: Profile) : IrcClient, CoroutineScope {
 
+    private val log by logger()
+
     override val coroutineContext = GlobalScope.newCoroutineContext(Dispatchers.IO)
 
     internal var socketFactory: (CoroutineScope, String, Int, Boolean) -> LineBufferedSocket = ::KtorLineBufferedSocket
     private val connecting = AtomicBoolean(false)
 
     override fun send(message: String) {
-        socket?.sendChannel?.offer(message.toByteArray())
+        socket?.sendChannel?.offer(message.toByteArray()) ?: log.warning { "No send channel for message: $message"}
     }
 
     override fun connect() {
                 // TODO: Send correct host
                 sendUser(profile.userName, 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)
 
+    internal fun reset() {
+        serverState.reset()
+        channelState.clear()
+        userState.reset()
+        socket = null
+        connecting.set(false)
+    }
+
 }

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

     /** The capabilities that we have agreed to enable. */
     val enabledCapabilities = HashMap<Capability, String>()
 
+    internal fun reset() {
+        negotiationState = CapabilitiesNegotiationState.AWAITING_LIST
+        advertisedCapabilities.clear()
+        enabledCapabilities.clear()
+    }
+
 }
 
 /**

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

      * If [modesDiscovered] is false, this map may be missing modes that the server hasn't told us about.
      */
     var modes = HashMap<Char, String>()
+
+    internal fun reset() {
+        receivingUserList = false
+        modesDiscovered = false
+        users.clear()
+        modes.clear()
+    }
 }
 
 /**

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

     var mechanismState: Any? = null
 
     fun getPreferredSaslMechanism(serverMechanisms: String?): SaslMechanism? {
-        serverMechanisms ?: return null
-        val serverSupported = serverMechanisms.split(',')
+        val serverSupported = serverMechanisms?.split(',') ?: return null
         return mechanisms
                 .filter { it.priority < currentMechanism?.priority ?: Int.MAX_VALUE }
                 .filter { serverMechanisms.isEmpty() || it.ircName in serverSupported }
                 .maxBy { it.priority }
     }
 
+    fun reset() {
+        saslBuffer = ""
+        currentMechanism = null
+    }
+
 }

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

  * Contains the current state of a single IRC server.
  */
 class ServerState internal constructor(
-        initialNickname: String,
-        initialServerName: String,
+        private val initialNickname: String,
+        private val initialServerName: String,
         saslMechanisms: Collection<SaslMechanism> = supportedSaslMechanisms) {
 
     private val log by logger()
         return ChannelModeType.NoParameter
     }
 
+    internal fun reset() {
+        receivedWelcome = false
+        status = ServerStatus.Disconnected
+        localNickname = initialNickname
+        serverName = initialServerName
+        features.clear()
+        capabilities.reset()
+        sasl.reset()
+    }
+
 }
 
 /**
 
     internal fun setAll(featureMap: ServerFeatureMap) = featureMap.features.forEach { feature, value -> features[feature] = value }
     internal fun reset(feature: ServerFeature<*>) = features.put(feature, null)
+    internal fun clear() = features.clear()
+    internal fun isEmpty() = features.isEmpty()
 
 }
 
     object WhoxSupport : ServerFeature<Boolean>("WHOX", Boolean::class, false)
 }
 
-internal val serverFeatures: Map<String, ServerFeature<*>> by lazy {
-    ServerFeature::class.nestedClasses.map { it.objectInstance as ServerFeature<*> }.associateBy { it.name }
-}
-
 /**
  * Enumeration of the possible states of a server.
  */
     /** We are connected and commands can be sent. */
     Ready,
 }
+
+internal val serverFeatures: Map<String, ServerFeature<*>> by lazy {
+    ServerFeature::class.nestedClasses.map { it.objectInstance as ServerFeature<*> }.associateBy { it.name }
+}

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

         }
     }
 
+    internal fun reset() {
+        users.clear()
+    }
+
 }
 
 /**

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

     }
 
     @Test
-    fun `IrcClientImpl uses socket factory to create a new socket on connect`() {
+    fun `uses socket factory to create a new socket on connect`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
     }
 
     @Test
-    fun `IrcClientImpl uses socket factory to create a new tls on connect`() {
+    fun `uses socket factory to create a new tls on connect`() {
         val client = IrcClientImpl(Server(HOST, PORT, true), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
     }
 
     @Test
-    fun `IrcClientImpl throws if socket already exists`() {
+    fun `throws if socket already exists`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
     }
 
     @Test
-    fun `IrcClientImpl emits connection events with local time`() = runBlocking {
+    fun `emits connection events with local time`() = runBlocking {
         currentTimeProvider = { TestConstants.time }
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
     }
 
     @Test
-    fun `IrcClientImpl emits disconnected event with local time when read channel closed`() = runBlocking {
+    fun `emits disconnected event with local time when read channel closed`() = runBlocking {
         currentTimeProvider = { TestConstants.time }
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
-        client.blockUntilConnected()
 
         client.onEvent(mockEventHandler)
         readLineChannel.close()
 
         val captor = argumentCaptor<ServerDisconnected>()
-        verify(mockEventHandler, timeout(500)).invoke(captor.capture())
+        verify(mockEventHandler, timeout(500).atLeast(2)).invoke(captor.capture())
         assertEquals(TestConstants.time, captor.lastValue.time)
     }
 
     @Test
-    fun `IrcClientImpl sends basic connection strings`() = runBlocking {
+    fun `sends basic connection strings`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.blockUntilConnected()
-
         assertEquals("CAP LS 302", String(sendLineChannel.receive()))
         assertEquals("NICK :$NICK", String(sendLineChannel.receive()))
         assertEquals("USER $USER_NAME 0 * :$REAL_NAME", String(sendLineChannel.receive()))
     }
 
     @Test
-    fun `IrcClientImpl sends password first, when present`() = runBlocking {
+    fun `sends password first, when present`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.blockUntilConnected()
-
         assertEquals("CAP LS 302", String(sendLineChannel.receive()))
         assertEquals("PASS :$PASSWORD", String(sendLineChannel.receive()))
     }
 
     @Test
-    fun `IrcClientImpl sends events to provided event handler`() {
+    fun `sends events to provided event handler`() {
         val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.onEvent(mockEventHandler)
     }
 
     @Test
-    fun `IrcClient gets case mapping from server features`() {
+    fun `gets case mapping from server features`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
         assertEquals(CaseMapping.RfcStrict, client.caseMapping)
     }
 
     @Test
-    fun `IrcClient indicates if user is local user or not`() {
+    fun `indicates if user is local user or not`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.serverState.localNickname = "[acidBurn]"
 
     }
 
     @Test
-    fun `IrcClient indicates if nickname is local user or not`() {
+    fun `indicates if nickname is local user or not`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.serverState.localNickname = "[acidBurn]"
 
     }
 
     @Test
-    fun `IrcClient uses current case mapping to check local user`() {
+    fun `uses current case mapping to check local user`() {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.serverState.localNickname = "[acidBurn]"
         client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.Ascii
     }
 
     @Test
-    fun `IrcClientImpl sends text to socket`() = runBlocking {
+    fun `sends text to socket`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.blockUntilConnected()
-
         client.send("testing 123")
 
         assertEquals(true, withTimeoutOrNull(500) {
     }
 
     @Test
-    fun `IrcClientImpl disconnects the socket`() = runBlocking {
+    fun `disconnects the socket`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.blockUntilConnected()
-
         client.disconnect()
 
         verify(mockSocket, timeout(500)).disconnect()
     }
 
     @Test
-    fun `IrcClientImpl sends messages in order`() = runBlocking {
+    fun `sends messages in order`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.blockUntilConnected()
-
         (0..100).forEach { client.send("TEST $it") }
 
         assertEquals(100, withTimeoutOrNull(500) {
     }
 
     @Test
-    fun `IrcClientImpl defaults local nickname to profile`() = runBlocking {
+    fun `defaults local nickname to profile`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         assertEquals(NICK, client.serverState.localNickname)
     }
 
     @Test
-    fun `IrcClientImpl defaults server name to host name`() = runBlocking {
+    fun `defaults server name to host name`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
         assertEquals(HOST, client.serverState.serverName)
     }
 
-    private suspend fun IrcClientImpl.blockUntilConnected() {
-        // Yuck. Maybe connect should be asynchronous?
-        while (serverState.status <= ServerStatus.Connecting) {
-            delay(50)
+    @Test
+    fun `reset clears all state`() {
+        with (IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))) {
+            userState += User("acidBurn")
+            channelState += ChannelState("#thegibson") { CaseMapping.Rfc }
+            serverState.serverName = "root.$HOST"
+            reset()
+
+            assertEquals(0, userState.count())
+            assertEquals(0, channelState.count())
+            assertEquals(HOST, serverState.serverName)
         }
     }
 

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

 package com.dmdirc.ktirc.model
 
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class CapabilitiesStateTest {
 
     @Test
-    fun `defaults negotiation state to awaiting list`() {
-        val capabilitiesState = CapabilitiesState()
+    fun `defaults negotiation state to awaiting list`() = with(CapabilitiesState()) {
+        assertEquals(CapabilitiesNegotiationState.AWAITING_LIST, negotiationState)
+    }
+
+    @Test
+    fun `reset clears all state`() = with(CapabilitiesState()) {
+        advertisedCapabilities[Capability.SaslAuthentication] = "foo"
+        enabledCapabilities[Capability.SaslAuthentication] = "foo"
+        negotiationState = CapabilitiesNegotiationState.FINISHED
+
+        reset()
 
-        assertEquals(CapabilitiesNegotiationState.AWAITING_LIST, capabilitiesState.negotiationState)
+        assertTrue(advertisedCapabilities.isEmpty())
+        assertTrue(enabledCapabilities.isEmpty())
+        assertEquals(CapabilitiesNegotiationState.AWAITING_LIST, negotiationState)
     }
 
-}
+}

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

 package com.dmdirc.ktirc.model
 
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Assertions.assertTrue
+import com.dmdirc.ktirc.io.CaseMapping
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ChannelStateTest {
         assertFalse(ChannelModeType.NoParameter.needsParameterToUnset)
     }
 
+    @Test
+    fun `reset resets all state`() = with(ChannelState("#thegibson") { CaseMapping.Rfc }) {
+        receivingUserList = true
+        modesDiscovered = true
+        modes['a'] = "b"
+        users += ChannelUser("acidBurn")
+
+        reset()
+
+        assertFalse(receivingUserList)
+        assertFalse(modesDiscovered)
+        assertTrue(modes.isEmpty())
+        assertEquals(0, users.count())
+    }
+
 }

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

 import com.dmdirc.ktirc.sasl.SaslMechanism
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class SaslStateTest {
         assertNull(state.mechanismState)
     }
 
+    @Test
+    fun `reset clears all state`() = with(SaslState(mechanisms)) {
+        currentMechanism = mech2
+        mechanismState = "in progress"
+        saslBuffer = "abcdef"
+
+        reset()
+
+        assertNull(currentMechanism)
+        assertNull(mechanismState)
+        assertTrue(saslBuffer.isEmpty())
+    }
+
 }

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

 internal class ServerFeatureMapTest {
 
     @Test
-    fun `ServerFeatureMap should return defaults for unspecified features`() {
+    fun `should return defaults for unspecified features`() {
         val featureMap = ServerFeatureMap()
         assertEquals(200, featureMap[ServerFeature.MaximumChannelNameLength])
     }
 
     @Test
-    fun `ServerFeatureMap should return null for unspecified features with no default`() {
+    fun `should return null for unspecified features with no default`() {
         val featureMap = ServerFeatureMap()
         assertNull(featureMap[ServerFeature.ChannelModes])
     }
 
     @Test
-    fun `ServerFeatureMap should return previously set value for features`() {
+    fun `should return previously set value for features`() {
         val featureMap = ServerFeatureMap()
         featureMap[ServerFeature.MaximumChannels] = 123
         assertEquals(123, featureMap[ServerFeature.MaximumChannels])
     }
 
     @Test
-    fun `ServerFeatureMap should return default set value for features that were reset`() {
+    fun `should return default set value for features that were reset`() {
         val featureMap = ServerFeatureMap()
         featureMap[ServerFeature.MaximumChannels] = 123
         featureMap.reset(ServerFeature.MaximumChannels)
     }
 
     @Test
-    fun `ServerFeatureMap should throw if a feature is set with the wrong type`() {
+    fun `should throw if a feature is set with the wrong type`() {
         val featureMap = ServerFeatureMap()
         assertThrows(IllegalArgumentException::class.java) {
             featureMap[ServerFeature.MaximumChannels] = "123"
     }
 
     @Test
-    fun `ServerFeatureMap sets all features from another map`() {
+    fun `sets all features from another map`() {
         val featureMap1 = ServerFeatureMap()
         val featureMap2 = ServerFeatureMap()
         featureMap2[ServerFeature.WhoxSupport] = true
         assertArrayEquals(arrayOf("abc", "def"), featureMap1[ServerFeature.ChannelModes])
     }
 
-
     @Test
-    fun `ServerFeatureMap resets features reset in another map`() {
+    fun `resets features reset in another map`() {
         val featureMap1 = ServerFeatureMap()
         val featureMap2 = ServerFeatureMap()
         featureMap1[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
 
         assertEquals(CaseMapping.Rfc, featureMap1[ServerFeature.ServerCaseMapping])
     }
+
+    @Test
+    fun `clear removes all features`() {
+        val featureMap = ServerFeatureMap()
+        featureMap[ServerFeature.MaximumChannels] = 123
+        featureMap[ServerFeature.Network] = "testnet"
+        featureMap.clear()
+        assertTrue(featureMap.isEmpty())
+    }
+
+    @Test
+    fun `isEmpty returns true if empty`() {
+        val featureMap = ServerFeatureMap()
+        assertTrue(featureMap.isEmpty())
+        featureMap[ServerFeature.MaximumChannels] = 123
+        assertFalse(featureMap.isEmpty())
+    }
     
-}
+}

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

         assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('b'))
     }
 
+    @Test
+    fun `reset clears all state`() = with(ServerState("acidBurn", "")) {
+        receivedWelcome = true
+        status = ServerStatus.Connecting
+        localNickname = "acidBurn3"
+        serverName = "root.the.gibson"
+        features[ServerFeature.Network] = "gibson"
+        capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "sure"
+        sasl.saslBuffer = "in progress"
+
+        reset()
+
+        assertFalse(receivedWelcome)
+        assertEquals(ServerStatus.Disconnected, status)
+        assertEquals("acidBurn", localNickname)
+        assertEquals("", serverName)
+        assertTrue(features.isEmpty())
+        assertTrue(capabilities.advertisedCapabilities.isEmpty())
+        assertEquals("", sasl.saslBuffer)
+    }
+
 }
 
 internal class ModePrefixMappingTest {

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

     private val userState = UserState { CaseMapping.Rfc }
 
     @Test
-    fun `UserState adds and gets new users`() {
+    fun `adds and gets new users`() {
         userState += User("acidBurn", "libby", "root.localhost")
         val user = userState["acidburn"]
         assertNotNull(user)
     }
 
     @Test
-    fun `UserState removes users`() {
+    fun `removes users`() {
         userState += User("acidBurn", "libby", "root.localhost")
         userState -= User("ACIDBURN")
         assertNull(userState["acidburn"])
     }
 
     @Test
-    fun `UserState removes users by nickname`() {
+    fun `removes users by nickname`() {
         userState += User("acidBurn", "libby", "root.localhost")
         userState -= "ACIDBURN"
         assertNull(userState["acidburn"])
     }
 
     @Test
-    fun `UserState updates existing user with same nickname`() {
+    fun `updates existing user with same nickname`() {
         userState += User("acidBurn", "libby", "root.localhost")
         userState.update(User("acidBurn", realName = "Libby", awayMessage = "Hacking"))
 
     }
 
     @Test
-    fun `UserState updates existing user with new nickname`() {
+    fun `updates existing user with new nickname`() {
         userState += User("acidBurn", "libby", "root.localhost")
         userState.update(User("acidBurn2", realName = "Libby", awayMessage = "Hacking"), "acidBurn")
 
         assertNotNull(userState["zeroCool"])
     }
 
+    @Test
+    fun `reset clears all state`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState += User("zeroCool", "dade", "root.localhost")
+        userState += User("acidBurn2", "libby", "root.localhost")
+
+        userState.reset()
+
+        assertEquals(0, userState.count())
+    }
+
 }