Raise ServerConnected event, track status nicely

CHANGELOG

     Instead of: client.send(joinMessage("#channel"))
     Now use: client.sendJoin("#channel")
   * Added reply utility to easily send replies to message events
+  * Server state improvements:
+    * Added status field to ServerState
+    * ServerConnected event is emitted as soon as the socket is connected
 
 v0.2.1
 

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.util.currentTimeProvider
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.map
 import java.util.concurrent.atomic.AtomicBoolean
         check(!connecting.getAndSet(true))
         connectionJob = scope.launch {
             with(socketFactory(server.host, server.port, server.tls)) {
+                // TODO: Proper error handling - what if connect() fails?
                 socket = this
                 connect()
-                sendLine("CAP LS 302")
+                messageHandler.emitEvent(this@IrcClientImpl, ServerConnected(currentTimeProvider()))
+                sendLine("CAP LS 302") // TODO: Stick this in a builder
                 server.password?.let { pass -> sendPassword(pass) }
                 sendNickChange(profile.initialNick)
                 // TODO: Send correct host
                 sendUser(profile.userName, "localhost", server.host, profile.realName)
-                // TODO: This should be elsewhere
                 messageHandler.processMessages(this@IrcClientImpl, readLines(scope).map { parser.parse(it) })
             }
         }

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

 /** Base class for all events. */
 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 initially welcomes us to the IRC network. */
 class ServerWelcome(time: LocalDateTime, val localNick: String) : IrcEvent(time)
 
 /** Raised when the features supported by the server have changed. This may occur numerous times. */
 class ServerFeaturesUpdated(time: LocalDateTime, val serverFeatures: ServerFeatureMap) : IrcEvent(time)
 
-/** Raised when the connection to the server has been established, configuration information has been received, etc. */
-// TODO: Implement
-class ServerConnected(time: LocalDateTime) : IrcEvent(time)
-
 /** Raised whenever a PING is received from the server. */
 class PingReceived(time: LocalDateTime, val nonce: ByteArray) : IrcEvent(time)
 

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

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.EventHandler
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.messages.MessageProcessor
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.channels.consumeEach
 
 internal class MessageHandler(private val processors: List<MessageProcessor>, val handlers: MutableList<EventHandler>) {
 
     private val log by logger()
 
     suspend fun processMessages(ircClient: IrcClient, messages: ReceiveChannel<IrcMessage>) {
-        messages.consumeEach {
-            it.process().forEach { event ->
-                handlers.forEach { handler ->
-                    handler.processEvent(ircClient, event)
-                }
-            }
+        for (message in messages) {
+            message.toEvents().forEach { event -> emitEvent(ircClient, event) }
         }
     }
 
-    private fun IrcMessage.process() = this.getProcessor()?.process(this) ?: emptyList()
+    fun emitEvent(ircClient: IrcClient, ircEvent: IrcEvent) {
+        handlers.forEach { handler ->
+            handler.processEvent(ircClient, ircEvent)
+        }
+    }
+
+    private fun IrcMessage.toEvents() = this.getProcessor()?.process(this) ?: emptyList()
     private fun IrcMessage.getProcessor() = processors.firstOrNull { it.commands.contains(command) } ?: run {
         log.warning { "No processor found for $command" }
         null

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

 package com.dmdirc.ktirc.model
 
+import com.dmdirc.ktirc.util.currentTimeProvider
+import com.dmdirc.ktirc.util.currentTimeZoneProvider
 import java.time.Instant
 import java.time.LocalDateTime
-import java.time.ZoneId
 
 class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
 
-    companion object {
-        internal var currentTimeZoneProvider = { ZoneId.systemDefault() }
-        internal var currentTimeProvider = { LocalDateTime.now(currentTimeZoneProvider()) }
-    }
-
     val time: LocalDateTime = if (MessageTag.ServerTime in tags) {
         LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
     } else {

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

 import com.dmdirc.ktirc.io.CaseMapping
 import kotlin.reflect.KClass
 
-class ServerState(initialNickname: String) {
+/**
+ * Contains the current state of a single IRC server.
+ */
+class ServerState internal constructor(initialNickname: String) {
 
+    /** The current status of the server. */
+    var status = ServerStatus.Connecting
+        internal set
+
+    /** Our present nickname on the server. */
     var localNickname: String = initialNickname
+        internal set
+
+    /** The features that the server has declared it supports (from the 005 header). */
     val features = ServerFeatureMap()
+
+    /** The capabilities we have negotiated with the server (from IRCv3). */
     val capabilities = CapabilitiesState()
 
 }
 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.
+ */
+enum class ServerStatus {
+    /** 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. */
+    Negotiating,
+    /** We are connected and commands can be sent. */
+    Ready,
+}

src/main/kotlin/com/dmdirc/ktirc/util/Time.kt

+package com.dmdirc.ktirc.util
+
+import java.time.LocalDateTime
+import java.time.ZoneId
+
+internal var currentTimeZoneProvider = { ZoneId.systemDefault() }
+internal var currentTimeProvider = { LocalDateTime.now(currentTimeZoneProvider()) }

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.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
-import com.dmdirc.ktirc.model.*
+import com.dmdirc.ktirc.model.Profile
+import com.dmdirc.ktirc.model.Server
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.util.currentTimeProvider
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.channels.Channel
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test
         }
     }
 
+    @Test
+    fun `IrcClientImpl emits connected event 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())
+        assertEquals(TestConstants.time, captor.firstValue.time)
+    }
+
     @Test
     fun `IrcClientImpl sends basic connection strings`() = runBlocking {
         val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))

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

     }
 
     @Test
-    fun `MessageHandler passes message on to correct processor`() = runBlocking {
+    fun `MessageHandler passes message on to correct processor`() = runBlocking<Unit> {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
         val message = IrcMessage(emptyMap(), null, "JOIN", emptyList())
 
         }
 
         verify(joinProcessor).process(message)
-        Unit
     }
 
     @Test
-    fun `MessageHandler reads multiple messages`() = runBlocking {
+    fun `MessageHandler reads multiple messages`() = runBlocking<Unit> {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
         val nickMessage = IrcMessage(emptyMap(), null, "NICK", emptyList())
             verify(joinProcessor).process(joinMessage)
             verify(nickProcessor).process(nickMessage)
         }
-        Unit
     }
 
     @Test
         verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
     }
 
+    @Test
+    fun `MessageHandler emits custom events to all handlers`() = runBlocking {
+        val eventHandler1 = mock<EventHandler>()
+        val eventHandler2 = mock<EventHandler>()
+        val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "abc"))
+
+        verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
+        verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
+    }
+
 }

src/test/kotlin/com/dmdirc/ktirc/messages/JoinProcessorTest.kt

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test

src/test/kotlin/com/dmdirc/ktirc/messages/PartProcessorTest.kt

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test

src/test/kotlin/com/dmdirc/ktirc/messages/PrivmsgProcessorTest.kt

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test

src/test/kotlin/com/dmdirc/ktirc/messages/QuitProcessorTest.kt

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test

src/test/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessorTest.kt

 
 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 
     @BeforeEach
     fun setUp() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
     }
 
     @Test

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

 package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.util.currentTimeProvider
+import com.dmdirc.ktirc.util.currentTimeZoneProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.Test
 
     @Test
     fun `Gets UTC time from ServerTime tag if present`() {
-        IrcMessage.currentTimeZoneProvider = { ZoneId.of("Z") }
+        currentTimeZoneProvider = { ZoneId.of("Z") }
         val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
         assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
     }
 
     @Test
     fun `Converts time in ServerTime tag to local timezone`() {
-        IrcMessage.currentTimeZoneProvider = { ZoneId.of("America/New_York") }
+        currentTimeZoneProvider = { ZoneId.of("America/New_York") }
         val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
         assertEquals(LocalDateTime.parse("1995-09-15T05:00:00"), message.time)
     }
 
     @Test
     fun `Uses current local time if no tag present`() {
-        IrcMessage.currentTimeProvider = { TestConstants.time }
+        currentTimeProvider = { TestConstants.time }
         val message = IrcMessage(emptyMap(), null, "", emptyList())
         assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
     }

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

 internal class ServerStateTest {
 
     @Test
-    fun `IrcServerState should use the initial nickname as local nickname`() {
+    fun `ServerState should use the initial nickname as local nickname`() {
         val serverState = ServerState("acidBurn")
         assertEquals("acidBurn", serverState.localNickname)
     }
 
+    @Test
+    fun `ServerState should default status to connecting`() {
+        val serverState = ServerState("acidBurn")
+        assertEquals(ServerStatus.Connecting, serverState.status)
+    }
+
 }
 
 internal class ModePrefixMappingTest {