Add always echo messages behaviour

CHANGELOG

    * send(command, arguments) is available if no tags are to be sent
    * the line is built automatically (with spaces/' :' added appropriately)
    * send(line) is deprecated and will be removed after v1.0.0
+ * Add 'alwaysEchoMessages' behaviour that makes it easier to deal with servers
+   that don't support the echo message capability
  * (Internal) Added annotation to track removal of deprecated methods
 
 v0.9.0

build.gradle.kts

     testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0")
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.4.0")
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.4.0")
+    testImplementation("io.mockk:mockk:1.9")
     testRuntime("org.junit.jupiter:junit-jupiter-engine:5.4.0")
 }
 

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

  *
  * behaviour {
  *     requestModesOnJoin = true
+ *     alwaysEchoMessages = true
  * }
  *
  * sasl {
 @IrcClientDsl
 class BehaviourConfig : ClientBehaviour {
     override var requestModesOnJoin = false
+    override var alwaysEchoMessages = false
 }

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

     /** Whether or not to request channel modes when we join a channel. */
     val requestModesOnJoin: Boolean
 
+    /**
+     * If enabled, all messages (`PRIVMSG`s) sent by the client will always be "echoed" back as a MessageReceived
+     * event.
+     *
+     * This makes the behaviour consistent across ircds that support the echo-message capability and those that
+     * don't. If disabled, messages will only be echoed back when the server supports the capability.
+     */
+    val alwaysEchoMessages: Boolean
+
 }
 
 /**

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

     }
 
     override fun send(tags: Map<MessageTag, String>, command: String, vararg arguments: String) {
+        maybeEchoMessage(command, arguments)
         socket?.sendChannel?.offer(messageBuilder.build(tags, command, arguments))
                 ?: log.warning { "No send channel for command: $command" }
     }
 
     // TODO: This will become sendAsync and return a Deferred<IrcEvent>
     internal fun sendWithLabel(tags: Map<MessageTag, String>, command: String, vararg arguments: String) {
+        maybeEchoMessage(command, arguments)
         val tagseToSend = if (Capability.LabeledResponse in serverState.capabilities.enabledCapabilities) {
             tags + (MessageTag.Label to generateLabel(this))
         } else {
     private fun emitEvent(event: IrcEvent) = messageHandler.handleEvent(this, event)
     private fun sendPasswordIfPresent() = config.server.password?.let(this::sendPassword)
 
+    private fun maybeEchoMessage(command: String, arguments: Array<out String>) {
+        // TODO: Is this the best place to do it? It'd be nicer to actually build the message and
+        //       reflect the raw line back through all the processors etc.
+        if (command == "PRIVMSG" && behaviour.alwaysEchoMessages && !serverState.capabilities.enabledCapabilities.contains(Capability.EchoMessages)) {
+            emitEvent(MessageReceived(
+                    EventMetadata(currentTimeProvider()),
+                    userState[serverState.localNickname]?.details ?: User(serverState.localNickname),
+                    arguments[0],
+                    arguments[1]
+            ))
+        }
+    }
+
     internal fun reset() {
         serverState.reset()
         channelState.clear()

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

 import com.dmdirc.ktirc.util.generateLabel
 import com.nhaarman.mockitokotlin2.*
 import io.ktor.util.KtorExperimentalAPI
+import io.mockk.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.filter
         username = USER_NAME
     }
 
-    private val normalConfig = IrcClientConfig(ServerConfig().apply {
+    private val serverConfig = ServerConfig().apply {
         host = HOST
         port = PORT
-    }, profileConfig, BehaviourConfig(), null)
+    }
+
+    private val normalConfig = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig(), null)
 
     @BeforeEach
     fun setUp() {
     }
 
     @Test
+    @SuppressWarnings("deprecation")
     fun `sends text to socket`() = runBlocking {
         val client = IrcClientImpl(normalConfig)
         client.socketFactory = mockSocketFactory
         assertLineReceived("testing 123 456")
     }
 
+    @Test
+    fun `echoes message event when behaviour is set and cap is unsupported`() = runBlocking {
+        val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = true }, null)
+        val client = IrcClientImpl(config)
+        client.socketFactory = mockSocketFactory
+
+        val slot = slot<MessageReceived>()
+        val mockkEventHandler = mockk<(IrcEvent) -> Unit>(relaxed = true)
+        every { mockkEventHandler(capture(slot)) } just Runs
+
+        client.onEvent(mockkEventHandler)
+        client.connect()
+
+        client.send("PRIVMSG", "#thegibson", "Mess with the best, die like the rest")
+
+        assertTrue(slot.isCaptured)
+        val event = slot.captured
+        assertEquals("#thegibson", event.target)
+        assertEquals("Mess with the best, die like the rest", event.message)
+        assertEquals(NICK, event.user.nickname)
+        assertEquals(TestConstants.time, event.metadata.time)
+    }
+
+    @Test
+    fun `does not echo message event when behaviour is set and cap is supported`() = runBlocking {
+        val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = true }, null)
+        val client = IrcClientImpl(config)
+        client.socketFactory = mockSocketFactory
+        client.serverState.capabilities.enabledCapabilities[Capability.EchoMessages] = ""
+        client.connect()
+
+        client.onEvent(mockEventHandler)
+        client.send("PRIVMSG", "#thegibson", "Mess with the best, die like the rest")
+
+        verify(mockEventHandler, never()).invoke(isA<MessageReceived>())
+    }
+
+    @Test
+    fun `does not echo message event when behaviour is unset`() = runBlocking {
+        val config = IrcClientConfig(serverConfig, profileConfig, BehaviourConfig().apply { alwaysEchoMessages = false }, null)
+        val client = IrcClientImpl(config)
+        client.socketFactory = mockSocketFactory
+        client.connect()
+
+        client.onEvent(mockEventHandler)
+        client.send("PRIVMSG", "#thegibson", "Mess with the best, die like the rest")
+
+        verify(mockEventHandler, never()).invoke(isA<MessageReceived>())
+    }
+
     @Test
     fun `sends structured text to socket with tags`() = runBlocking {
         val client = IrcClientImpl(normalConfig)