Add initial integration tests/framework

build.gradle.kts

@@ -4,6 +4,11 @@ plugins {
     kotlin("jvm") version "1.3.0-rc-190"
 }
 
+configurations {
+    create("itestImplementation") { extendsFrom(getByName("testImplementation")) }
+    create("itestRuntime") { extendsFrom(getByName("testRuntime")) }
+}
+
 repositories {
     jcenter()
     mavenCentral()
@@ -16,15 +21,29 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.2-eap13")
     implementation("io.ktor:ktor-network:1.0.0-beta-1")
 
-    testCompile("org.junit.jupiter:junit-jupiter-api:5.3.1")
-    testCompile("org.junit.jupiter:junit-jupiter-params:5.3.1")
-    testRuntime("org.junit.jupiter:junit-jupiter-engine:5.3.1")
     testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.0.0-RC3")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.3.1")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.3.1")
+    testRuntime("org.junit.jupiter:junit-jupiter-engine:5.3.1")
 }
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
     targetCompatibility = JavaVersion.VERSION_1_8
+
+    sourceSets {
+        create("itest") {
+            compileClasspath += getByName("main").output
+            runtimeClasspath += getByName("main").output
+            java.srcDirs("src/itest/kotlin")
+        }
+    }
+}
+
+tasks.create<Test>("itest") {
+    group = "verification"
+    testClassesDirs = java.sourceSets.getByName("itest").output.classesDirs
+    classpath = java.sourceSets.getByName("itest").runtimeClasspath
 }
 
 tasks.withType<KotlinCompile> {

src/itest/kotlin/com/dmdirc/irctest/Dsl.kt

@@ -0,0 +1,79 @@
+package com.dmdirc.irctest
+
+@DslMarker
+annotation class TestDslMarker
+
+fun testCase(name: String, data: TestCaseContext.() -> Unit) = TestCaseContext(name).apply(data)
+
+@TestDslMarker
+class TestCaseContext(val name: String) {
+
+    internal val config = ConfigContext()
+    internal val steps = StepsContext()
+
+    fun config(data: ConfigContext.() -> Unit) = config.data()
+    fun steps(data: StepsContext.() -> Unit) = steps.data()
+
+}
+
+@TestDslMarker
+class ConfigContext {
+
+    var nick = "nick"
+    var user = "ident"
+    var realName = "some name"
+    var password: String? = null
+
+}
+
+@TestDslMarker
+class StepsContext {
+
+    private val steps = mutableListOf<Step>()
+
+    fun send(line: String) { steps += SendStep(line) }
+    fun expect(line: String) { steps += SimpleExpectStep(line) }
+
+    fun expect(data: ExpectContext.() -> Unit) {
+        ExpectContext().data()
+    }
+
+    operator fun iterator() = steps.iterator()
+
+}
+
+open class Step
+class SendStep(val line: String) : Step()
+class SimpleExpectStep(val line: String): Step()
+
+@TestDslMarker
+class ExpectContext {
+
+    private var commandMatcher: ((String) -> Boolean)? = null
+    private var paramMatchers = HashMap<Int, (String) -> Boolean>()
+
+    val command: String = "COMMAND"
+    val parameters = ParameterProvider()
+
+    infix fun String.toMatch(regex: String) {
+        val matcher = { it: String -> it.matches(regex.toRegex()) }
+        when (this) {
+            command -> commandMatcher = matcher
+            else -> paramMatchers[this.toInt()] = matcher
+        }
+    }
+
+    infix fun String.toEqual(value: String) {
+        val matcher = { it: String -> it == value }
+        when (this) {
+            command -> commandMatcher = matcher
+            else -> paramMatchers[this.toInt()] = matcher
+        }
+    }
+}
+
+class ParameterProvider {
+    val count = "count"
+    operator fun get(index: Int) = "$index"
+}
+

src/itest/kotlin/com/dmdirc/irctest/TestRunner.kt

@@ -0,0 +1,55 @@
+package com.dmdirc.irctest
+
+import com.dmdirc.irctest.cases.testCases
+import org.junit.jupiter.api.DynamicTest
+import java.io.BufferedReader
+import java.io.BufferedWriter
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+import java.net.ServerSocket
+
+class IrcLibraryTests {
+
+    interface IrcLibrary {
+        fun connect(nick: String, ident: String, realName: String, password: String?)
+        fun terminate()
+    }
+
+    fun getTests(library: IrcLibrary, names: List<TestCaseContext> = testCases) = names.map { getTest(library, it) }
+
+    fun getTest(library: IrcLibrary, test: TestCaseContext): DynamicTest = DynamicTest.dynamicTest(test.name) {
+        ServerSocket(12321).use { serverSocket ->
+            library.connect(
+                    test.config.nick,
+                    test.config.user,
+                    test.config.realName,
+                    test.config.password
+            )
+
+            val clientSocket = serverSocket.accept()
+            val clientInput = BufferedReader(InputStreamReader(clientSocket.getInputStream()))
+            val clientOutput = BufferedWriter(OutputStreamWriter(clientSocket.getOutputStream()))
+            for (step in test.steps) {
+                when (step) {
+                    is SimpleExpectStep -> {
+                        while (true) {
+                            val read = clientInput.readLine()
+                            if (read == step.line) {
+                                println("     MATCH: $read")
+                                break
+                            } else {
+                                println("UNEXPECTED: $read")
+                            }
+                        }
+                    }
+                    is SendStep -> {
+                        println("      SENT: ${step.line}")
+                        clientOutput.write("${step.line}\r\n")
+                        clientOutput.flush()
+                    }
+                }
+            }
+        }
+    }
+
+}

src/itest/kotlin/com/dmdirc/irctest/cases/TestCases.kt

@@ -0,0 +1,7 @@
+package com.dmdirc.irctest.cases
+
+val testCases = listOf(
+        com.dmdirc.irctest.cases.connection.password,
+        com.dmdirc.irctest.cases.connection.capabilities.v32.emptyList,
+        com.dmdirc.irctest.cases.connection.capabilities.v32.serverTime
+)

src/itest/kotlin/com/dmdirc/irctest/cases/connection/Password.kt

@@ -0,0 +1,14 @@
+package com.dmdirc.irctest.cases.connection
+
+import com.dmdirc.irctest.testCase
+
+val password = testCase("connection.password") {
+    config {
+        password = "This is a test"
+        nick = "test"
+    }
+
+    steps {
+        expect("PASS :This is a test")
+    }
+}

src/itest/kotlin/com/dmdirc/irctest/cases/connection/capabilities/v32/EmptyList.kt

@@ -0,0 +1,11 @@
+package com.dmdirc.irctest.cases.connection.capabilities.v32
+
+import com.dmdirc.irctest.testCase
+
+val emptyList = testCase("connection.capabilities.302.empty-list") {
+    steps {
+        expect("CAP LS 302")
+        send("CAP * LS :")
+        expect("CAP END")
+    }
+}

src/itest/kotlin/com/dmdirc/irctest/cases/connection/capabilities/v32/ServerTime.kt

@@ -0,0 +1,13 @@
+package com.dmdirc.irctest.cases.connection.capabilities.v32
+
+import com.dmdirc.irctest.testCase
+
+val serverTime = testCase("connection.capabilities.302.server-time") {
+    steps {
+        expect("CAP LS 302")
+        send("CAP * LS :server-time")
+        expect("CAP REQ :server-time")
+        send("CAP * ACK :server-time")
+        expect("CAP END")
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.dmdirc.ktirc
+
+import com.dmdirc.irctest.IrcLibraryTests
+import com.dmdirc.ktirc.model.Profile
+import com.dmdirc.ktirc.model.Server
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import org.junit.jupiter.api.TestFactory
+
+class KtIrcIntegrationTest {
+
+    @TestFactory
+    fun dynamicTests() = IrcLibraryTests().getTests(object : IrcLibraryTests.IrcLibrary {
+
+        private lateinit var ircClient : IrcClientImpl
+
+        override fun connect(nick: String, ident: String, realName: String, password: String?) {
+            ircClient = IrcClientImpl(Server("localhost", 12321, password = password), Profile(nick, ident, realName))
+            GlobalScope.launch(Dispatchers.IO) {
+                ircClient.connect()
+            }
+        }
+
+        override fun terminate() {
+            ircClient.disconnect()
+        }
+
+    })
+
+}

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

@@ -73,6 +73,10 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
         }
     }
 
+    fun disconnect() {
+        socket?.disconnect()
+    }
+
     companion object {
         @JvmStatic
         fun main(args: Array<String>) {

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

@@ -28,10 +28,15 @@ class CapabilitiesHandler : EventHandler {
         // TODO: We probably need to split the outgoing REQ lines if there are lots of caps
         // TODO: For caps with values we'll need to decide which value to use/whether to enable them/etc
         with (client.serverState.capabilities) {
-            negotiationState = CapabilitiesNegotiationState.AWAITING_ACK
-            advertisedCapabilities.keys.map { it.name }.let {
-                log.info { "Requesting capabilities: ${it.toList()}" }
-                client.send(capabilityRequestMessage(it))
+            if (advertisedCapabilities.keys.isEmpty()) {
+                negotiationState = CapabilitiesNegotiationState.FINISHED
+                client.send(capabilityEndMessage())
+            } else {
+                negotiationState = CapabilitiesNegotiationState.AWAITING_ACK
+                advertisedCapabilities.keys.map { it.name }.let {
+                    log.info { "Requesting capabilities: ${it.toList()}" }
+                    client.send(capabilityRequestMessage(it))
+                }
             }
         }
     }

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

@@ -34,7 +34,7 @@ class CapabilityProcessor : MessageProcessor {
         get() = params.slice(1 until params.size)
 
     private val List<ByteArray>.capabilities
-        get() = String(last()).split(' ').toCapabilities()
+        get() = with (String(last())) { if (isEmpty()) emptyMap() else split(' ').toCapabilities() }
 
     private fun List<String>.toCapabilities() = sequence {
         forEach { cap ->

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

@@ -38,6 +38,8 @@ internal class CapabilitiesHandlerTest {
     @Test
     fun `CapabilitiesHandler updates negotiation state when capabilities finished`() {
         runBlocking {
+            serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
+
             handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
 
             assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, serverState.capabilities.negotiationState)
@@ -56,6 +58,24 @@ internal class CapabilitiesHandlerTest {
         }
     }
 
+    @Test
+    fun `CapabilitiesHandler sends END when blank capabilities received`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+
+            verify(ircClient).send("CAP END")
+        }
+    }
+
+    @Test
+    fun `CapabilitiesHandler updates negotiation when blank capabilities received`() {
+        runBlocking {
+            handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+
+            assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
+        }
+    }
+
     @Test
     fun `CapabilitiesHandler sends END when capabilities acknowledged`() {
         runBlocking {

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

@@ -20,6 +20,15 @@ internal class CapabilityProcessorTest {
         assertTrue(events.isEmpty())
     }
 
+    @Test
+    fun `CapabilityProcessor raises ServerCapabilitiesReceived event given no capabilities`() {
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "").map { it.toByteArray() }))
+
+        val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
+        assertEquals(0, receivedEvent.capabilities.size)
+    }
+
+
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities`() {
         val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))