Better server state handling

Expose status (connecting, negotiating, ready)
Fire ServerReady and ServerConnected events

CHANGELOG

@@ -7,6 +7,8 @@ vNEXT (in development)
   * Server state improvements:
     * Added status field to ServerState
     * ServerConnected event is emitted as soon as the socket is connected
+    * ServerReady event is emitted after logging in, negotiating, etc
+  * (Internal) Event handlers can now return more events to emit
 
 v0.2.1
 

src/itest/kotlin/com/dmdirc/irctest/TestRunner.kt

@@ -30,6 +30,7 @@ class IrcLibraryTests {
             val clientInput = BufferedReader(InputStreamReader(clientSocket.getInputStream()))
             val clientOutput = BufferedWriter(OutputStreamWriter(clientSocket.getOutputStream()))
             for (step in test.steps) {
+                println(step)
                 when (step) {
                     is SimpleExpectStep -> {
                         while (true) {
@@ -49,6 +50,8 @@ class IrcLibraryTests {
                     }
                 }
             }
+
+            library.terminate()
         }
     }
 

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

@@ -3,6 +3,8 @@ package com.dmdirc.ktirc
 import com.dmdirc.irctest.IrcLibraryTests
 import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.Server
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.TestFactory
 
 class KtIrcIntegrationTest {
@@ -18,7 +20,11 @@ class KtIrcIntegrationTest {
         }
 
         override fun terminate() {
-            ircClient.disconnect()
+            runBlocking {
+                delay(100)
+                ircClient.disconnect()
+                ircClient.join()
+            }
         }
 
     })

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

@@ -100,6 +100,7 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
     private var connectionJob: Job? = null
 
     override fun send(message: String) {
+        // TODO: What happens if sending fails?
         scope.launch {
             socket?.sendLine(message)
         }
@@ -112,9 +113,9 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
                 // TODO: Proper error handling - what if connect() fails?
                 socket = this
                 connect()
-                messageHandler.emitEvent(this@IrcClientImpl, ServerConnected(currentTimeProvider()))
-                sendLine("CAP LS 302") // TODO: Stick this in a builder
-                server.password?.let { pass -> sendPassword(pass) }
+                emitEvent(ServerConnected(currentTimeProvider()))
+                sendCapabilityList()
+                sendPasswordIfPresent()
                 sendNickChange(profile.initialNick)
                 // TODO: Send correct host
                 sendUser(profile.userName, "localhost", server.host, profile.realName)
@@ -133,11 +134,16 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
 
     override fun onEvent(handler: (IrcEvent) -> Unit) {
         messageHandler.handlers.add(object : EventHandler {
-            override fun processEvent(client: IrcClient, event: IrcEvent) {
+            override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
                 handler(event)
+                return emptyList()
             }
         })
     }
+
+    private fun emitEvent(event: IrcEvent) = messageHandler.emitEvent(this, event)
+    private fun sendPasswordIfPresent() = server.password?.let(this::sendPassword)
+
 }
 
 internal fun main() {

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

@@ -12,12 +12,13 @@ internal class CapabilitiesHandler : EventHandler {
 
     private val log by logger()
 
-    override fun processEvent(client: IrcClient, event: IrcEvent) {
+    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
             is ServerCapabilitiesReceived -> handleCapabilitiesReceived(client.serverState.capabilities, event.capabilities)
             is ServerCapabilitiesFinished -> handleCapabilitiesFinished(client)
             is ServerCapabilitiesAcknowledged -> handleCapabilitiesAcknowledged(client, event.capabilities)
         }
+        return emptyList()
     }
 
     private fun handleCapabilitiesReceived(state: CapabilitiesState, capabilities: Map<Capability, String>) {

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

@@ -9,7 +9,7 @@ internal class ChannelStateHandler : EventHandler {
 
     private val log by logger()
 
-    override fun processEvent(client: IrcClient, event: IrcEvent) {
+    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
             is ChannelJoined -> handleJoin(client, event)
             is ChannelParted -> handlePart(client, event)
@@ -17,6 +17,7 @@ internal class ChannelStateHandler : EventHandler {
             is ChannelNamesFinished -> handleNamesFinished(client, event)
             is UserQuit -> handleQuit(client, event)
         }
+        return emptyList()
     }
 
     private fun handleJoin(client: IrcClient, event: ChannelJoined) {

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

@@ -5,7 +5,7 @@ import com.dmdirc.ktirc.IrcClient
 @FunctionalInterface
 internal interface EventHandler {
 
-    fun processEvent(client: IrcClient, event: IrcEvent)
+    fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent>
 
 }
 

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

@@ -11,6 +11,9 @@ sealed class IrcEvent(val time: LocalDateTime)
 /** Raised when the connection to the server has been established. The server will not be ready for use yet. */
 class ServerConnected(time: LocalDateTime) : IrcEvent(time)
 
+/** Raised when the server is ready for use. */
+class ServerReady(time: LocalDateTime) : IrcEvent(time)
+
 /** Raised when the server initially welcomes us to the IRC network. */
 class ServerWelcome(time: LocalDateTime, val localNick: String) : IrcEvent(time)
 

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

@@ -5,10 +5,11 @@ import com.dmdirc.ktirc.messages.sendPong
 
 internal class PingHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent) {
+    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
             is PingReceived -> client.sendPong(event.nonce)
         }
+        return emptyList()
     }
 
 }

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

@@ -1,14 +1,40 @@
 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.ServerStatus
+import java.time.LocalDateTime
 
 internal class ServerStateHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent) {
+    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
-            is ServerWelcome -> client.serverState.localNickname = event.localNick
+            is ServerConnected -> client.serverState.status = ServerStatus.Negotiating
+            is ServerWelcome -> handleWelcome(client.serverState, event.localNick)
             is ServerFeaturesUpdated -> client.serverState.features.setAll(event.serverFeatures)
+
+            // Events that won't trigger a server ready event
+            is PingReceived -> Unit
+            is ServerCapabilitiesReceived -> Unit
+            is ServerCapabilitiesAcknowledged -> Unit
+            is ServerCapabilitiesFinished -> Unit
+
+            else -> return checkReadyState(client, event.time)
+        }
+        return emptyList()
+    }
+
+    private fun handleWelcome(serverState: ServerState, localNick: String) {
+        serverState.receivedWelcome = true
+        serverState.localNickname = localNick
+    }
+
+    private fun checkReadyState(client: IrcClient, time: LocalDateTime): List<IrcEvent> {
+        if (client.serverState.receivedWelcome && client.serverState.status == ServerStatus.Negotiating) {
+            client.serverState.status = ServerStatus.Ready
+            return listOf(ServerReady(time))
         }
+        return emptyList()
     }
 
 }

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

@@ -5,13 +5,14 @@ import com.dmdirc.ktirc.model.UserState
 
 internal class UserStateHandler : EventHandler {
 
-    override fun processEvent(client: IrcClient, event: IrcEvent) {
+    override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
             is ChannelJoined -> handleJoin(client.userState, event)
             is ChannelParted -> handlePart(client, event)
             is ChannelNamesReceived  -> handleNamesReceived(client, event)
             is UserQuit -> handleQuit(client.userState, event)
         }
+        return emptyList()
     }
 
     private fun handleJoin(state: UserState, event: ChannelJoined) {

src/main/kotlin/com/dmdirc/ktirc/io/MessageHandler.kt

@@ -20,7 +20,9 @@ internal class MessageHandler(private val processors: List<MessageProcessor>, va
 
     fun emitEvent(ircClient: IrcClient, ircEvent: IrcEvent) {
         handlers.forEach { handler ->
-            handler.processEvent(ircClient, ircEvent)
+            handler.processEvent(ircClient, ircEvent).forEach {
+                emitEvent(ircClient, it)
+            }
         }
     }
 

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

@@ -2,6 +2,8 @@ package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.IrcClient
 
+/** Sends a message to ask the server to list capabilities. */
+internal fun IrcClient.sendCapabilityList() = send("CAP LS 302")
 /** Sends a message indicating the end of capability negotiation. */
 internal fun IrcClient.sendCapabilityEnd() = send("CAP END")
 /** Sends a message requesting the specified caps are enabled. */

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

@@ -8,6 +8,9 @@ import kotlin.reflect.KClass
  */
 class ServerState internal constructor(initialNickname: String) {
 
+    /** Whether we've received the 'Welcome to IRC' (001) message. */
+    internal var receivedWelcome = false
+
     /** The current status of the server. */
     var status = ServerStatus.Connecting
         internal set
@@ -72,4 +75,4 @@ enum class ServerStatus {
     Negotiating,
     /** We are connected and commands can be sent. */
     Ready,
-}
+}

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

@@ -2,13 +2,12 @@ package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
-import com.dmdirc.ktirc.model.ServerFeature
-import com.dmdirc.ktirc.model.ServerFeatureMap
-import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class ServerStateHandlerTest {
@@ -26,6 +25,56 @@ internal class ServerStateHandlerTest {
         assertEquals("acidBurn", serverState.localNickname)
     }
 
+    @Test
+    fun `ServerStateHandler sets receivedWelcome on welcome event`() = runBlocking {
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "acidBurn"))
+        assertTrue(serverState.receivedWelcome)
+    }
+
+    @Test
+    fun `ServerStateHandler sets state to negotiating on connected`() = runBlocking {
+        handler.processEvent(ircClient, ServerConnected(TestConstants.time))
+        assertEquals(ServerStatus.Negotiating, serverState.status)
+    }
+
+    @Test
+    fun `ServerStateHandler sets server state to ready on receiving post-005 line`() = runBlocking {
+        ircClient.serverState.status = ServerStatus.Negotiating
+
+        listOf(
+                ServerWelcome(TestConstants.time, "acidBurn"),
+                PingReceived(TestConstants.time, "1234".toByteArray()),
+                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
+                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
+                ServerCapabilitiesFinished(TestConstants.time),
+                MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!")
+        ).forEach {
+            assertEquals(ServerStatus.Negotiating, serverState.status)
+            handler.processEvent(ircClient, it)
+        }
+
+        assertEquals(ServerStatus.Ready, serverState.status)
+    }
+
+    @Test
+    fun `ServerStateHandler emits event on receiving post-005 line`() = runBlocking {
+        ircClient.serverState.status = ServerStatus.Negotiating
+
+        listOf(
+                ServerWelcome(TestConstants.time, "acidBurn"),
+                PingReceived(TestConstants.time, "1234".toByteArray()),
+                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
+                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
+                ServerCapabilitiesFinished(TestConstants.time)
+        ).forEach {
+            assertTrue(handler.processEvent(ircClient, it).isEmpty())
+        }
+
+        val events = handler.processEvent(ircClient, MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!"))
+        assertEquals(1, events.size)
+        assertTrue(events[0] is ServerReady)
+    }
+
     @Test
     fun `ServerStateHandler updates features on features event`() = runBlocking {
         val features = ServerFeatureMap()

src/test/kotlin/com/dmdirc/ktirc/io/MessageHandlerTest.kt

@@ -4,6 +4,7 @@ import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.events.ServerConnected
+import com.dmdirc.ktirc.events.ServerReady
 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.model.IrcMessage
@@ -60,7 +61,7 @@ internal class MessageHandlerTest {
     }
 
     @Test
-    fun `MessageHandler invokes all event handler with all returned events`() = runBlocking {
+    fun `MessageHandler invokes all event handler with all returned events`() = runBlocking<Unit> {
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
@@ -80,7 +81,7 @@ internal class MessageHandlerTest {
     }
 
     @Test
-    fun `MessageHandler emits custom events to all handlers`() = runBlocking {
+    fun `MessageHandler emits custom events to all handlers`() = runBlocking<Unit> {
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
@@ -90,4 +91,17 @@ internal class MessageHandlerTest {
         verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
     }
 
+    @Test
+    fun `MessageHandler emits events returned from handler`() = runBlocking<Unit> {
+        val eventHandler1 = mock<EventHandler> {
+            on { processEvent(any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(TestConstants.time))
+        }
+        val eventHandler2 = mock<EventHandler>()
+        val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "abc"))
+
+        verify(eventHandler1).processEvent(same(ircClient), isA<ServerReady>())
+        verify(eventHandler2).processEvent(same(ircClient), isA<ServerReady>())
+    }
+
 }