Wie verwalte ich die unit test Ressourcen in Kotlin, wie das starten/stoppen Sie eine Datenbank-Verbindung oder eine eingebettete elasticsearch server?

Ihre unit-test-Klasse muss in der Regel ein paar Dinge, die zum verwalten einer freigegebenen Ressource für eine Gruppe von test-Methoden. Und in Kotlin, die Sie verwenden können @BeforeClass und @AfterClass nicht in der test-Klasse, sondern innerhalb seiner companion-Objekt zusammen mit der @JvmStatic annotation.

Den Aufbau einer test-Klasse würde wie folgt Aussehen:

class MyTestClass {
    companion object {
        init {
           //things that may need to be setup before companion class member variables are instantiated
        }

        //variables you initialize for the class just once:
        val someClassVar = initializer() 

        //variables you initialize for the class later in the @BeforeClass method:
        lateinit var someClassLateVar: SomeResource 

        @BeforeClass @JvmStatic fun setup() {
           //things to execute once and keep around for the class
        }

        @AfterClass @JvmStatic fun teardown() {
           //clean up after this class, leave nothing dirty behind
        }
    }

    //variables you initialize per instance of the test class:
    val someInstanceVar = initializer() 

    //variables you initialize per test case later in your @Before methods:
    var lateinit someInstanceLateZVar: MyType 

    @Before fun prepareTest() { 
        //things to do before each test
    }

    @After fun cleanupTest() {
        //things to do after each test
    }

    @Test fun testSomething() {
        //an actual test case
    }

    @Test fun testSomethingElse() {
        //another test case
    }

    //...more test cases
}  

Angesichts der oben genannten, sollten Sie Lesen Sie über:

• companion Objekten - ähnlich wie die Klasse object in Java, sondern ein singleton pro Klasse, die nicht statisch ist,
• @JvmStatic - eine Anmerkung, die dreht sich eine companion-Objekt die Methode in einer statischen Methode auf die äußere Klasse für Java-interop
• lateinit - ermöglicht eine var Eigenschaft initialisiert werden später, wenn Sie eine gut definierte lifecycle -
• Delegierten.notNull() - kann anstelle von verwendet werden lateinit für eine Eigenschaft, die gesetzt werden sollten, mindestens einmal, bevor Sie gelesen werden.

Hier sind voller Beispiele von test-Klassen für Kotlin, dass die Verwaltung eingebetteter Ressourcen.

Den ersten kopiert und geändert von Solr-Sog tests, und bevor die Testfälle ausgeführt werden, konfiguriert und gestartet wird, ein Solr-Undertow-server. Nach dem ausführen der tests, es löscht alle temporären Dateien, die erstellt durch die tests. Es sorgt auch für environment-Variablen und system-Eigenschaften korrekt sind, bevor die tests ausgeführt werden. Zwischen test cases, es leert alle temporären geladen Solr-Kerne. Der test:

class TestServerWithPlugin {
    companion object {
        val workingDir = Paths.get("test-data/solr-standalone").toAbsolutePath()
        val coreWithPluginDir = workingDir.resolve("plugin-test/collection1")

        lateinit var server: Server

        @BeforeClass @JvmStatic fun setup() {
            assertTrue(coreWithPluginDir.exists(), "test core w/plugin does not exist $coreWithPluginDir")

            //make sure no system properties are set that could interfere with test
            resetEnvProxy()
            cleanSysProps()
            routeJbossLoggingToSlf4j()
            cleanFiles()

            val config = mapOf(...) 
            val configLoader = ServerConfigFromOverridesAndReference(workingDir, config) verifiedBy { loader ->
                ...
            }

            assertNotNull(System.getProperty("solr.solr.home"))

            server = Server(configLoader)
            val (serverStarted, message) = server.run()
            if (!serverStarted) {
                fail("Server not started: '$message'")
            }
        }

        @AfterClass @JvmStatic fun teardown() {
            server.shutdown()
            cleanFiles()
            resetEnvProxy()
            cleanSysProps()
        }

        private fun cleanSysProps() { ... }

        private fun cleanFiles() {
            //don't leave any test files behind
            coreWithPluginDir.resolve("data").deleteRecursively()
            Files.deleteIfExists(coreWithPluginDir.resolve("core.properties"))
            Files.deleteIfExists(coreWithPluginDir.resolve("core.properties.unloaded"))
        }
    }

    val adminClient: SolrClient = HttpSolrClient("http://localhost:8983/solr/")

    @Before fun prepareTest() {
        //anything before each test?
    }

    @After fun cleanupTest() {
        //make sure test cores do not bleed over between test cases
        unloadCoreIfExists("tempCollection1")
        unloadCoreIfExists("tempCollection2")
        unloadCoreIfExists("tempCollection3")
    }

    private fun unloadCoreIfExists(name: String) { ... }

    @Test
    fun testServerLoadsPlugin() {
        println("Loading core 'withplugin' from dir ${coreWithPluginDir.toString()}")
        val response = CoreAdminRequest.createCore("tempCollection1", coreWithPluginDir.toString(), adminClient)
        assertEquals(0, response.status)
    }

    //... other test cases
}

Und anderen ab AWS DynamoDB local als eine eingebettete Datenbank (kopiert und leicht modifiziert aus Laufen AWS DynamoDB-lokal eingebettete). Dieser test muss der hack java.library.path bevor irgendetwas anderes passiert, oder lokale DynamoDB (sqlite mit binären Bibliotheken) wird nicht ausgeführt. Dann startet er einen server zu teilen, für alle test-Klassen und bereinigt, temporäre Daten, die zwischen den tests. Der test:

class TestAccountManager {
    companion object {
        init {
            //we need to control the "java.library.path" or sqlite cannot find its libraries
            val dynLibPath = File("./src/test/dynlib/").absoluteFile
            System.setProperty("java.library.path", dynLibPath.toString());

            //TEST HACK: if we kill this value in the System classloader, it will be
            //recreated on next access allowing java.library.path to be reset
            val fieldSysPath = ClassLoader::class.java.getDeclaredField("sys_paths")
            fieldSysPath.setAccessible(true)
            fieldSysPath.set(null, null)

            //ensure logging always goes through Slf4j
            System.setProperty("org.eclipse.jetty.util.log.class", "org.eclipse.jetty.util.log.Slf4jLog")
        }

        private val localDbPort = 19444

        private lateinit var localDb: DynamoDBProxyServer
        private lateinit var dbClient: AmazonDynamoDBClient
        private lateinit var dynamo: DynamoDB

        @BeforeClass @JvmStatic fun setup() {
            //do not use ServerRunner, it is evil and doesn't set the port correctly, also
            //it resets logging to be off.
            localDb = DynamoDBProxyServer(localDbPort, LocalDynamoDBServerHandler(
                    LocalDynamoDBRequestHandler(0, true, null, true, true), null)
            )
            localDb.start()

            //fake credentials are required even though ignored
            val auth = BasicAWSCredentials("fakeKey", "fakeSecret")
            dbClient = AmazonDynamoDBClient(auth) initializedWith {
                signerRegionOverride = "us-east-1"
                setEndpoint("http://localhost:$localDbPort")
            }
            dynamo = DynamoDB(dbClient)

            //create the tables once
            AccountManagerSchema.createTables(dbClient)

            //for debugging reference
            dynamo.listTables().forEach { table ->
                println(table.tableName)
            }
        }

        @AfterClass @JvmStatic fun teardown() {
            dbClient.shutdown()
            localDb.stop()
        }
    }

    val jsonMapper = jacksonObjectMapper()
    val dynamoMapper: DynamoDBMapper = DynamoDBMapper(dbClient)

    @Before fun prepareTest() {
        //insert commonly used test data
        setupStaticBillingData(dbClient)
    }

    @After fun cleanupTest() {
        //delete anything that shouldn't survive any test case
        deleteAllInTable<Account>()
        deleteAllInTable<Organization>()
        deleteAllInTable<Billing>()
    }

    private inline fun <reified T: Any> deleteAllInTable() { ... }

    @Test fun testAccountJsonRoundTrip() {
        val acct = Account("123",  ...)
        dynamoMapper.save(acct)

        val item = dynamo.getTable("Accounts").getItem("id", "123")
        val acctReadJson = jsonMapper.readValue<Account>(item.toJSON())
        assertEquals(acct, acctReadJson)
    }

    //...more test cases

}

HINWEIS: einige Teile der Beispiele sind abgekürzt mit ...