Support step definitions written in Kotlin

Summary

Cucumber currently supports Kotlin by using Java Annotations or Lambda based step definitions. This works because Java and Kotlin can interoperate. This does however fails to leverage some of the advantages of Kotlin (#1554, #1520). So a Kotlin backend would be most useful.

Update:

The approach describe below will not work in the future because we are aiming for a design where step definitions must be discoverable without instantiating the glue class. For this reason we are deprecating cucumber-java8 (https://github.com/cucumber/cucumber-jvm/issues/2174) and this design was patterned on that. As a replacement for cucumber-java8 we are considering cucumber-lambda (https://github.com/cucumber/cucumber-jvm/issues/2279). This may or may not make this ticket obsolete.

Goals

1. Implement a Kotlin backend that supports step definitions, hooks, data table and parameter type declaration.

2. Avoid the duplication of method name and step definition common when using annotation based step definitions. Example:

Given("a step definition")
public void given_a_step_definition() {}

1. Use Kotlin primitives and types everywhere. This should include Cucumber expressions, parameter types, data table types, DataTable and DocString.

2. Generate Kotlin step definitions

Step definitions

class StepDefinitions(belly: Belly) : En {
   init {
     Given("there are {int} cukes in my belly"){ cukes : Int -> 
         belly.setCukes(cukes)
     }

      When("^I eat ([0-9]) cukes$") { cukes : Int ->
         belly.addCukes(cukes)
     }
   }
}

En would be implement as a class with members for various keywords and other glue (see java8 equivalent).

interface Test {

    fun Given(expression: String, f: Function<Unit>) {
        //Register with thread local as in Java 8
    }
    
    ... other key words
}

Note that Function has subtypes that support up to up to 22 parameters. After that it becomes a varg and we can no longer user f.javaClass.methods[1].genericParameterTypes to work out what the the types were. As a result Cucumber won’t be able to convert arguments automatically when using regular rather then Cucumber expressions. This is a reasonable drawback for wanting to use 22+ parameters.

Steps to take

1. Implement a KotlinBackendProviderService and KotlinBackend and KotlinStepDefinition for a single annotation. For examples see Java8** equivalents in the java8 module.
2. Experiment to see how the interop works
3. Implement everything else (sorry about the draw-the-rest-of-the-owl, I don’t know what or how yet).

[mpkorstanje]

This looks promising:

package io.cucumber.kotlin

import kotlin.reflect.KClass

class World {

    fun hello() {
        println("Hello world!")
    }

    fun hello(number: Int) {
        println("Hello world ${number}!")
    }
}

val stepDefinitions = define {
    using<World> {
        step("hello world") {
            hello();
        }
        step("hello again world {int}") { number: Int ->
            hello(number)
        }
    }
}

The plumbing:

fun define(define: StepDefinitions.() -> Unit): StepDefinitions {
    val stepDefinitions = StepDefinitions()
    stepDefinitions.define()
    return stepDefinitions;
}

class StepDefinitions {
    val stepDefinitions: MutableList<Any> = mutableListOf()
    inline fun <reified T : Any> using(define: Using<T>.() -> Unit) {
        val context = Using(T::class)
        context.define()
        stepDefinitions.addAll(context.stepDefinitions);
    }
}

class Using<T : Any>(val kls: KClass<T>) {
    val stepDefinitions: MutableList<Any> = mutableListOf()
    inline fun step(expression: String, noinline implementation: T.() -> Unit) {
        stepDefinitions.add(StepDefinition00(expression, implementation, kls))
    }

    inline fun <reified V1 : Any> step(expression: String, noinline implementation: T.(a: V1) -> Unit) {
        stepDefinitions.add(StepDefinition01(expression, implementation, kls, V1::class))
    }
}

data class StepDefinition00<T : Any>(
    val expression: String,
    val implementation: T.() -> Unit,
    val executionContextType: KClass<T>
)

data class StepDefinition01<T : Any, V1 : Any>(
    val expression: String,
    val implementation: T.(V1) -> Unit,
    val executionContextType: KClass<T>,
    val expressionArgType01: KClass<V1>
)

fun main() {
    stepDefinitions.stepDefinitions.forEach { println(it) }
}

[mpkorstanje]

Is it as simple as saying that if the description is not provided, the name of the method is used as the description?

Unfortunately not. See: https://github.com/cucumber/cucumber-jvm/issues/1829#issuecomment-558640666