Server Connecting and Disconnected events

CHANGELOG

  * Added MotdFinished event
  * Added UserAccountChanged event
  * Improved some documentation
+ * Added ServerConnecting and ServerDisconnected events
+ * Server status now starts as Disconnected rather than Connecting
 
 v0.4.0
 

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

                 // TODO: Proper error handling - what if connect() fails?
                 socket = this
 
+                emitEvent(ServerConnecting(currentTimeProvider()))
+
                 connect()
 
                 with(Channel<ByteArray>(Channel.UNLIMITED)) {
                 // TODO: Send correct host
                 sendUser(profile.userName, "localhost", server.host, profile.realName)
                 messageHandler.processMessages(this@IrcClientImpl, readLines(scope).map { parser.parse(it) })
+                emitEvent(ServerDisconnected(currentTimeProvider()))
             }
         }
     }

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

 /** Base class for all events. */
 sealed class IrcEvent(val time: LocalDateTime)
 
+/** Raised when a connection to the server is being established. */
+class ServerConnecting(time: LocalDateTime) : IrcEvent(time)
+
 /** 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 connection to the server has ended. */
+class ServerDisconnected(time: LocalDateTime) : IrcEvent(time)
+
 /** Raised when the server is ready for use. */
 class ServerReady(time: LocalDateTime) : IrcEvent(time)
 

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

 
     override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
+            is ServerConnecting -> client.serverState.status = ServerStatus.Connecting
             is ServerConnected -> client.serverState.status = ServerStatus.Negotiating
+            is ServerDisconnected -> client.serverState.status = ServerStatus.Disconnected
             is ServerWelcome -> handleWelcome(client.serverState, event.server, event.localNick)
             is ServerFeaturesUpdated -> client.serverState.features.setAll(event.serverFeatures)
 

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

     internal var receivedWelcome = false
 
     /** The current status of the server. */
-    var status = ServerStatus.Connecting
+    var status = ServerStatus.Disconnected
         internal set
 
     /**
  * Enumeration of the possible states of a server.
  */
 enum class ServerStatus {
+    /** The server is not connected. */
+    Disconnected,
     /** We are attempting to connect to the server. It is not yet ready for use. */
     Connecting,
     /** We are logging in, dealing with capabilities, etc. The server is not yet ready for use. */

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

 package com.dmdirc.ktirc
 
-import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.events.ServerConnected
-import com.dmdirc.ktirc.events.ServerWelcome
+import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
 import com.dmdirc.ktirc.model.Profile
     }
 
     @Test
-    fun `IrcClientImpl emits connected event with local time`() = runBlocking {
+    fun `IrcClientImpl 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
         client.onEvent(mockEventHandler)
         client.connect()
 
-        val captor = argumentCaptor<ServerConnected>()
-        verify(mockEventHandler, timeout(500)).invoke(captor.capture())
+        val captor = argumentCaptor<IrcEvent>()
+        verify(mockEventHandler, timeout(500).atLeast(2)).invoke(captor.capture())
+
+        assertTrue(captor.firstValue is ServerConnecting)
         assertEquals(TestConstants.time, captor.firstValue.time)
+
+        assertTrue(captor.secondValue is ServerConnected)
+        assertEquals(TestConstants.time, captor.secondValue.time)
+    }
+
+    @Test
+    fun `IrcClientImpl 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())
+        assertEquals(TestConstants.time, captor.lastValue.time)
     }
 
     @Test

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

         assertTrue(serverState.receivedWelcome)
     }
 
+    @Test
+    fun `ServerStateHandler sets state to connecting on event`() = runBlocking {
+        handler.processEvent(ircClient, ServerConnecting(TestConstants.time))
+        assertEquals(ServerStatus.Connecting, serverState.status)
+    }
+
+    @Test
+    fun `ServerStateHandler sets state to disconnected on event`() = runBlocking {
+        serverState.status = ServerStatus.Ready
+        handler.processEvent(ircClient, ServerDisconnected(TestConstants.time))
+        assertEquals(ServerStatus.Disconnected, serverState.status)
+    }
+
     @Test
     fun `ServerStateHandler sets state to negotiating on connected`() = runBlocking {
         handler.processEvent(ircClient, ServerConnected(TestConstants.time))

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

     }
 
     @Test
-    fun `ServerState should default status to connecting`() {
+    fun `ServerState should default status to disconnected`() {
         val serverState = ServerState("acidBurn", "")
-        assertEquals(ServerStatus.Connecting, serverState.status)
+        assertEquals(ServerStatus.Disconnected, serverState.status)
     }
 
 }