Extract server names nicely

CHANGELOG

  * Added sendCtcp and sendAction message builders
  * Fix issue with messages being sent out of order, which sometimes caused problems connecting to passworded servers
  * Added 'network' server feature
+ * Added serverName field to ServerState
 
 v0.3.1
 

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

 
     internal var socketFactory: (String, Int, Boolean) -> LineBufferedSocket = ::KtorLineBufferedSocket
 
-    override val serverState = ServerState(profile.initialNick)
+    override val serverState = ServerState(profile.initialNick, server.host)
     override val channelState = ChannelStateMap { caseMapping }
     override val userState = UserState { caseMapping }
 

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

 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)
+class ServerWelcome(time: LocalDateTime, val server: String, 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)

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

     override fun processEvent(client: IrcClient, event: IrcEvent): List<IrcEvent> {
         when (event) {
             is ServerConnected -> client.serverState.status = ServerStatus.Negotiating
-            is ServerWelcome -> handleWelcome(client.serverState, event.localNick)
+            is ServerWelcome -> handleWelcome(client.serverState, event.server, event.localNick)
             is ServerFeaturesUpdated -> client.serverState.features.setAll(event.serverFeatures)
 
             // Events that won't trigger a server ready event
         return emptyList()
     }
 
-    private fun handleWelcome(serverState: ServerState, localNick: String) {
+    private fun handleWelcome(serverState: ServerState, server: String, localNick: String) {
         serverState.receivedWelcome = true
+        serverState.serverName = server
         serverState.localNickname = localNick
     }
 

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

 
     override val commands = arrayOf("001")
 
-    override fun process(message: IrcMessage) = listOf(ServerWelcome(message.time, String(message.params[0])))
+    override fun process(message: IrcMessage) = listOf(ServerWelcome(message.time, message.serverName(), String(message.params[0])))
 
+    private fun IrcMessage.serverName() = prefix?.let { String(it) } ?: ""
 }

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

 /**
  * Contains the current state of a single IRC server.
  */
-class ServerState internal constructor(initialNickname: String) {
+class ServerState internal constructor(initialNickname: String, initialServerName: String) {
 
     /** Whether we've received the 'Welcome to IRC' (001) message. */
     internal var receivedWelcome = false
     var localNickname: String = initialNickname
         internal set
 
+    /** The server's name, as reported by it. */
+    var serverName: String = initialServerName
+        internal set
+
     /** The features that the server has declared it supports (from the 005 header). */
     val features = ServerFeatureMap()
 

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

         })
     }
 
+    @Test
+    fun `IrcClientImpl 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 {
+        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 (writeChannel == null) {

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

 internal class CapabilitiesHandlerTest {
 
     private val handler = CapabilitiesHandler()
-    private val serverState = ServerState("")
+    private val serverState = ServerState("", "")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
     }

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

 
     private val handler = ChannelStateHandler()
     private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-    private val serverState = ServerState("")
+    private val serverState = ServerState("", "")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
         on { channelState } doReturn channelStateMap

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

 
 internal class EventUtilsTest {
 
-    private val serverState = ServerState("")
+    private val serverState = ServerState("", "")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
         on { caseMapping } doReturn CaseMapping.Ascii

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

 
 internal class ServerStateHandlerTest {
 
-    private val serverState = ServerState("")
+    private val serverState = ServerState("", "")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
     }
 
     @Test
     fun `ServerStateHandler sets local nickname on welcome event`() = runBlocking {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
         assertEquals("acidBurn", serverState.localNickname)
     }
 
+    @Test
+    fun `ServerStateHandler sets server name on welcome event`() = runBlocking {
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        assertEquals("the.gibson", serverState.serverName)
+    }
+
     @Test
     fun `ServerStateHandler sets receivedWelcome on welcome event`() = runBlocking {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
         assertTrue(serverState.receivedWelcome)
     }
 
         ircClient.serverState.status = ServerStatus.Negotiating
 
         listOf(
-                ServerWelcome(TestConstants.time, "acidBurn"),
+                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
                 PingReceived(TestConstants.time, "1234".toByteArray()),
                 ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
                 ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
         ircClient.serverState.status = ServerStatus.Negotiating
 
         listOf(
-                ServerWelcome(TestConstants.time, "acidBurn"),
+                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
                 PingReceived(TestConstants.time, "1234".toByteArray()),
                 ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
                 ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),

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

 
 internal class UserStateHandlerTest {
 
-    private val serverState = ServerState("")
+    private val serverState = ServerState("", "")
     private val userState = UserState { CaseMapping.Rfc }
 
     private val ircClient = mock<IrcClient> {

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

         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
-        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(TestConstants.time), ServerWelcome(TestConstants.time, "abc")))
+        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(TestConstants.time), ServerWelcome(TestConstants.time, "the.gibson", "acidBurn")))
 
         with(Channel<IrcMessage>(1)) {
             send(joinMessage)
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "abc"))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
 
         verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
         verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
         }
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(emptyList(), mutableListOf(eventHandler1, eventHandler2))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "abc"))
+        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
 
         verify(eventHandler1).processEvent(same(ircClient), isA<ServerReady>())
         verify(eventHandler2).processEvent(same(ircClient), isA<ServerReady>())

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

 
     @Test
     fun `WelcomeProcessor returns server welcome event`() {
-        val events = processor.process(IrcMessage(emptyMap(), ":thegibson.com".toByteArray(), "001", listOf(
+        val events = processor.process(IrcMessage(emptyMap(), "thegibson.com".toByteArray(), "001", listOf(
                 "acidBurn".toByteArray(),
                 "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
         assertEquals(1, events.size)
         assertEquals(TestConstants.time, events[0].time)
         assertEquals("acidBurn", events[0].localNick)
+        assertEquals("thegibson.com", events[0].server)
     }
 
 }

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

 
     @Test
     fun `ServerState should use the initial nickname as local nickname`() {
-        val serverState = ServerState("acidBurn")
+        val serverState = ServerState("acidBurn", "")
         assertEquals("acidBurn", serverState.localNickname)
     }
 
+    @Test
+    fun `ServerState should use the initial name as server name`() {
+        val serverState = ServerState("", "the.gibson")
+        assertEquals("the.gibson", serverState.serverName)
+    }
+
     @Test
     fun `ServerState should default status to connecting`() {
-        val serverState = ServerState("acidBurn")
+        val serverState = ServerState("acidBurn", "")
         assertEquals(ServerStatus.Connecting, serverState.status)
     }