Index of every page on this site: llms.txt
All skills
Run it yourself

Write and improve Kotlin tests with Kotest, MockK, coroutine test tools, property tests, Kover, and the red-green-refactor TDD cycle. Use for new Kotlin code, missing tests, test bugs, slow or flaky tests, and coverage setup.

  • 1 file
  • 8.3 KB
  • Updated 2 months ago
  • GitHub
Use this Skill: https://skilld.dev/gh/agenticluke/kotlin-test-pilot-plus/skill

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈58 tokens for metadata: the name and description. ≈2.1k when used: this file.

Description uses 3.0% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈242 characters, or 3.0%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Kotlin Testing

Original skill by ECC. Credit ECC in any copy or shared version of this skill.

Write small, clear, and stable Kotlin tests. Use Kotest for tests, MockK for test doubles, coroutine test tools for suspend code, and Kover for coverage.

When to Use

Use this skill when you:

  • Add a Kotlin function or class
  • Add tests to old Kotlin code
  • Fix a broken or flaky test
  • Test suspend functions or flows
  • Add property tests
  • Set up Kover coverage
  • Follow test-driven development, or TDD

Main Steps

  1. Read the code and its build files.
  2. Find the public result that must be true.
  3. Pick the smallest useful test type.
  4. Write one test that fails for the right reason.
  5. Run that test and check the failure.
  6. Write the least code needed to pass.
  7. Run the full test set.
  8. Clean up the code while tests stay green.
  9. Check coverage for missed cases.

Do not change build tool or test library unless the task needs it.

Pick the Right Test

  • Use StringSpec for short, direct cases.
  • Use FunSpec when setup or hooks help.
  • Use BehaviorSpec when Given, When, and Then make a rule easier to read.
  • Use a property test when many inputs follow the same rule.
  • Use an integration test when real file, data, or network parts must work together.

Test what code does. Do not test private methods on their own.

TDD Cycle

RED      Write one failing test.
GREEN    Write the least code that makes it pass.
REFACTOR Make the code clearer.
REPEAT   Add the next rule.

A RED test must fail because the feature is missing. A test that fails due to bad setup does not count.

Basic Kotest Example

package com.example.math

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe

class CalculatorTest : StringSpec({
    "adds two numbers" {
        Calculator.add(2, 3) shouldBe 5
    }

    "adds negative numbers" {
        Calculator.add(-2, -3) shouldBe -5
    }
})

Use clear test names. Each name should state one rule.

Matchers

Use the most exact matcher you can.

result shouldBe expected
result shouldNotBe wrongValue

name shouldStartWith "Al"
name shouldContain "lic"

items shouldHaveSize 3
items shouldContain "book"
items.shouldBeEmpty()

value.shouldBeNull()
value.shouldNotBeNull()
value.shouldBeInstanceOf<User>()

count shouldBeGreaterThan 0

shouldThrow<IllegalArgumentException> {
    validateAge(-1)
}.message shouldBe "Age must be positive"

Check error type and useful error data. Do not only check that some error happened.

For money and decimal values, use the exact type used by the app. For floating point values, use a small allowed gap.

MockK

Mock only code outside the unit under test. Prefer real value objects and small fake classes when they are easy to build.

class UserServiceTest : FunSpec({
    val repository = mockk<UserRepository>()
    val service = UserService(repository)

    beforeTest {
        clearMocks(repository)
    }

    test("returns the saved user") {
        val user = User(id = "1", name = "Alice")
        every { repository.findById("1") } returns user

        service.findUser("1") shouldBe user

        verify(exactly = 1) {
            repository.findById("1")
        }
        confirmVerified(repository)
    }
})

Rules:

  • Use every and verify for normal functions.
  • Use coEvery and coVerify for suspend functions.
  • Use relaxed = true only when unused calls do not matter.
  • Clear shared mocks before each test.
  • Stub every call that affects the result.
  • Verify key effects, not every small call.
  • Avoid mocking the class under test.
  • Do not hide missing setup with broad any() rules unless the input does not matter.

Coroutine Tests

Use runTest from kotlinx-coroutines-test. It gives safe test scope and virtual time.

import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.test.runTest

class AsyncUserServiceTest : FunSpec({
    val repository = mockk<UserRepository>()
    val service = UserService(repository)

    test("loads a user") {
        runTest {
            val user = User(id = "1", name = "Alice")
            coEvery { repository.findById("1") } returns user

            service.getUser("1") shouldBe user

            coVerify(exactly = 1) {
                repository.findById("1")
            }
        }
    }
})

Do not use real sleep calls. Use virtual time tools such as advanceTimeBy, runCurrent, or advanceUntilIdle.

Pass a test dispatcher or clock into app code when time or thread choice matters. Restore any changed main dispatcher after the test.

For flows:

  • Collect only the values the test needs.
  • End collection in the test.
  • Test empty, error, and cancel cases.
  • Do not leave jobs running after the test ends.

Property Tests

Use property tests for rules that should hold for many values.

import io.kotest.core.spec.style.StringSpec
import io.kotest.property.Arb
import io.kotest.property.arbitrary.int
import io.kotest.property.checkAll
import io.kotest.matchers.shouldBe

class MathPropertyTest : StringSpec({
    "adding zero keeps the same value" {
        checkAll(Arb.int()) { value ->
            value + 0 shouldBe value
        }
    }
})

Keep property tests stable:

  • Limit data to valid input when needed.
  • Add direct tests for key edge cases.
  • Include empty, zero, negative, min, and max values when valid.
  • Save the random seed when a failure must be run again.
  • Keep each property simple.
  • Do not use random data when a short table of cases is clearer.

Concrete Usage Example

Task: add an email check.

First, write tests:

class EmailValidatorTest : StringSpec({
    "accepts a valid email" {
        validateEmail("user@example.com")
            .getOrNull() shouldBe "user@example.com"
    }

    "rejects a blank email" {
        validateEmail("").isFailure shouldBe true
    }

    "rejects an email with no at sign" {
        validateEmail("user.example.com").isFailure shouldBe true
    }
})

Run the test:

./gradlew test --tests '*EmailValidatorTest'

Check that it fails because validateEmail is missing or not done. Then add the least code needed:

fun validateEmail(email: String): Result<String> {
    if (email.isBlank()) {
        return Result.failure(
            IllegalArgumentException("Email cannot be blank")
        )
    }

    if ('@' !in email) {
        return Result.failure(
            IllegalArgumentException("Email must contain @")
        )
    }

    return Result.success(email)
}

Run the test again. Then run all tests:

./gradlew test

Add more rules only when the app needs them. Do not claim full email rule support from a small check.

Edge Cases

Check cases that fit the code:

  • Empty and blank text
  • Null values when the type allows null
  • Zero and negative numbers
  • Min and max values
  • Empty and very large lists
  • Duplicate items
  • Unicode text
  • Time zones and daylight saving time
  • Missing files
  • Bad data
  • Timeouts
  • Cancelled coroutines
  • Failed work after part of a task is done
  • Calls made more than once
  • Shared state between tests

Use fixed clocks, test data, and random seeds. Tests must not depend on the current time, test order, local machine, or internet.

Kover Coverage

Use the Kover tasks already set by the project. Common tasks are:

./gradlew koverHtmlReport
./gradlew koverVerify

Open the HTML report and check missed branches, not only the total score.

Aim for 80 percent or the project rule, whichever is set. Coverage is a guide. A high score does not prove good tests. Do not add weak tests only to raise the number. Do not test generated code unless the project asks for it.

Final Check

Before finishing:

  • Run the changed test by itself.
  • Run the full test set.
  • Check that no test depends on run order.
  • Check that coroutine jobs end.
  • Check that mocks do not leak between tests.
  • Check key errors and edge cases.
  • Run Kover if coverage is part of the task.
  • Report any test you could not run and why.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at 65c8bea. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last month.

Steadyupdated 2 months ago
origin
ECC

README badge

README badge for agenticluke/kotlin-test-pilot-plus