Better server state handling

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

CHANGELOG

   * 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

             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) {
                     }
                 }
             }
+
+            library.terminate()
         }
     }
 

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

 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 {
         }
 
         override fun terminate() {
-            ircClient.disconnect()
+            runBlocking {
+                delay(100)
+                ircClient.disconnect()
+                ircClient.join()
+            }
         }
 
     })

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

     private var connectionJob: Job? = null
 
     override fun send(message: String) {
+        // TODO: What happens if sending fails?
         scope.launch {
             socket?.sendLine(message)
         }
                 // 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)
 
     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

 
     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

 
     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)
             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

 @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

 /** 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

 
 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

 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

 
 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

 
     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

 
 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

  */
 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
     Negotiating,
     /** We are connected and commands can be sent. */
     Ready,
-}
+}

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

 
 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 {
         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

 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
     }
 
     @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))
     }
 
     @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))
         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>())
+    }
+
 }