T from the doc
13 | * string
14 | * @tparam T
15 | * type to convert to
16 | */
17 | def DocStringType[T](
18 | contentType: String
19 | )(body: DocStringDefinitionBody[T])(implicit ev: Stepable[T]): Unit = {
20 | registry.registerDocStringType(
21 | ScalaDocStringTypeDetails[T](
22 | contentType,
23 | body,
24 | ev.asJavaType,
25 | Utils.frame(self)
26 | )
27 | )
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/docs/upgrade_v8.md:
--------------------------------------------------------------------------------
1 | # Upgrading from 7.x to 8.x
2 |
3 | Prior to upgrading to v8.0.0 upgrade to latest v7.x and stop using all deprecated features.
4 | Some features will log a deprecation warning.
5 |
6 | See also:
7 | - [Cucumber Scala CHANGELOG](../CHANGELOG.md)
8 | - [Cucumber JVM CHANGELOG](https://github.com/cucumber/cucumber-jvm/blob/main/CHANGELOG.md)
9 |
10 | ## Cannot use `DataTable#asX` inside a `DataTableType`
11 |
12 | You should not use the methods `DataTable#asX()` in `DataTableType`s.
13 | It was working in previous versions, but it will now raise an exception when running your tests.
14 |
15 | Instead you should use:
16 | - Replace `DataTable#asList()` with `DataTable#values()`
17 | - Replace `DataTable#asLists()` with `DataTable#cells()`
18 | - Replace `DataTable#asMaps()` with `DataTable#entries()`
19 |
20 |
21 | More context for this change at https://github.com/cucumber/common/pull/1419
22 |
--------------------------------------------------------------------------------
/integration-tests/common/src/test/scala/isolated/IsolatedSteps.scala:
--------------------------------------------------------------------------------
1 | package isolated
2 |
3 | import java.util.{List => JList}
4 | import io.cucumber.scala.{EN, ScalaDsl}
5 |
6 | import scala.jdk.CollectionConverters._
7 |
8 | class IsolatedSteps extends ScalaDsl with EN {
9 |
10 | var mutableValues: List[Int] = List()
11 |
12 | Given("""I set the list of values to""") { (values: JList[Int]) =>
13 | // Obviously this is silly, as we keep the previous value but this is exactly what we want to test
14 | // Isolated scenarios should ensure that the previous value is not kept
15 | mutableValues = mutableValues ++ values.asScala.toList
16 | }
17 |
18 | Given("""I multiply by {int}""") { (mult: Int) =>
19 | mutableValues = mutableValues.map(i => i * mult)
20 | }
21 |
22 | Then("""the list of values is""") { (values: JList[Int]) =>
23 | assert(mutableValues == values.asScala.toList)
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/cucumber-scala/src/main/scala/io/cucumber/scala/DataTableDefinitionBody.scala:
--------------------------------------------------------------------------------
1 | package io.cucumber.scala
2 |
3 | import io.cucumber.datatable.DataTable
4 |
5 | trait DataTableEntryDefinitionBody[T] {
6 |
7 | def transform(entry: Map[String, String]): T
8 |
9 | }
10 |
11 | trait DataTableOptionalEntryDefinitionBody[T] {
12 |
13 | def transform(entry: Map[String, Option[String]]): T
14 |
15 | }
16 |
17 | trait DataTableRowDefinitionBody[T] {
18 |
19 | def transform(row: Seq[String]): T
20 |
21 | }
22 |
23 | trait DataTableOptionalRowDefinitionBody[T] {
24 |
25 | def transform(row: Seq[Option[String]]): T
26 |
27 | }
28 |
29 | trait DataTableCellDefinitionBody[T] {
30 |
31 | def transform(cell: String): T
32 |
33 | }
34 |
35 | trait DataTableOptionalCellDefinitionBody[T] {
36 |
37 | def transform(cell: Option[String]): T
38 |
39 | }
40 |
41 | trait DataTableDefinitionBody[T] {
42 |
43 | def transform(dataTable: DataTable): T
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/cucumber-scala/src/main/scala/io/cucumber/scala/ScalaStaticHookDefinition.scala:
--------------------------------------------------------------------------------
1 | package io.cucumber.scala
2 |
3 | import io.cucumber.core.backend.StaticHookDefinition
4 |
5 | trait ScalaStaticHookDefinition
6 | extends StaticHookDefinition
7 | with AbstractGlueDefinition {
8 |
9 | val hookDetails: ScalaStaticHookDetails
10 |
11 | override val location: StackTraceElement = hookDetails.stackTraceElement
12 |
13 | override def execute(): Unit = {
14 | executeAsCucumber(hookDetails.body.apply())
15 | }
16 |
17 | override def getOrder: Int = hookDetails.order
18 |
19 | }
20 |
21 | object ScalaStaticHookDefinition {
22 |
23 | def apply(
24 | scalaHookDetails: ScalaStaticHookDetails
25 | ): ScalaStaticHookDefinition = {
26 | new ScalaGlobalStaticHookDefinition(scalaHookDetails)
27 | }
28 |
29 | }
30 |
31 | class ScalaGlobalStaticHookDefinition(
32 | override val hookDetails: ScalaStaticHookDetails
33 | ) extends ScalaStaticHookDefinition {}
34 |
--------------------------------------------------------------------------------
/examples/examples-junit4/src/main/scala/cucumber/examples/scalacalculator/RpnCalculator.scala:
--------------------------------------------------------------------------------
1 | package cucumber.examples.scalacalculator
2 |
3 | import scala.collection.mutable.Queue
4 |
5 | sealed trait Arg
6 |
7 | object Arg {
8 | implicit def op(s: String): Op = Op(s)
9 | implicit def value(v: Double): Val = Val(v)
10 | }
11 |
12 | case class Op(value: String) extends Arg
13 | case class Val(value: Double) extends Arg
14 |
15 | class RpnCalculator {
16 | private val stack = Queue.empty[Double]
17 |
18 | private def op(f: (Double, Double) => Double) =
19 | stack += f(stack.dequeue(), stack.dequeue())
20 |
21 | def push(arg: Arg): Unit = {
22 | arg match {
23 | case Op("+") => op(_ + _)
24 | case Op("-") => op(_ - _)
25 | case Op("*") => op(_ * _)
26 | case Op("/") => op(_ / _)
27 | case Val(value) => stack += value
28 | case _ => ()
29 | }
30 | ()
31 | }
32 |
33 | def value: Double = stack.head
34 | }
35 |
--------------------------------------------------------------------------------
/examples/examples-junit5/src/main/scala/cucumber/examples/scalacalculator/RpnCalculator.scala:
--------------------------------------------------------------------------------
1 | package cucumber.examples.scalacalculator
2 |
3 | import scala.collection.mutable.Queue
4 |
5 | sealed trait Arg
6 |
7 | object Arg {
8 | implicit def op(s: String): Op = Op(s)
9 | implicit def value(v: Double): Val = Val(v)
10 | }
11 |
12 | case class Op(value: String) extends Arg
13 | case class Val(value: Double) extends Arg
14 |
15 | class RpnCalculator {
16 | private val stack = Queue.empty[Double]
17 |
18 | private def op(f: (Double, Double) => Double) =
19 | stack += f(stack.dequeue(), stack.dequeue())
20 |
21 | def push(arg: Arg): Unit = {
22 | arg match {
23 | case Op("+") => op(_ + _)
24 | case Op("-") => op(_ - _)
25 | case Op("*") => op(_ * _)
26 | case Op("/") => op(_ / _)
27 | case Val(value) => stack += value
28 | case _ => ()
29 | }
30 | ()
31 | }
32 |
33 | def value: Double = stack.head
34 | }
35 |
--------------------------------------------------------------------------------
/integration-tests/common/src/test/scala/misc/OptionalCaptureGroupsSteps.scala:
--------------------------------------------------------------------------------
1 | package misc
2 |
3 | import java.util.Optional
4 |
5 | import io.cucumber.scala.{EN, ScalaDsl}
6 |
7 | class OptionalCaptureGroupsSteps extends ScalaDsl with EN {
8 |
9 | // Scala 2.13 only
10 | // import scala.jdk.OptionConverters._
11 |
12 | import OptionalCaptureGroupsSteps._
13 |
14 | Given("""^I have the name:\s?(.+)?$""") { (name: Optional[String]) =>
15 | val option = name.toScala
16 | assert(option.isDefined)
17 | assert(option.getOrElse("Nope") == "Jack")
18 | }
19 |
20 | Given("""^I don't have the name:\s?(.+)?$""") { (name: Optional[String]) =>
21 | val option = name.toScala
22 | assert(option.isEmpty)
23 | }
24 |
25 | }
26 |
27 | object OptionalCaptureGroupsSteps {
28 |
29 | implicit class RichOptional[A](private val o: java.util.Optional[A])
30 | extends AnyVal {
31 |
32 | def toScala: Option[A] = if (o.isPresent) Some(o.get) else None
33 |
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/integration-tests/common/src/test/scala/statichooks/StaticHooksSteps.scala:
--------------------------------------------------------------------------------
1 | package statichooks
2 |
3 | import io.cucumber.scala.{EN, ScalaDsl}
4 | import org.junit.jupiter.api.Assertions.assertEquals
5 |
6 | import scala.annotation.nowarn
7 |
8 | @nowarn
9 | object StaticHooksSteps extends ScalaDsl with EN {
10 |
11 | var countBeforeAll: Int = 0
12 | var countAfterAll: Int = 0
13 |
14 | BeforeAll {
15 | countBeforeAll = countBeforeAll + 1
16 | }
17 |
18 | AfterAll {
19 | countAfterAll = countAfterAll + 1
20 | }
21 |
22 | When("""I run scenario {string}""") { (scenarioName: String) =>
23 | println(s"Running scenario $scenarioName")
24 | ()
25 | }
26 |
27 | Then("""BeforeAll count is {int}""") { (count: Int) =>
28 | println(s"BeforeAll = $countBeforeAll")
29 | assertEquals(count, countBeforeAll)
30 | }
31 |
32 | Then("""AfterAll count is {int}""") { (count: Int) =>
33 | println(s"AfterAll = $countAfterAll")
34 | assertEquals(count, countAfterAll)
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/integration-tests/common/src/test/resources/docstring/Docstring.feature:
--------------------------------------------------------------------------------
1 | Feature: As Cucumber Scala, I want to use DocStringType
2 |
3 | Scenario: Using a DocStringType
4 | Given the following json text
5 | """json
6 | {
7 | "key": "value"
8 | }
9 | """
10 | Then I have a json text
11 |
12 | Scenario: Using another DocStringType
13 | Given the following xml text
14 | """xml
15 | This trait register a `DefaultDataTableEntryTransformer` using Jackson 7 | * `ObjectMapper`.
8 | * 9 | *The `[empty]` string is used as default empty string replacement. You can 10 | * override it if you need to.
11 | * 12 | *Note: Jackson is not included with Cucumber Scala, you have to add the 13 | * dependency: `com.fasterxml.jackson.module:jackson-module-scala` to your 14 | * project if you want to use this trait.
15 | * 16 | *For Jackson 3.x, use `Jackson3DefaultDataTableEntryTransformer` 17 | * instead.
18 | */ 19 | trait JacksonDefaultDataTableEntryTransformer extends ScalaDsl { 20 | 21 | /** Define the string to be used as replacement for empty. Default is 22 | * `[empty]`. 23 | */ 24 | def emptyStringReplacement: String = "[empty]" 25 | 26 | /** Create the Jackson ObjectMapper to be used. Default is a simple 27 | * ObjectMapper with DefaultScalaModule registered. 28 | */ 29 | def createObjectMapper(): ObjectMapper = { 30 | val objectMapper = new ObjectMapper() 31 | objectMapper.registerModule(DefaultScalaModule) 32 | } 33 | 34 | private lazy val objectMapper: ObjectMapper = createObjectMapper() 35 | 36 | DefaultDataTableEntryTransformer(emptyStringReplacement) { 37 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 38 | objectMapper.convertValue[AnyRef]( 39 | fromValue, 40 | objectMapper.constructType(toValueType) 41 | ) 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /cucumber-scala/src/test/scala/io/cucumber/scala/ScalaDslDocStringTypeTest.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend._ 4 | import org.junit.jupiter.api.Test 5 | 6 | import scala.annotation.nowarn 7 | 8 | @nowarn 9 | class ScalaDslDocStringTypeTest { 10 | 11 | @Test 12 | def testDocStringType(): Unit = { 13 | 14 | class Glue extends ScalaDsl with EN { 15 | DocStringType("doc") { docString => 16 | new StringBuilder(docString) 17 | } 18 | } 19 | 20 | val glue = new Glue() 21 | 22 | assertClassDocStringType(glue.registry.docStringTypes.head) 23 | } 24 | 25 | // -------------------- Test on object -------------------- 26 | // Note: for now there is no difference between the two in ScalaDsl but better safe than sorry 27 | 28 | @Test 29 | def testObjectDocStringType(): Unit = { 30 | 31 | object Glue extends ScalaDsl with EN { 32 | DocStringType("doc") { docString => 33 | new StringBuilder(docString) 34 | } 35 | } 36 | 37 | assertObjectDocStringType(Glue.registry.docStringTypes.head) 38 | } 39 | 40 | private def assertClassDocStringType( 41 | details: ScalaDocStringTypeDetails[_] 42 | ): Unit = { 43 | assertDocStringType(ScalaDocStringTypeDefinition(details, true)) 44 | } 45 | 46 | private def assertObjectDocStringType( 47 | details: ScalaDocStringTypeDetails[_] 48 | ): Unit = { 49 | assertDocStringType(ScalaDocStringTypeDefinition(details, false)) 50 | } 51 | 52 | private def assertDocStringType( 53 | docStringType: DocStringTypeDefinition 54 | ): Unit = { 55 | // Cannot assert much because everything is strangely private in DocStringTypeDefinition 56 | // Real feature tests will do the job 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaDefaultParameterTransformerDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.lang.reflect.Type 4 | import io.cucumber.core.backend.{ 5 | DefaultParameterTransformerDefinition, 6 | ScenarioScoped 7 | } 8 | import io.cucumber.cucumberexpressions.ParameterByTypeTransformer 9 | 10 | import scala.annotation.nowarn 11 | 12 | trait ScalaDefaultParameterTransformerDefinition 13 | extends DefaultParameterTransformerDefinition 14 | with AbstractGlueDefinition { 15 | 16 | val details: ScalaDefaultParameterTransformerDetails 17 | 18 | override val location: StackTraceElement = details.stackTraceElement 19 | 20 | override val parameterByTypeTransformer: ParameterByTypeTransformer = 21 | (fromValue: String, toValue: Type) => { 22 | details.body.apply(fromValue, toValue) 23 | } 24 | 25 | } 26 | 27 | object ScalaDefaultParameterTransformerDefinition { 28 | 29 | def apply( 30 | details: ScalaDefaultParameterTransformerDetails, 31 | scenarioScoped: Boolean 32 | ): ScalaDefaultParameterTransformerDefinition = { 33 | if (scenarioScoped) { 34 | new ScalaScenarioScopedDefaultParameterTransformerDefinition(details) 35 | } else { 36 | new ScalaGlobalDefaultParameterTransformerDefinition(details) 37 | } 38 | } 39 | 40 | } 41 | 42 | @nowarn 43 | class ScalaScenarioScopedDefaultParameterTransformerDefinition( 44 | override val details: ScalaDefaultParameterTransformerDetails 45 | ) extends ScalaDefaultParameterTransformerDefinition 46 | with ScenarioScoped {} 47 | 48 | class ScalaGlobalDefaultParameterTransformerDefinition( 49 | override val details: ScalaDefaultParameterTransformerDetails 50 | ) extends ScalaDefaultParameterTransformerDefinition {} 51 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaParameterTypeDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend.{ParameterTypeDefinition, ScenarioScoped} 4 | import io.cucumber.cucumberexpressions.{CaptureGroupTransformer, ParameterType} 5 | 6 | import scala.annotation.nowarn 7 | import scala.jdk.CollectionConverters._ 8 | 9 | trait ScalaParameterTypeDefinition[R] 10 | extends ParameterTypeDefinition 11 | with AbstractGlueDefinition { 12 | 13 | val details: ScalaParameterTypeDetails[R] 14 | 15 | override val location: StackTraceElement = details.stackTraceElement 16 | 17 | private val transformer: CaptureGroupTransformer[R] = 18 | (parameterContent: Array[String]) => { 19 | details.body.apply(parameterContent.toList) 20 | } 21 | 22 | override val parameterType: ParameterType[R] = new ParameterType[R]( 23 | details.name, 24 | Seq(details.regex).asJava, 25 | details.tag.runtimeClass.asInstanceOf[Class[R]], 26 | transformer 27 | ) 28 | 29 | } 30 | 31 | object ScalaParameterTypeDefinition { 32 | 33 | def apply[R]( 34 | stepDetails: ScalaParameterTypeDetails[R], 35 | scenarioScoped: Boolean 36 | ): ScalaParameterTypeDefinition[R] = { 37 | if (scenarioScoped) { 38 | new ScalaScenarioScopedParameterTypeDefinition(stepDetails) 39 | } else { 40 | new ScalaGlobalParameterTypeDefinition(stepDetails) 41 | } 42 | } 43 | 44 | } 45 | 46 | @nowarn 47 | class ScalaScenarioScopedParameterTypeDefinition[R]( 48 | override val details: ScalaParameterTypeDetails[R] 49 | ) extends ScalaParameterTypeDefinition[R] 50 | with ScenarioScoped {} 51 | 52 | class ScalaGlobalParameterTypeDefinition[R]( 53 | override val details: ScalaParameterTypeDetails[R] 54 | ) extends ScalaParameterTypeDefinition[R] {} 55 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaStepDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.lang.reflect.{Type => JType} 4 | import java.util.{List => JList} 5 | import io.cucumber.core.backend.{ParameterInfo, ScenarioScoped, StepDefinition} 6 | 7 | import scala.annotation.nowarn 8 | import scala.jdk.CollectionConverters._ 9 | 10 | trait ScalaStepDefinition extends StepDefinition with AbstractGlueDefinition { 11 | 12 | val stepDetails: ScalaStepDetails 13 | 14 | override val location: StackTraceElement = stepDetails.frame 15 | 16 | override val parameterInfos: JList[ParameterInfo] = fromTypes( 17 | stepDetails.types 18 | ) 19 | 20 | private def fromTypes(types: Seq[JType]): JList[ParameterInfo] = { 21 | types 22 | .map(new ScalaTypeResolver(_)) 23 | .map(new ScalaParameterInfo(_)) 24 | .toList 25 | .asInstanceOf[List[ParameterInfo]] 26 | .asJava 27 | } 28 | 29 | override def execute(args: Array[AnyRef]): Unit = { 30 | executeAsCucumber { 31 | stepDetails.body(args.toList) 32 | () 33 | } 34 | } 35 | 36 | override def getPattern: String = stepDetails.pattern 37 | 38 | } 39 | 40 | object ScalaStepDefinition { 41 | 42 | def apply( 43 | stepDetails: ScalaStepDetails, 44 | scenarioScoped: Boolean 45 | ): ScalaStepDefinition = { 46 | if (scenarioScoped) { 47 | new ScalaScenarioScopedStepDefinition(stepDetails) 48 | } else { 49 | new ScalaGlobalStepDefinition(stepDetails) 50 | } 51 | } 52 | 53 | } 54 | 55 | @nowarn 56 | class ScalaScenarioScopedStepDefinition( 57 | override val stepDetails: ScalaStepDetails 58 | ) extends ScalaStepDefinition 59 | with ScenarioScoped {} 60 | 61 | class ScalaGlobalStepDefinition(override val stepDetails: ScalaStepDetails) 62 | extends ScalaStepDefinition {} 63 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/Jackson3DefaultDataTableEntryTransformer.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import tools.jackson.databind.ObjectMapper 4 | import tools.jackson.databind.json.JsonMapper 5 | import tools.jackson.module.scala.ScalaModule 6 | 7 | /**This trait register a `DefaultDataTableEntryTransformer` using Jackson 8 | * `ObjectMapper`.
9 | * 10 | *The `[empty]` string is used as default empty string replacement. You can 11 | * override it if you need to.
12 | * 13 | *Note: Jackson is not included with Cucumber Scala, you have to add the 14 | * dependency: `tools.jackson.module:jackson-module-scala` to your project if 15 | * you want to use this trait.
16 | * 17 | *For Jackson 2.x, use `JacksonDefaultDataTableEntryTransformer` 18 | * instead.
19 | */ 20 | trait Jackson3DefaultDataTableEntryTransformer extends ScalaDsl { 21 | 22 | /** Define the string to be used as replacement for empty. Default is 23 | * `[empty]`. 24 | */ 25 | def emptyStringReplacement: String = "[empty]" 26 | 27 | /** Create the Jackson ObjectMapper to be used. Default is a simple JsonMapper 28 | * with ScalaModule (including all builtin modules) registered. 29 | */ 30 | def createObjectMapper(): ObjectMapper = { 31 | val scalaModule = ScalaModule 32 | .builder() 33 | .addAllBuiltinModules() 34 | .build() 35 | JsonMapper.builder().addModule(scalaModule).build() 36 | } 37 | 38 | private lazy val objectMapper: ObjectMapper = createObjectMapper() 39 | 40 | DefaultDataTableEntryTransformer(emptyStringReplacement) { 41 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 42 | objectMapper.convertValue[AnyRef]( 43 | fromValue, 44 | objectMapper.constructType(toValueType) 45 | ) 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaHookDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend.{HookDefinition, ScenarioScoped, TestCaseState} 4 | import io.cucumber.scala.ScopedHookType.{AFTER, AFTER_STEP, BEFORE, BEFORE_STEP} 5 | 6 | import java.util.Optional 7 | import scala.annotation.nowarn 8 | 9 | trait ScalaHookDefinition extends HookDefinition with AbstractGlueDefinition { 10 | 11 | val hookDetails: ScalaHookDetails 12 | 13 | override val location: StackTraceElement = hookDetails.stackTraceElement 14 | 15 | override def execute(state: TestCaseState): Unit = { 16 | executeAsCucumber(hookDetails.body.apply(new Scenario(state))) 17 | } 18 | 19 | override def getTagExpression: String = hookDetails.tagExpression 20 | 21 | override def getOrder: Int = hookDetails.order 22 | 23 | override def getHookType: Optional[HookDefinition.HookType] = { 24 | val javaHookType = hookDetails.hookType match { 25 | case BEFORE => HookDefinition.HookType.BEFORE 26 | case AFTER => HookDefinition.HookType.AFTER 27 | case BEFORE_STEP => HookDefinition.HookType.BEFORE_STEP 28 | case AFTER_STEP => HookDefinition.HookType.AFTER_STEP 29 | } 30 | Optional.of(javaHookType) 31 | } 32 | 33 | } 34 | 35 | object ScalaHookDefinition { 36 | 37 | def apply( 38 | scalaHookDetails: ScalaHookDetails, 39 | scenarioScoped: Boolean 40 | ): ScalaHookDefinition = { 41 | if (scenarioScoped) { 42 | new ScalaScenarioScopedHookDefinition(scalaHookDetails) 43 | } else { 44 | new ScalaGlobalHookDefinition(scalaHookDetails) 45 | } 46 | } 47 | 48 | } 49 | 50 | @nowarn 51 | class ScalaScenarioScopedHookDefinition( 52 | override val hookDetails: ScalaHookDetails 53 | ) extends ScalaHookDefinition 54 | with ScenarioScoped {} 55 | 56 | class ScalaGlobalHookDefinition(override val hookDetails: ScalaHookDetails) 57 | extends ScalaHookDefinition {} 58 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaDefaultDataTableCellTransformerDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.lang.reflect.Type 4 | import io.cucumber.core.backend.{ 5 | DefaultDataTableCellTransformerDefinition, 6 | ScenarioScoped 7 | } 8 | import io.cucumber.datatable.TableCellByTypeTransformer 9 | 10 | import scala.annotation.nowarn 11 | 12 | trait ScalaDefaultDataTableCellTransformerDefinition 13 | extends DefaultDataTableCellTransformerDefinition 14 | with AbstractDatatableElementTransformerDefinition { 15 | 16 | val details: ScalaDefaultDataTableCellTransformerDetails 17 | 18 | override val emptyPatterns: Seq[String] = details.emptyPatterns 19 | 20 | override val location: StackTraceElement = details.stackTraceElement 21 | 22 | override val tableCellByTypeTransformer: TableCellByTypeTransformer = 23 | (fromValue: String, toTypeValue: Type) => { 24 | details.body.apply( 25 | replaceEmptyPatternsWithEmptyString(fromValue), 26 | toTypeValue 27 | ) 28 | } 29 | 30 | } 31 | 32 | object ScalaDefaultDataTableCellTransformerDefinition { 33 | 34 | def apply( 35 | details: ScalaDefaultDataTableCellTransformerDetails, 36 | scenarioScoped: Boolean 37 | ): ScalaDefaultDataTableCellTransformerDefinition = { 38 | if (scenarioScoped) { 39 | new ScalaScenarioScopedDataTableCellTransformerDefinition(details) 40 | } else { 41 | new ScalaGlobalDataTableCellTransformerDefinition(details) 42 | } 43 | } 44 | 45 | } 46 | 47 | @nowarn 48 | class ScalaScenarioScopedDataTableCellTransformerDefinition( 49 | override val details: ScalaDefaultDataTableCellTransformerDetails 50 | ) extends ScalaDefaultDataTableCellTransformerDefinition 51 | with ScenarioScoped {} 52 | 53 | class ScalaGlobalDataTableCellTransformerDefinition( 54 | override val details: ScalaDefaultDataTableCellTransformerDetails 55 | ) extends ScalaDefaultDataTableCellTransformerDefinition {} 56 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/resources/parametertypes/ParameterTypes.feature: -------------------------------------------------------------------------------- 1 | Feature: As Cucumber Scala, I want to handle ParameterType definitions 2 | 3 | Scenario: define parameter type with single argument 4 | Given "string builder" parameter, defined by lambda 5 | 6 | Scenario: define parameter type with two arguments 7 | Given balloon coordinates 123,456, defined by lambda 8 | 9 | Scenario: define parameter type with three arguments 10 | Given kebab made from mushroom, meat and veg, defined by lambda 11 | 12 | Scenario: define parameter type with parameterized type, string undefined 13 | Given an optional string parameter value "" undefined 14 | 15 | Scenario: define parameter type with parameterized type, string defined 16 | Given an optional string parameter value "toto" defined 17 | 18 | Scenario: define parameter type with parameterized type, int undefined 19 | Given an optional int parameter value undefined 20 | 21 | Scenario: define parameter type with parameterized type, int defined 22 | Given an optional int parameter value 5 defined 23 | 24 | Scenario: define default parameter transformer 25 | Given kebab made from anonymous meat, defined by lambda 26 | 27 | Scenario: define default data table cell transformer - DataTable 28 | Given default data table cells, defined by lambda 29 | | Kebab | 30 | | [empty] | 31 | 32 | Scenario: define default data table cell transformer - JList[Jlist] 33 | Given default data table cells, defined by lambda, as rows 34 | | Kebab | 35 | | [empty] | 36 | 37 | Scenario: define default data table entry transformer - DataTable 38 | Given default data table entries, defined by lambda 39 | | dinner | 40 | | Kebab | 41 | | [empty] | 42 | 43 | Scenario: define default data table entry transformer - JList 44 | Given default data table entries, defined by lambda, as rows 45 | | dinner | 46 | | Kebab | 47 | | [empty] | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaDataTableTypeDetails.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import scala.reflect.ClassTag 4 | 5 | sealed trait ScalaDataTableTypeDetails[T] { 6 | def emptyPatterns: Seq[String] 7 | def tag: ClassTag[T] 8 | def stackTraceElement: StackTraceElement 9 | } 10 | 11 | case class ScalaDataTableEntryTypeDetails[T]( 12 | emptyPatterns: Seq[String], 13 | body: DataTableEntryDefinitionBody[T], 14 | tag: ClassTag[T], 15 | stackTraceElement: StackTraceElement 16 | ) extends ScalaDataTableTypeDetails[T] 17 | 18 | case class ScalaDataTableOptionalEntryTypeDetails[T]( 19 | emptyPatterns: Seq[String], 20 | body: DataTableOptionalEntryDefinitionBody[T], 21 | tag: ClassTag[T], 22 | stackTraceElement: StackTraceElement 23 | ) extends ScalaDataTableTypeDetails[T] 24 | 25 | case class ScalaDataTableRowTypeDetails[T]( 26 | emptyPatterns: Seq[String], 27 | body: DataTableRowDefinitionBody[T], 28 | tag: ClassTag[T], 29 | stackTraceElement: StackTraceElement 30 | ) extends ScalaDataTableTypeDetails[T] 31 | 32 | case class ScalaDataTableOptionalRowTypeDetails[T]( 33 | emptyPatterns: Seq[String], 34 | body: DataTableOptionalRowDefinitionBody[T], 35 | tag: ClassTag[T], 36 | stackTraceElement: StackTraceElement 37 | ) extends ScalaDataTableTypeDetails[T] 38 | 39 | case class ScalaDataTableCellTypeDetails[T]( 40 | emptyPatterns: Seq[String], 41 | body: DataTableCellDefinitionBody[T], 42 | tag: ClassTag[T], 43 | stackTraceElement: StackTraceElement 44 | ) extends ScalaDataTableTypeDetails[T] 45 | 46 | case class ScalaDataTableOptionalCellTypeDetails[T]( 47 | emptyPatterns: Seq[String], 48 | body: DataTableOptionalCellDefinitionBody[T], 49 | tag: ClassTag[T], 50 | stackTraceElement: StackTraceElement 51 | ) extends ScalaDataTableTypeDetails[T] 52 | 53 | case class ScalaDataTableTableTypeDetails[T]( 54 | emptyPatterns: Seq[String], 55 | body: DataTableDefinitionBody[T], 56 | tag: ClassTag[T], 57 | stackTraceElement: StackTraceElement 58 | ) extends ScalaDataTableTypeDetails[T] 59 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/scala/docstring/DocStringSteps.scala: -------------------------------------------------------------------------------- 1 | package docstring 2 | 3 | import io.cucumber.scala.{EN, ScalaDsl} 4 | 5 | class DocStringSteps extends ScalaDsl with EN { 6 | 7 | case class JsonText(json: String) 8 | 9 | case class XmlText(xml: String) 10 | 11 | case class RawText(raw: String) 12 | 13 | var _text: Any = _ 14 | 15 | DocStringType("json") { (text) => 16 | JsonText(text) 17 | } 18 | 19 | DocStringType("xml") { (text) => 20 | XmlText(text) 21 | } 22 | 23 | DocStringType("") { (text) => 24 | RawText(text) 25 | } 26 | 27 | // Tests generic type 28 | DocStringType[Seq[String]]("") { (text) => 29 | text.split('\n').toSeq 30 | } 31 | 32 | DocStringType[Seq[Int]]("") { (text) => 33 | text.split('\n').map(_.toInt).toSeq 34 | } 35 | 36 | Given("the following json text") { (json: JsonText) => 37 | _text = json 38 | } 39 | 40 | Given("the following xml text") { (xml: XmlText) => 41 | _text = xml 42 | } 43 | 44 | Given("the following raw text") { (raw: RawText) => 45 | _text = raw 46 | } 47 | 48 | Given("the following string list") { (list: Seq[String]) => 49 | _text = list 50 | } 51 | 52 | Given("the following int list") { (list: Seq[Int]) => 53 | _text = list 54 | } 55 | 56 | Then("I have a json text") { 57 | assert(_text.isInstanceOf[JsonText]) 58 | } 59 | 60 | Then("I have a xml text") { 61 | assert(_text.isInstanceOf[XmlText]) 62 | } 63 | 64 | Then("I have a raw text") { 65 | assert(_text.isInstanceOf[RawText]) 66 | } 67 | 68 | Then("I have a string list {string}") { (expectedList: String) => 69 | assert(_text.isInstanceOf[Seq[_]]) 70 | assert(_text.asInstanceOf[Seq[_]].head.isInstanceOf[String]) 71 | assert(_text.asInstanceOf[Seq[String]] == expectedList.split(',').toSeq) 72 | } 73 | 74 | Then("I have a int list {string}") { (expectedList: String) => 75 | assert(_text.isInstanceOf[Seq[_]]) 76 | assert(_text.asInstanceOf[Seq[_]].head.isInstanceOf[Int]) 77 | assert( 78 | _text.asInstanceOf[Seq[Int]] == expectedList.split(',').map(_.toInt).toSeq 79 | ) 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaDefaultDataTableEntryTransformerDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.lang.reflect.Type 4 | import java.util.{Map => JavaMap} 5 | import io.cucumber.core.backend.{ 6 | DefaultDataTableEntryTransformerDefinition, 7 | ScenarioScoped 8 | } 9 | import io.cucumber.datatable.{ 10 | TableCellByTypeTransformer, 11 | TableEntryByTypeTransformer 12 | } 13 | 14 | import scala.annotation.nowarn 15 | import scala.jdk.CollectionConverters._ 16 | 17 | trait ScalaDefaultDataTableEntryTransformerDefinition 18 | extends DefaultDataTableEntryTransformerDefinition 19 | with AbstractDatatableElementTransformerDefinition { 20 | 21 | val details: ScalaDefaultDataTableEntryTransformerDetails 22 | 23 | override val emptyPatterns: Seq[String] = details.emptyPatterns 24 | 25 | override val location: StackTraceElement = details.stackTraceElement 26 | 27 | override val tableEntryByTypeTransformer: TableEntryByTypeTransformer = ( 28 | fromValue: JavaMap[String, String], 29 | toValueType: Type, 30 | _: TableCellByTypeTransformer 31 | ) => { 32 | replaceEmptyPatternsWithEmptyString(fromValue.asScala.toMap) 33 | .map(details.body.apply(_, toValueType)) 34 | .get 35 | } 36 | 37 | override val headersToProperties: Boolean = true 38 | 39 | } 40 | 41 | object ScalaDefaultDataTableEntryTransformerDefinition { 42 | 43 | def apply( 44 | details: ScalaDefaultDataTableEntryTransformerDetails, 45 | scenarioScoped: Boolean 46 | ): ScalaDefaultDataTableEntryTransformerDefinition = { 47 | if (scenarioScoped) { 48 | new ScalaScenarioScopedDataTableEntryTransformerDefinition(details) 49 | } else { 50 | new ScalaGlobalDataTableEntryTransformerDefinition(details) 51 | } 52 | } 53 | 54 | } 55 | 56 | @nowarn 57 | class ScalaScenarioScopedDataTableEntryTransformerDefinition( 58 | override val details: ScalaDefaultDataTableEntryTransformerDetails 59 | ) extends ScalaDefaultDataTableEntryTransformerDefinition 60 | with ScenarioScoped {} 61 | 62 | class ScalaGlobalDataTableEntryTransformerDefinition( 63 | override val details: ScalaDefaultDataTableEntryTransformerDetails 64 | ) extends ScalaDefaultDataTableEntryTransformerDefinition {} 65 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/codegen/gen.scala: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Generates the evil looking apply methods in StepDsl#StepBody for Function1 to Function22 4 | * Scala 3 5 | */ 6 | for (i <- 1 to 22) { 7 | val ts = (1 to i).map("T".+).mkString(", ") 8 | val implicits = (1 to i).map(n => s"t$n: Stepable[T$n]").mkString(", ") 9 | val implicitsParams = (1 to i).map(n => s"t$n").mkString(", ") 10 | val listParams = (1 to i).map("a" + _ + ":AnyRef").mkString(", ") 11 | val pf = (1 to i).map(n => "a" + n + ".asInstanceOf[T" + n + "]").mkString(",\n ") 12 | 13 | println(s""" 14 | |def apply[$ts](f: ($ts) => Any)(using $implicits): Unit = { 15 | | register($implicitsParams) { 16 | | case List($listParams) => 17 | | f($pf) 18 | | case _ => 19 | | throw new IncorrectStepDefinitionException() 20 | | } 21 | |}""".stripMargin) 22 | } 23 | 24 | /* 25 | * Generates the apply methods in ParameterTypeDsl for Function1 to Function22 26 | */ 27 | for (i <- 1 to 22) { 28 | // String, String, ..., String 29 | val types = (1 to i).map(_ => "String").mkString(", ") 30 | // p1, p2, ..., p22 31 | val args = (1 to i).map(j => s"p$j").mkString(", ") 32 | 33 | val template = 34 | s""" 35 | |def apply[R](f: ($types) => R)(implicit tag: ClassTag[R]): Unit = { 36 | | register { 37 | | case List($args) => 38 | | f($args) 39 | | } 40 | |} 41 | |""".stripMargin 42 | 43 | println(template) 44 | } 45 | 46 | /* 47 | * Generates the Stepable implicit methods 48 | */ 49 | for (i <- (1 to 9).reverse) { 50 | 51 | val underscores = (1 to i).map(_ => "_").mkString(", ") 52 | val types = (1 to i).map(j => s"X$j").mkString(", ") 53 | val typesStepable = (1 to i).map(j => s"X$j: Stepable").mkString(", ") 54 | val typeArgs = (1 to i).map(j => s"implicitly[Stepable[X$j]].asJavaType").mkString(", ") 55 | 56 | val template = 57 | s""" 58 | |implicit def stepable$i[T[$underscores], $typesStepable](implicit ct: ClassTag[T[$types]]): Stepable[T[$types]] = 59 | | new Stepable[T[$types]] { 60 | | def asJavaType: JavaType = 61 | | new ScalaParameterizedType( 62 | | ct.runtimeClass, 63 | | Array( 64 | | $typeArgs 65 | | ) 66 | | ) 67 | | }""".stripMargin 68 | 69 | println(template) 70 | } 71 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/IncorrectHookDefinitionException.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend.CucumberBackendException 4 | 5 | sealed abstract class IncorrectHookDefinitionException(message: String) 6 | extends CucumberBackendException(message) 7 | 8 | object IncorrectHookDefinitionException { 9 | 10 | def undefinedHooksErrorMessage(expectedHooks: Seq[UndefinedHook]): String = { 11 | val hooksListToDisplay = expectedHooks.map { eh => 12 | s" - ${eh.stackTraceElement.getFileName}:${eh.stackTraceElement.getLineNumber} (${eh.hookType})" 13 | } 14 | 15 | s"""Some hooks are not defined properly: 16 | |${hooksListToDisplay.mkString("\n")} 17 | | 18 | |This can be caused by defining hooks where the body returns a Int or String rather than Unit. 19 | | 20 | |For instance, the following code: 21 | | 22 | | Before { 23 | | someInitMethodReturningInt() 24 | | } 25 | | 26 | |Should be replaced with: 27 | | 28 | | Before { 29 | | someInitMethodReturningInt() 30 | | () 31 | | } 32 | |""".stripMargin 33 | } 34 | 35 | def scenarioScopedStaticHookErrorMessage( 36 | staticHooks: Seq[ScalaStaticHookDetails] 37 | ): String = { 38 | val hooksListToDisplay: Seq[String] = staticHooks.map { h => 39 | s" - ${h.stackTraceElement.getFileName}:${h.stackTraceElement.getLineNumber}" 40 | } 41 | 42 | s"""Some hooks are not defined properly: 43 | |${hooksListToDisplay.mkString("\n")} 44 | | 45 | |This can be caused by defining static hooks (BeforeAll/AfterAll) in a class rather than in a object. 46 | |Such hooks can only be defined in a static context. 47 | |""".stripMargin 48 | } 49 | 50 | } 51 | 52 | class UndefinedHooksException(val undefinedHooks: Seq[UndefinedHook]) 53 | extends IncorrectHookDefinitionException( 54 | IncorrectHookDefinitionException.undefinedHooksErrorMessage( 55 | undefinedHooks 56 | ) 57 | ) {} 58 | 59 | class ScenarioScopedStaticHookException( 60 | val staticHooks: Seq[ScalaStaticHookDetails] 61 | ) extends IncorrectHookDefinitionException( 62 | IncorrectHookDefinitionException.scenarioScopedStaticHookErrorMessage( 63 | staticHooks 64 | ) 65 | ) {} 66 | 67 | case class UndefinedHook( 68 | hookType: HookType, 69 | stackTraceElement: StackTraceElement 70 | ) 71 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/AbstractDatatableElementTransformerDefinition.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.datatable.DataTable 4 | 5 | import scala.util.{Failure, Success, Try} 6 | import scala.jdk.CollectionConverters._ 7 | 8 | trait AbstractDatatableElementTransformerDefinition 9 | extends AbstractGlueDefinition { 10 | 11 | val emptyPatterns: Seq[String] 12 | 13 | protected def replaceEmptyPatternsWithEmptyString( 14 | row: Seq[String] 15 | ): Seq[String] = { 16 | row.map(replaceEmptyPatternsWithEmptyString) 17 | } 18 | 19 | protected def replaceEmptyPatternsWithEmptyString( 20 | table: DataTable 21 | ): DataTable = { 22 | val rawWithEmptyStrings = table 23 | .cells() 24 | .asScala 25 | .map(_.asScala.toSeq) 26 | .map(replaceEmptyPatternsWithEmptyString) 27 | .map(_.asJava) 28 | .toSeq 29 | .asJava 30 | 31 | DataTable.create(rawWithEmptyStrings, table.getTableConverter) 32 | } 33 | 34 | protected def replaceEmptyPatternsWithEmptyString( 35 | fromValue: Map[String, String] 36 | ): Try[Map[String, String]] = { 37 | val replacement = fromValue.toSeq.map { case (key, value) => 38 | val potentiallyEmptyKey = replaceEmptyPatternsWithEmptyString(key) 39 | val potentiallyEmptyValue = replaceEmptyPatternsWithEmptyString(value) 40 | 41 | (potentiallyEmptyKey, potentiallyEmptyValue) 42 | } 43 | 44 | if (containsDuplicateKey(replacement)) { 45 | Failure(createDuplicateKeyAfterReplacement(fromValue)) 46 | } else { 47 | Success(replacement.toMap) 48 | } 49 | } 50 | 51 | protected def replaceEmptyPatternsWithEmptyString(t: String): String = { 52 | if (emptyPatterns.contains(t)) { 53 | "" 54 | } else { 55 | t 56 | } 57 | } 58 | 59 | private def containsDuplicateKey(seq: Seq[(String, Any)]): Boolean = { 60 | seq.map { case (key, _) => key }.toSet.size != seq.size 61 | } 62 | 63 | private def createDuplicateKeyAfterReplacement( 64 | fromValue: Map[String, String] 65 | ): IllegalArgumentException = { 66 | val conflict = 67 | emptyPatterns.filter(emptyPattern => fromValue.contains(emptyPattern)) 68 | val msg = 69 | s"After replacing ${conflict.headOption 70 | .getOrElse("")} and ${conflict.drop(1).headOption.getOrElse("")} with empty strings the datatable entry contains duplicate keys: $fromValue" 71 | new IllegalArgumentException(msg) 72 | } 73 | 74 | } 75 | -------------------------------------------------------------------------------- /scripts/update-changelog.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -uf -o pipefail 3 | 4 | # Reads a changelog from STDIN and writes out a new one to STDOUT where: 5 | # 6 | # * The [Unreleased] diff link is updated 7 | # * A new diff link for the new release is added 8 | # * The ## [Unreleased] header is changed to a version header with date 9 | # * The empty sections are removed 10 | # * A new, empty [Unreleased] paragraph is added at the top 11 | # 12 | 13 | changelog=$(&2 echo "No version found in link: ${unreleased_link}" 54 | exit 1 55 | fi 56 | 57 | # Insert a new release diff link 58 | 59 | insertion_line_number=$((line_number + 1)) 60 | release_link=$(echo "${changelog}" | head -n ${insertion_line_number} | tail -1) 61 | new_release_link=$(echo "${release_link}" | \ 62 | sed "s/${last_version}/${new_version}/g" | \ 63 | sed "s/v[0-9]\+.[0-9]\+.[0-9]\+/v${last_version}/") 64 | 65 | changelog=$(echo "${changelog}" | sed "${insertion_line_number} i \\ 66 | ${new_release_link} 67 | ") 68 | 69 | # Remove empty sections 70 | 71 | scripts_path="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" 72 | changelog=$(echo "${changelog}" | awk -f "${scripts_path}/remove-empty-sections-changelog.awk") 73 | 74 | # Insert a new [Unreleased] header 75 | 76 | changelog=$(echo "${changelog}" | sed "s/----/----\\ 77 | ${header_escaped}\\ 78 | /g") 79 | 80 | echo "${changelog}" 81 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/ScalaSnippet.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.lang.reflect.Type 4 | import java.text.MessageFormat 5 | import java.util.{Map => JMap} 6 | import java.util.Optional 7 | 8 | import io.cucumber.core.backend.Snippet 9 | import io.cucumber.datatable.DataTable 10 | 11 | import scala.jdk.CollectionConverters._ 12 | 13 | object ScalaSnippet { 14 | 15 | // Allows to use """ in """xxx"""" strings 16 | val tripleDoubleQuotes = "\"\"\"" 17 | 18 | } 19 | 20 | class ScalaSnippet extends Snippet { 21 | 22 | import ScalaSnippet.tripleDoubleQuotes 23 | 24 | override def language(): Optional[String] = { 25 | Optional.of("scala") 26 | } 27 | 28 | override def template(): MessageFormat = { 29 | new MessageFormat( 30 | s"""{0}(${tripleDoubleQuotes}{1}${tripleDoubleQuotes}) '{' ({3}) => 31 | | // {4} 32 | | throw new ${classOf[PendingException].getName}() 33 | |'}'""".stripMargin 34 | ) 35 | } 36 | 37 | override def tableHint(): String = { 38 | """| // For automatic transformation, change DataTable to one of 39 | | // E, List A data table can only
12 | * represent absent and non-empty strings. By replacing a known value (for
13 | * example [empty]) a data table can also represent empty strings.
14 | *
15 | * @param replaceWithEmptyString
16 | * a string that will be replaced with an empty string.
17 | */
18 | def DataTableType(replaceWithEmptyString: String): DataTableTypeBody =
19 | DataTableType(Seq(replaceWithEmptyString))
20 |
21 | private def DataTableType(replaceWithEmptyString: Seq[String]) =
22 | new DataTableTypeBody(replaceWithEmptyString)
23 |
24 | final class DataTableTypeBody(replaceWithEmptyString: Seq[String]) {
25 |
26 | def apply[T](
27 | body: DataTableEntryDefinitionBody[T]
28 | )(implicit ev: ClassTag[T]): Unit = {
29 | registry.registerDataTableType(
30 | ScalaDataTableEntryTypeDetails[T](
31 | replaceWithEmptyString,
32 | body,
33 | ev,
34 | Utils.frame(self)
35 | )
36 | )
37 | }
38 |
39 | def apply[T](
40 | body: DataTableOptionalEntryDefinitionBody[T]
41 | )(implicit ev: ClassTag[T]): Unit = {
42 | registry.registerDataTableType(
43 | ScalaDataTableOptionalEntryTypeDetails[T](
44 | replaceWithEmptyString,
45 | body,
46 | ev,
47 | Utils.frame(self)
48 | )
49 | )
50 | }
51 |
52 | def apply[T](
53 | body: DataTableRowDefinitionBody[T]
54 | )(implicit ev: ClassTag[T]): Unit = {
55 | registry.registerDataTableType(
56 | ScalaDataTableRowTypeDetails[T](
57 | replaceWithEmptyString,
58 | body,
59 | ev,
60 | Utils.frame(self)
61 | )
62 | )
63 | }
64 |
65 | def apply[T](
66 | body: DataTableOptionalRowDefinitionBody[T]
67 | )(implicit ev: ClassTag[T]): Unit = {
68 | registry.registerDataTableType(
69 | ScalaDataTableOptionalRowTypeDetails[T](
70 | replaceWithEmptyString,
71 | body,
72 | ev,
73 | Utils.frame(self)
74 | )
75 | )
76 | }
77 |
78 | def apply[T](
79 | body: DataTableCellDefinitionBody[T]
80 | )(implicit ev: ClassTag[T]): Unit = {
81 | registry.registerDataTableType(
82 | ScalaDataTableCellTypeDetails[T](
83 | replaceWithEmptyString,
84 | body,
85 | ev,
86 | Utils.frame(self)
87 | )
88 | )
89 | }
90 |
91 | def apply[T](
92 | body: DataTableOptionalCellDefinitionBody[T]
93 | )(implicit ev: ClassTag[T]): Unit = {
94 | registry.registerDataTableType(
95 | ScalaDataTableOptionalCellTypeDetails[T](
96 | replaceWithEmptyString,
97 | body,
98 | ev,
99 | Utils.frame(self)
100 | )
101 | )
102 | }
103 |
104 | def apply[T](
105 | body: DataTableDefinitionBody[T]
106 | )(implicit ev: ClassTag[T]): Unit = {
107 | registry.registerDataTableType(
108 | ScalaDataTableTableTypeDetails[T](
109 | replaceWithEmptyString,
110 | body,
111 | ev,
112 | Utils.frame(self)
113 | )
114 | )
115 | }
116 |
117 | }
118 |
119 | }
120 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Cucumber Scala
2 |
3 | [](https://search.maven.org/search?q=g:%22io.cucumber%22%20AND%20a:%22cucumber-scala_2.13%22)
4 | 
5 |
6 | Cucumber Scala is the Scala implementation of [Cucumber](https://cucumber.io/).
7 |
8 | ## Help & Support
9 |
10 | See: https://cucumber.io/support
11 |
12 | ## Compatibility matrix
13 |
14 | Cucumber Scala has a different release cycle than other Cucumber projects that you might use
15 | (like _cucumber-junit-platform-engine_).
16 |
17 | As a rule of thumb, you can assume that latest version of Cucumber Scala targets the latest version
18 | of Cucumber Core projects.
19 |
20 | The table below shows the compatible versions:
21 |
22 | | Cucumber Scala version | Cucumber Core version | Scala versions |
23 | |------------------------|-----------------------|------------------------|
24 | | 8.18+ | 7.x | 2.12, 2.13, 3.3+ |
25 | | 8.13-8.17 | 7.x | 2.12, 2.13, 3.2+ |
26 | | 8.0-8.12 | 7.x | 2.12, 2.13, 3.0+ |
27 | | 7.x | 6.x | 2.11, 2.12, 2.13, 3.0+ |
28 | | 6.x | 6.x | 2.11, 2.12, 2.13 |
29 | | 5.x | 5.x | 2.11, 2.12, 2.13 |
30 | | 4.x | 4.x | 2.11, 2.12, 2.13 |
31 |
32 | ## Getting started
33 |
34 | - [Installation](./docs/install.md)
35 | - Upgrade notes
36 | - [Version 8.x](docs/upgrade_v8.md)
37 | - [Version 7.x](docs/upgrade_v7.md)
38 | - [Version 6.x](docs/upgrade_v6.md)
39 | - [Version 5.x](docs/upgrade_v5.md)
40 | - Documentation
41 | - [Basic usage](docs/usage.md)
42 | - [Step Definitions](docs/step_definitions.md)
43 | - [DataTables](docs/datatables.md)
44 | - [Hooks](docs/hooks.md)
45 | - [Transformers](docs/transformers.md)
46 | - [Default Jackson DataTable Transformer](docs/default_jackson_datatable_transformer.md)
47 | - [Example project](examples/examples-junit5/README.md)
48 | - [Reference documentation for Java](https://docs.cucumber.io/docs/cucumber/)
49 | - [Changelog](CHANGELOG.md)
50 |
51 | ## Contributing
52 |
53 | See [here](CONTRIBUTING.md) for internal documentation and information about contributing.
54 |
55 | ## Backers & Sponsors
56 |
57 | Support us with a monthly donation and help us continue our activities. [Become a backer](https://opencollective.com/cucumber#backer) or [a sponsor](https://opencollective.com/cucumber#sponsor)!
58 |
59 | ## They are using it
60 |
61 | You are using Cucumber Scala? We would love to know about you! Please open a PR to add your project or company to the list below.
62 |
63 | ||||
64 | | :---: | :---: | :---: |
65 | | 
| 
| 
|
66 | | 
| |
67 |
--------------------------------------------------------------------------------
/cucumber-scala/src/main/scala/io/cucumber/scala/ScalaBackend.scala:
--------------------------------------------------------------------------------
1 | package io.cucumber.scala
2 |
3 | import io.cucumber.core.backend._
4 | import io.cucumber.core.resource.{ClasspathScanner, ClasspathSupport}
5 | import io.cucumber.scala.ScalaBackend.isRegularClass
6 |
7 | import java.lang.reflect.Modifier
8 | import java.net.URI
9 | import java.util.function.Supplier
10 | import java.util.{List => JList}
11 | import scala.jdk.CollectionConverters._
12 | import scala.util.{Failure, Try}
13 |
14 | object ScalaBackend {
15 |
16 | /** @return
17 | * true if it's a class, false if it's an object
18 | */
19 | private[scala] def isRegularClass(cls: Class[_]): Try[Boolean] = {
20 | Try {
21 | // Object don't have constructors
22 | cls.getConstructors.headOption
23 | .map(_.getModifiers)
24 | .exists(Modifier.isPublic)
25 | }.recoverWith { case ex: Throwable =>
26 | Failure(new UnknownClassType(cls, ex))
27 | }
28 | }
29 |
30 | }
31 |
32 | class ScalaBackend(
33 | lookup: Lookup,
34 | container: Container,
35 | classLoaderProvider: Supplier[ClassLoader]
36 | ) extends Backend {
37 |
38 | private val classFinder = new ClasspathScanner(classLoaderProvider)
39 |
40 | private var glueAdaptor: GlueAdaptor = _
41 | private[scala] var scalaGlueClasses: Seq[Class[_ <: ScalaDsl]] = Nil
42 |
43 | override def disposeWorld(): Unit = {
44 | // Nothing to do
45 | }
46 |
47 | override def getSnippet(): Snippet = {
48 | new ScalaSnippet()
49 | }
50 |
51 | override def buildWorld(): Unit = {
52 | // Instantiate all the glue classes and load the glue code from them
53 | scalaGlueClasses.foreach { glueClass =>
54 | val glueInstance = Option(lookup.getInstance(glueClass))
55 | glueInstance match {
56 | case Some(glue) =>
57 | glueAdaptor.loadRegistry(glue.registry, scenarioScoped = true)
58 | case None =>
59 | throw new CucumberBackendException(
60 | s"Not able to instantiate class ${glueClass.getName}. Please report this issue to cucumber-scala project."
61 | )
62 | }
63 | }
64 | }
65 |
66 | override def loadGlue(glue: Glue, gluePaths: JList[URI]): Unit = {
67 |
68 | glueAdaptor = new GlueAdaptor(glue)
69 |
70 | val dslClasses = gluePaths.asScala
71 | .filter(gluePath =>
72 | ClasspathSupport.CLASSPATH_SCHEME.equals(gluePath.getScheme)
73 | )
74 | .map(ClasspathSupport.packageName)
75 | .flatMap(basePackageName =>
76 | classFinder
77 | .scanForSubClassesInPackage(basePackageName, classOf[ScalaDsl])
78 | .asScala
79 | )
80 | .filter(glueClass => !glueClass.isInterface)
81 | .distinct
82 |
83 | // Voluntarily throw exception if not able to identify if it's a class
84 | val (clsClasses, objClasses) =
85 | dslClasses.partition(c => isRegularClass(c).get)
86 |
87 | // Retrieve Scala objects (singletons)
88 | val objInstances = objClasses.map { cls =>
89 | val instField = cls.getDeclaredField("MODULE$")
90 | instField.setAccessible(true)
91 | instField.get(null).asInstanceOf[ScalaDsl]
92 | }
93 |
94 | // Regular Scala classes are added to the container, they will be instantiated by the container depending on its logic
95 | // Object are not because by definition they are singletons
96 | clsClasses.foreach { glueClass =>
97 | container.addClass(glueClass)
98 | scalaGlueClasses = scalaGlueClasses :+ glueClass
99 | }
100 |
101 | // For object, we add the definitions here, once for all
102 | objInstances.foreach { glueInstance =>
103 | glueAdaptor.loadRegistry(glueInstance.registry, scenarioScoped = false)
104 | }
105 |
106 | ()
107 | }
108 |
109 | }
110 |
--------------------------------------------------------------------------------
/cucumber-scala/src/main/scala/io/cucumber/scala/DefaultTransformerDsl.scala:
--------------------------------------------------------------------------------
1 | package io.cucumber.scala
2 |
3 | import io.cucumber.scala.Aliases.{
4 | DefaultDataTableCellTransformerBody,
5 | DefaultDataTableEntryTransformerBody,
6 | DefaultParameterTransformerBody
7 | }
8 |
9 | private[scala] trait DefaultTransformerDsl extends BaseScalaDsl { self =>
10 |
11 | /** Register default parameter type transformer.
12 | *
13 | * @param body
14 | * converts `String` argument to an instance of the `Type` argument
15 | */
16 | def DefaultParameterTransformer(
17 | body: DefaultParameterTransformerBody
18 | ): Unit = {
19 | registry.registerDefaultParameterTransformer(
20 | ScalaDefaultParameterTransformerDetails(body, Utils.frame(self))
21 | )
22 | }
23 |
24 | /** Register default data table cell transformer.
25 | *
26 | * @param body
27 | * converts `String` argument to an instance of the `Type` argument
28 | */
29 | def DefaultDataTableCellTransformer(
30 | body: DefaultDataTableCellTransformerBody
31 | ): Unit = {
32 | DefaultDataTableCellTransformer(NO_REPLACEMENT)(body)
33 | }
34 |
35 | /** Register default data table cell transformer with a replacement.
A 36 | * data table can only represent absent and non-empty strings. By replacing a 37 | * known value (for example [empty]) a data table can also represent empty 38 | * strings. * 39 | * 40 | * @param replaceWithEmptyString 41 | * a string that will be replaced with an empty string. 42 | * @param body 43 | * converts `String` argument to an instance of the `Type` argument 44 | */ 45 | def DefaultDataTableCellTransformer( 46 | replaceWithEmptyString: String 47 | )(body: DefaultDataTableCellTransformerBody): Unit = { 48 | DefaultDataTableCellTransformer(Seq(replaceWithEmptyString))(body) 49 | } 50 | 51 | private def DefaultDataTableCellTransformer( 52 | replaceWithEmptyString: Seq[String] 53 | )(body: DefaultDataTableCellTransformerBody): Unit = { 54 | registry.registerDefaultDataTableCellTransformer( 55 | ScalaDefaultDataTableCellTransformerDetails( 56 | replaceWithEmptyString, 57 | body, 58 | Utils.frame(self) 59 | ) 60 | ) 61 | } 62 | 63 | /** Register default data table entry transformer. 64 | * 65 | * @param body 66 | * converts `Map[String,String]` argument to an instance of the `Type` 67 | * argument 68 | */ 69 | def DefaultDataTableEntryTransformer( 70 | body: DefaultDataTableEntryTransformerBody 71 | ): Unit = { 72 | DefaultDataTableEntryTransformer(NO_REPLACEMENT)(body) 73 | } 74 | 75 | /** Register default data table cell transformer with a replacement.
A 76 | * data table can only represent absent and non-empty strings. By replacing a 77 | * known value (for example [empty]) a data table can also represent empty 78 | * strings. 79 | * 80 | * @param replaceWithEmptyString 81 | * a string that will be replaced with an empty string. 82 | * @param body 83 | * converts `Map[String,String]` argument to an instance of the `Type` 84 | * argument 85 | */ 86 | def DefaultDataTableEntryTransformer( 87 | replaceWithEmptyString: String 88 | )(body: DefaultDataTableEntryTransformerBody): Unit = { 89 | DefaultDataTableEntryTransformer(Seq(replaceWithEmptyString))(body) 90 | } 91 | 92 | private def DefaultDataTableEntryTransformer( 93 | replaceWithEmptyString: Seq[String] 94 | )(body: DefaultDataTableEntryTransformerBody): Unit = { 95 | registry.registerDefaultDataTableEntryTransformer( 96 | ScalaDefaultDataTableEntryTransformerDetails( 97 | replaceWithEmptyString, 98 | body, 99 | Utils.frame(self) 100 | ) 101 | ) 102 | } 103 | 104 | } 105 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/resources/datatables/DatatableAsScala.feature: -------------------------------------------------------------------------------- 1 | Feature: As Cucumber Scala, I want to parse DataTables to Scala types properly 2 | 3 | # Scenarios with Strings 4 | 5 | Scenario: As datatable 6 | Given the following table as Scala DataTable 7 | | key1 | key2 | key3 | 8 | | val11 | val12 | val13 | 9 | | val21 | | val23 | 10 | | val31 | val32 | val33 | 11 | 12 | Scenario: As List of Map 13 | Given the following table as Scala List of Map 14 | | key1 | key2 | key3 | 15 | | val11 | val12 | val13 | 16 | | val21 | | val23 | 17 | | val31 | val32 | val33 | 18 | 19 | Scenario: As List of List 20 | Given the following table as Scala List of List 21 | | val11 | val12 | val13 | 22 | | val21 | | val23 | 23 | | val31 | val32 | val33 | 24 | 25 | Scenario: As Map of Map 26 | Given the following table as Scala Map of Map 27 | | | key1 | key2 | key3 | 28 | | row1 | val11 | val12 | val13 | 29 | | row2 | val21 | | val23 | 30 | | row3 | val31 | val32 | val33 | 31 | 32 | Scenario: As Map of List 33 | Given the following table as Scala Map of List 34 | | row1 | val11 | val12 | val13 | 35 | | row2 | val21 | | val23 | 36 | | row3 | val31 | val32 | val33 | 37 | 38 | Scenario: As Map 39 | Given the following table as Scala Map 40 | | row1 | val11 | 41 | | row2 | | 42 | | row3 | val31 | 43 | 44 | Scenario: As List 45 | Given the following table as Scala List 46 | | val11 | 47 | | | 48 | | val31 | 49 | 50 | # Scenarios with other basic types (Int) 51 | 52 | Scenario: As datatable of integers 53 | Given the following table as Scala DataTable of integers 54 | | 1 | 2 | 3 | 55 | | 11 | 12 | 13 | 56 | | 21 | | 23 | 57 | | 31 | 32 | 33 | 58 | 59 | Scenario: As List of Map of integers 60 | Given the following table as Scala List of Map of integers 61 | | 1 | 2 | 3 | 62 | | 11 | 12 | 13 | 63 | | 21 | | 23 | 64 | | 31 | 32 | 33 | 65 | 66 | Scenario: As List of List of integers 67 | Given the following table as Scala List of List of integers 68 | | 11 | 12 | 13 | 69 | | 21 | | 23 | 70 | | 31 | 32 | 33 | 71 | 72 | Scenario: As Map of Map of integers (partial) 73 | Given the following table as Scala Map of Map of integers 74 | | | key1 | key2 | key3 | 75 | | 10 | val11 | val12 | val13 | 76 | | 20 | val21 | | val23 | 77 | | 30 | val31 | val32 | val33 | 78 | 79 | Scenario: As Map of List of integers (partial) 80 | Given the following table as Scala Map of List of integers 81 | | 10 | val11 | val12 | val13 | 82 | | 20 | val21 | | val23 | 83 | | 30 | val31 | val32 | val33 | 84 | 85 | Scenario: As Map of integers 86 | Given the following table as Scala Map of integers 87 | | 10 | 11 | 88 | | 20 | | 89 | | 30 | 31 | 90 | 91 | Scenario: As List of integers 92 | Given the following table as Scala List of integers 93 | | 11 | 94 | | | 95 | | 31 | 96 | 97 | # With custom types using DatatableType 98 | 99 | Scenario: As List of custom type 100 | Given the following table as Scala List of custom type 101 | | key1 | key2 | key3 | 102 | | val11 | val12 | val13 | 103 | | val21 | | val23 | 104 | | val31 | val32 | val33 | 105 | 106 | Scenario: As List of List of custom type 107 | Given the following table as Scala List of List of custom type 108 | | val11 | val12 | val13 | 109 | | val21 | | val23 | 110 | | val31 | val32 | val33 | 111 | 112 | Scenario: As List of Map of custom type 113 | Given the following table as Scala List of Map of custom type 114 | | key1 | key2 | key3 | 115 | | val11 | val12 | val13 | 116 | | val21 | | val23 | 117 | | val31 | val32 | val33 | 118 | 119 | -------------------------------------------------------------------------------- /cucumber-scala/src/main/scala/io/cucumber/scala/Scenario.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import java.net.URI 4 | import java.util 5 | 6 | import io.cucumber.core.backend.{Status, TestCaseState} 7 | 8 | /** Before or After Hooks that declare a parameter of this type will receive an 9 | * instance of this class. It allows writing text and embedding media into 10 | * reports, as well as inspecting results (in an After block).
Note: This 11 | * class is not intended to be used to create reports. To create custom reports 12 | * use the `io.cucumber.plugin.Plugin` class. The plugin system provides a much 13 | * richer access to Cucumbers then hooks after could provide. For an example 14 | * see `io.cucumber.core.plugin.PrettyFormatter`. 15 | */ 16 | class Scenario(val delegate: TestCaseState) { 17 | 18 | /** @return 19 | * tags of this scenario. 20 | */ 21 | def getSourceTagNames: util.Collection[String] = delegate.getSourceTagNames 22 | 23 | /** Returns the current status of this test case.
The test case status is 24 | * calculate as the most severe status of the executed steps in the testcase 25 | * so far. 26 | * 27 | * @return 28 | * the current status of this test case 29 | */ 30 | def getStatus: Status = Status.valueOf(delegate.getStatus.name) 31 | 32 | /** @return 33 | * true if and only if `getStatus` returns "failed" 34 | */ 35 | def isFailed: Boolean = delegate.isFailed 36 | 37 | /** Attach data to the report(s).
{@code // Attach a screenshot. See
38 | * your UI automation tool's docs for // details about how to take a
39 | * screenshot. scenario.attach(pngBytes, "image/png", "Bartholomew and the
40 | * Bytes of the Oobleck"); } To ensure reporting tools can 41 | * understand what the data is a {@code mediaType} must be provided. For 42 | * example: {@code text/plain} , {@code image/png} , 43 | * {@code text/html;charset=utf-8} .
Media types are defined in RFC 7231 Section 45 | * 3.1.1.1. 46 | * 47 | * @param data 48 | * what to attach, for example an image. 49 | * @param mediaType 50 | * what is the data? 51 | * @param name 52 | * attachment name 53 | */ 54 | def attach(data: Array[Byte], mediaType: String, name: String): Unit = { 55 | delegate.attach(data, mediaType, name) 56 | } 57 | 58 | /** Attaches some text based data to the report. 59 | * 60 | * @param data 61 | * what to attach, for example html. 62 | * @param mediaType 63 | * what is the data? 64 | * @param name 65 | * attachment name 66 | * @see 67 | * #attach(byte[], String, String) 68 | */ 69 | def attach(data: String, mediaType: String, name: String): Unit = { 70 | delegate.attach(data, mediaType, name) 71 | } 72 | 73 | /** Outputs some text into the report. 74 | * 75 | * @param text 76 | * what to put in the report. 77 | */ 78 | def log(text: String): Unit = { 79 | delegate.log(text) 80 | } 81 | 82 | /** @return 83 | * the name of the Scenario 84 | */ 85 | def getName: String = delegate.getName 86 | 87 | /** Returns the unique identifier for this scenario.
If this is a Scenario 88 | * from Scenario Outlines this will return the id of the example row in the 89 | * Scenario Outline.
The id is not stable across multiple executions of 90 | * Cucumber but does correlate with ids used in messages output. Use the uri 91 | * + line number to obtain a somewhat stable identifier of a scenario. 92 | * 93 | * @return 94 | * the id of the Scenario. 95 | */ 96 | def getId: String = delegate.getId 97 | 98 | /** @return 99 | * the uri of the Scenario. 100 | */ 101 | def getUri: URI = delegate.getUri 102 | 103 | /** Returns the line in the feature file of the Scenario.
If this is a 104 | * Scenario from Scenario Outlines this will return the line of the example 105 | * row in the Scenario Outline. 106 | * 107 | * @return 108 | * the line in the feature file of the Scenario 109 | */ 110 | def getLine: Integer = delegate.getLine 111 | 112 | } 113 | -------------------------------------------------------------------------------- /cucumber-scala/src/test/scala/io/cucumber/scala/ScalaDslParameterTypeTest.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend._ 4 | import io.cucumber.scala.ScalaDslParameterTypeTest.Point 5 | import org.junit.jupiter.api.Assertions.assertEquals 6 | import org.junit.jupiter.api.Test 7 | 8 | import scala.jdk.CollectionConverters._ 9 | 10 | object ScalaDslParameterTypeTest { 11 | 12 | private case class Point(x: Int, y: Int) 13 | 14 | } 15 | 16 | class ScalaDslParameterTypeTest { 17 | 18 | @Test 19 | def testClassParameterType1(): Unit = { 20 | 21 | class Glue extends ScalaDsl with EN { 22 | ParameterType("string-builder", ".*") { str => 23 | new StringBuilder(str) 24 | } 25 | } 26 | 27 | val glue = new Glue() 28 | 29 | assertClassParameterType( 30 | glue.registry.parameterTypes.head, 31 | "string-builder", 32 | Seq(".*"), 33 | classOf[StringBuilder] 34 | ) 35 | } 36 | 37 | @Test 38 | def testClassParameterType2(): Unit = { 39 | 40 | class Glue extends ScalaDsl with EN { 41 | ParameterType("coordinates", "(.+),(.+)") { (x, y) => 42 | Point(x.toInt, y.toInt) 43 | } 44 | } 45 | 46 | val glue = new Glue() 47 | 48 | assertClassParameterType( 49 | glue.registry.parameterTypes.head, 50 | "coordinates", 51 | Seq("(.+),(.+)"), 52 | classOf[Point] 53 | ) 54 | } 55 | 56 | @Test 57 | def testClassParameterType3(): Unit = { 58 | 59 | class Glue extends ScalaDsl with EN { 60 | ParameterType("ingredients", "(.+), (.+) and (.+)") { (x, y, z) => 61 | s"$x-$y-$z" 62 | } 63 | } 64 | 65 | val glue = new Glue() 66 | 67 | assertClassParameterType( 68 | glue.registry.parameterTypes.head, 69 | "ingredients", 70 | Seq("(.+), (.+) and (.+)"), 71 | classOf[String] 72 | ) 73 | } 74 | 75 | // -------------------- Test on object -------------------- 76 | // Note: for now there is no difference between the two in ScalaDsl but better safe than sorry 77 | 78 | @Test 79 | def testObjectParameterType1(): Unit = { 80 | 81 | object Glue extends ScalaDsl with EN { 82 | ParameterType("string-builder", ".*") { str => 83 | new StringBuilder(str) 84 | } 85 | } 86 | 87 | assertObjectParameterType( 88 | Glue.registry.parameterTypes.head, 89 | "string-builder", 90 | Seq(".*"), 91 | classOf[StringBuilder] 92 | ) 93 | } 94 | 95 | @Test 96 | def testObjectParameterType2(): Unit = { 97 | 98 | object Glue extends ScalaDsl with EN { 99 | ParameterType("coordinates", "(.+),(.+)") { (x, y) => 100 | Point(x.toInt, y.toInt) 101 | } 102 | } 103 | 104 | assertObjectParameterType( 105 | Glue.registry.parameterTypes.head, 106 | "coordinates", 107 | Seq("(.+),(.+)"), 108 | classOf[Point] 109 | ) 110 | } 111 | 112 | @Test 113 | def testObjectParameterType3(): Unit = { 114 | 115 | object Glue extends ScalaDsl with EN { 116 | ParameterType("ingredients", "(.+), (.+) and (.+)") { (x, y, z) => 117 | s"$x-$y-$z" 118 | } 119 | } 120 | 121 | assertObjectParameterType( 122 | Glue.registry.parameterTypes.head, 123 | "ingredients", 124 | Seq("(.+), (.+) and (.+)"), 125 | classOf[String] 126 | ) 127 | } 128 | 129 | private def assertClassParameterType( 130 | details: ScalaParameterTypeDetails[_], 131 | name: String, 132 | regexps: Seq[String], 133 | expectedType: Class[_] 134 | ): Unit = { 135 | assertParameterType( 136 | ScalaParameterTypeDefinition(details, true), 137 | name, 138 | regexps, 139 | expectedType 140 | ) 141 | } 142 | 143 | private def assertObjectParameterType( 144 | details: ScalaParameterTypeDetails[_], 145 | name: String, 146 | regexps: Seq[String], 147 | expectedType: Class[_] 148 | ): Unit = { 149 | assertParameterType( 150 | ScalaParameterTypeDefinition(details, false), 151 | name, 152 | regexps, 153 | expectedType 154 | ) 155 | } 156 | 157 | private def assertParameterType( 158 | parameterTypeDef: ParameterTypeDefinition, 159 | name: String, 160 | regexps: Seq[String], 161 | expectedType: Class[_] 162 | ): Unit = { 163 | val parameterType = parameterTypeDef.parameterType() 164 | 165 | assertEquals(name, parameterType.getName) 166 | assertEquals(regexps, parameterType.getRegexps.asScala) 167 | assertEquals(expectedType, parameterType.getType) 168 | 169 | // Cannot assert more because transform method is private 170 | } 171 | 172 | } 173 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/scala/parametertypes/ParameterTypesSteps.scala: -------------------------------------------------------------------------------- 1 | package parametertypes 2 | 3 | import java.util.{List => JavaList} 4 | 5 | import io.cucumber.datatable.DataTable 6 | import io.cucumber.scala.{EN, ScalaDsl} 7 | 8 | import scala.jdk.CollectionConverters._ 9 | 10 | case class Point(x: Int, y: Int) 11 | 12 | class ParameterTypesSteps extends ScalaDsl with EN { 13 | 14 | ParameterType("string-builder", "\"(.*)\"") { (str) => 15 | new StringBuilder(str) 16 | } 17 | 18 | ParameterType("coordinates", "(.+),(.+)") { (x, y) => 19 | Point(x.toInt, y.toInt) 20 | } 21 | 22 | ParameterType("ingredients", "(.+), (.+) and (.+)") { (x, y, z) => 23 | s"-$x-$y-$z-" 24 | } 25 | 26 | ParameterType("optionalint", """\s?(\d*)\s?""") { (str) => 27 | Option(str).filter(_.nonEmpty).map(_.toInt) 28 | } 29 | 30 | ParameterType("optionalstring", "(.*)") { (str) => 31 | Option(str).filter(_.nonEmpty) 32 | } 33 | 34 | DefaultParameterTransformer { (fromValue, toValueType) => 35 | new StringBuilder().append(fromValue).append('-').append(toValueType) 36 | } 37 | 38 | DefaultDataTableCellTransformer("[empty]") { 39 | (fromValue: String, toValueType) => 40 | new StringBuilder().append(fromValue).append("-").append(toValueType) 41 | } 42 | 43 | DefaultDataTableEntryTransformer("[empty]") { 44 | (fromValue: Map[String, String], toValueType) => 45 | new StringBuilder().append(fromValue).append("-").append(toValueType) 46 | } 47 | 48 | Given("{string-builder} parameter, defined by lambda") { 49 | (builder: StringBuilder) => 50 | assert(builder.toString() == "string builder") 51 | } 52 | 53 | Given("balloon coordinates {coordinates}, defined by lambda") { 54 | (coordinates: Point) => 55 | assert(coordinates == Point(123, 456)) 56 | } 57 | 58 | Given("kebab made from {ingredients}, defined by lambda") { 59 | (ingredients: String) => 60 | assert(ingredients == "-mushroom-meat-veg-") 61 | } 62 | 63 | Given("kebab made from anonymous {}, defined by lambda") { 64 | (ingredients: StringBuilder) => 65 | assert( 66 | ingredients 67 | .toString() == "meat-class scala.collection.mutable.StringBuilder" 68 | ) 69 | } 70 | 71 | Given("default data table cells, defined by lambda") { 72 | (dataTable: DataTable) => 73 | val table = dataTable 74 | .asLists[StringBuilder](classOf[StringBuilder]) 75 | .asScala 76 | .map(_.asScala) 77 | assert( 78 | table(0)(0) 79 | .toString() == "Kebab-class scala.collection.mutable.StringBuilder" 80 | ) 81 | assert( 82 | table(1)(0) 83 | .toString() == "-class scala.collection.mutable.StringBuilder" 84 | ) 85 | } 86 | 87 | Given("default data table cells, defined by lambda, as rows") { 88 | (cells: JavaList[JavaList[StringBuilder]]) => 89 | val table = cells.asScala.map(_.asScala) 90 | assert( 91 | table(0)(0) 92 | .toString() == "Kebab-class scala.collection.mutable.StringBuilder" 93 | ) 94 | assert( 95 | table(1)(0) 96 | .toString() == "-class scala.collection.mutable.StringBuilder" 97 | ) 98 | } 99 | 100 | Given("default data table entries, defined by lambda") { 101 | (dataTable: DataTable) => 102 | val table = 103 | dataTable.asList[StringBuilder](classOf[StringBuilder]).asScala 104 | assert( 105 | table(0).toString() == "Map(dinner -> Kebab)-class scala.collection.mutable.StringBuilder" 106 | ) 107 | assert( 108 | table(1).toString() == "Map(dinner -> )-class scala.collection.mutable.StringBuilder" 109 | ) 110 | } 111 | 112 | Given("default data table entries, defined by lambda, as rows") { 113 | (rows: JavaList[StringBuilder]) => 114 | val table = rows.asScala 115 | assert( 116 | table(0).toString() == "Map(dinner -> Kebab)-class scala.collection.mutable.StringBuilder" 117 | ) 118 | assert( 119 | table(1).toString() == "Map(dinner -> )-class scala.collection.mutable.StringBuilder" 120 | ) 121 | } 122 | 123 | Given("""an optional string parameter value "{optionalstring}" undefined""") { 124 | (value: Option[String]) => 125 | assert(value.isEmpty) 126 | } 127 | 128 | Given("""an optional string parameter value "{optionalstring}" defined""") { 129 | (value: Option[String]) => 130 | assert(value.contains("toto")) 131 | } 132 | 133 | Given("""an optional int parameter value{optionalint}undefined""") { 134 | (value: Option[Int]) => 135 | assert(value.isEmpty) 136 | } 137 | 138 | Given("""an optional int parameter value{optionalint}defined""") { 139 | (value: Option[Int]) => 140 | assert(value.contains(5)) 141 | } 142 | 143 | } 144 | -------------------------------------------------------------------------------- /cucumber-scala/src/test/scala/io/cucumber/scala/ScalaDslDefaultDataTableEntryTransformerTest.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend._ 4 | import org.junit.jupiter.api.Assertions.assertEquals 5 | import org.junit.jupiter.api.Test 6 | 7 | import scala.jdk.CollectionConverters._ 8 | 9 | class ScalaDslDefaultDataTableEntryTransformerTest { 10 | 11 | @Test 12 | def testClassDefaultDataTableEntryTransformer(): Unit = { 13 | 14 | class Glue extends ScalaDsl with EN { 15 | DefaultDataTableEntryTransformer { 16 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 17 | new StringBuilder().append(fromValue).append("-").append(toValueType) 18 | } 19 | } 20 | 21 | val glue = new Glue() 22 | 23 | assertClassDefaultDataTableEntryTransformer( 24 | glue.registry.defaultDataTableEntryTransformers.head, 25 | Map("a" -> "b", "c" -> "d"), 26 | classOf[StringBuilder], 27 | "Map(a -> b, c -> d)-class scala.collection.mutable.StringBuilder" 28 | ) 29 | } 30 | 31 | @Test 32 | def testClassDefaultDataTableEntryTransformerWithEmpty(): Unit = { 33 | 34 | class Glue extends ScalaDsl with EN { 35 | DefaultDataTableEntryTransformer("[empty]") { 36 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 37 | new StringBuilder().append(fromValue).append("-").append(toValueType) 38 | } 39 | } 40 | 41 | val glue = new Glue() 42 | 43 | assertClassDefaultDataTableEntryTransformer( 44 | glue.registry.defaultDataTableEntryTransformers.head, 45 | Map("a" -> "b", "c" -> "[empty]"), 46 | classOf[StringBuilder], 47 | "Map(a -> b, c -> )-class scala.collection.mutable.StringBuilder" 48 | ) 49 | } 50 | 51 | // -------------------- Test on object -------------------- 52 | // Note: for now there is no difference between the two in ScalaDsl but better safe than sorry 53 | 54 | @Test 55 | def testObjectDefaultDataTableEntryTransformer(): Unit = { 56 | 57 | object Glue extends ScalaDsl with EN { 58 | DefaultDataTableEntryTransformer { 59 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 60 | new StringBuilder().append(fromValue).append("-").append(toValueType) 61 | } 62 | } 63 | 64 | assertObjectDefaultDataTableEntryTransformer( 65 | Glue.registry.defaultDataTableEntryTransformers.head, 66 | Map("a" -> "b", "c" -> "d"), 67 | classOf[StringBuilder], 68 | "Map(a -> b, c -> d)-class scala.collection.mutable.StringBuilder" 69 | ) 70 | } 71 | 72 | @Test 73 | def testObjectDefaultDataTableEntryTransformerWithEmpty(): Unit = { 74 | 75 | object Glue extends ScalaDsl with EN { 76 | DefaultDataTableEntryTransformer("[empty]") { 77 | (fromValue: Map[String, String], toValueType: java.lang.reflect.Type) => 78 | new StringBuilder().append(fromValue).append("-").append(toValueType) 79 | } 80 | } 81 | 82 | assertObjectDefaultDataTableEntryTransformer( 83 | Glue.registry.defaultDataTableEntryTransformers.head, 84 | Map("a" -> "b", "c" -> "[empty]"), 85 | classOf[StringBuilder], 86 | "Map(a -> b, c -> )-class scala.collection.mutable.StringBuilder" 87 | ) 88 | } 89 | 90 | private def assertClassDefaultDataTableEntryTransformer( 91 | details: ScalaDefaultDataTableEntryTransformerDetails, 92 | input: Map[String, String], 93 | toType: java.lang.reflect.Type, 94 | expectedOutput: AnyRef 95 | ): Unit = { 96 | assertDefaultDataTableEntryTransformer( 97 | ScalaDefaultDataTableEntryTransformerDefinition(details, true), 98 | input, 99 | toType, 100 | expectedOutput 101 | ) 102 | } 103 | 104 | private def assertObjectDefaultDataTableEntryTransformer( 105 | details: ScalaDefaultDataTableEntryTransformerDetails, 106 | input: Map[String, String], 107 | toType: java.lang.reflect.Type, 108 | expectedOutput: AnyRef 109 | ): Unit = { 110 | assertDefaultDataTableEntryTransformer( 111 | ScalaDefaultDataTableEntryTransformerDefinition(details, false), 112 | input, 113 | toType, 114 | expectedOutput 115 | ) 116 | } 117 | 118 | private def assertDefaultDataTableEntryTransformer( 119 | typeDef: DefaultDataTableEntryTransformerDefinition, 120 | input: Map[String, String], 121 | toType: java.lang.reflect.Type, 122 | expectedOutput: AnyRef 123 | ): Unit = { 124 | assertEquals( 125 | toType, 126 | typeDef 127 | .tableEntryByTypeTransformer() 128 | .transform(input.asJava, toType, null) 129 | .getClass 130 | ) 131 | assertEquals( 132 | expectedOutput.toString, 133 | typeDef 134 | .tableEntryByTypeTransformer() 135 | .transform(input.asJava, toType, null) 136 | .toString 137 | ) 138 | } 139 | 140 | } 141 | -------------------------------------------------------------------------------- /cucumber-scala/src/test/scala/io/cucumber/scala/ScalaDslDefaultDataTableCellTransformerTest.scala: -------------------------------------------------------------------------------- 1 | package io.cucumber.scala 2 | 3 | import io.cucumber.core.backend._ 4 | import org.junit.jupiter.api.Assertions.assertEquals 5 | import org.junit.jupiter.api.Test 6 | 7 | class ScalaDslDefaultDataTableCellTransformerTest { 8 | 9 | @Test 10 | def testClassDefaultDataTableCellTransformer(): Unit = { 11 | 12 | class Glue extends ScalaDsl with EN { 13 | DefaultDataTableCellTransformer { 14 | (fromValue: String, toValueType: java.lang.reflect.Type) => 15 | new StringBuilder().append(fromValue).append("-").append(toValueType) 16 | } 17 | } 18 | 19 | val glue = new Glue() 20 | 21 | assertClassDefaultDataTableCellTransformer( 22 | glue.registry.defaultDataTableCellTransformers.head, 23 | "meat", 24 | classOf[StringBuilder], 25 | "meat-class scala.collection.mutable.StringBuilder" 26 | ) 27 | } 28 | 29 | @Test 30 | def testClassDefaultDataTableCellTransformerWithEmpty(): Unit = { 31 | 32 | class Glue extends ScalaDsl with EN { 33 | DefaultDataTableCellTransformer("[empty]") { 34 | (fromValue: String, toValueType: java.lang.reflect.Type) => 35 | new StringBuilder().append(fromValue).append("-").append(toValueType) 36 | } 37 | } 38 | 39 | val glue = new Glue() 40 | 41 | assertClassDefaultDataTableCellTransformer( 42 | glue.registry.defaultDataTableCellTransformers.head, 43 | "meat", 44 | classOf[StringBuilder], 45 | "meat-class scala.collection.mutable.StringBuilder" 46 | ) 47 | assertClassDefaultDataTableCellTransformer( 48 | glue.registry.defaultDataTableCellTransformers.head, 49 | "[empty]", 50 | classOf[StringBuilder], 51 | "-class scala.collection.mutable.StringBuilder" 52 | ) 53 | } 54 | 55 | // -------------------- Test on object -------------------- 56 | // Note: for now there is no difference between the two in ScalaDsl but better safe than sorry 57 | 58 | @Test 59 | def testObjectDefaultDataTableCellTransformer(): Unit = { 60 | 61 | object Glue extends ScalaDsl with EN { 62 | DefaultDataTableCellTransformer { 63 | (fromValue: String, toValueType: java.lang.reflect.Type) => 64 | new StringBuilder().append(fromValue).append("-").append(toValueType) 65 | } 66 | } 67 | 68 | assertObjectDefaultDataTableCellTransformer( 69 | Glue.registry.defaultDataTableCellTransformers.head, 70 | "meat", 71 | classOf[StringBuilder], 72 | "meat-class scala.collection.mutable.StringBuilder" 73 | ) 74 | } 75 | 76 | @Test 77 | def testObjectDefaultDataTableCellTransformerWithEmpty(): Unit = { 78 | 79 | object Glue extends ScalaDsl with EN { 80 | DefaultDataTableCellTransformer("[empty]") { 81 | (fromValue: String, toValueType: java.lang.reflect.Type) => 82 | new StringBuilder().append(fromValue).append("-").append(toValueType) 83 | } 84 | } 85 | 86 | assertObjectDefaultDataTableCellTransformer( 87 | Glue.registry.defaultDataTableCellTransformers.head, 88 | "meat", 89 | classOf[StringBuilder], 90 | "meat-class scala.collection.mutable.StringBuilder" 91 | ) 92 | assertObjectDefaultDataTableCellTransformer( 93 | Glue.registry.defaultDataTableCellTransformers.head, 94 | "[empty]", 95 | classOf[StringBuilder], 96 | "-class scala.collection.mutable.StringBuilder" 97 | ) 98 | } 99 | 100 | private def assertClassDefaultDataTableCellTransformer( 101 | details: ScalaDefaultDataTableCellTransformerDetails, 102 | input: String, 103 | toType: java.lang.reflect.Type, 104 | expectedOutput: AnyRef 105 | ): Unit = { 106 | assertDefaultDataTableCellTransformer( 107 | ScalaDefaultDataTableCellTransformerDefinition(details, true), 108 | input, 109 | toType, 110 | expectedOutput 111 | ) 112 | } 113 | 114 | private def assertObjectDefaultDataTableCellTransformer( 115 | details: ScalaDefaultDataTableCellTransformerDetails, 116 | input: String, 117 | toType: java.lang.reflect.Type, 118 | expectedOutput: AnyRef 119 | ): Unit = { 120 | assertDefaultDataTableCellTransformer( 121 | ScalaDefaultDataTableCellTransformerDefinition(details, false), 122 | input, 123 | toType, 124 | expectedOutput 125 | ) 126 | } 127 | 128 | private def assertDefaultDataTableCellTransformer( 129 | typeDef: DefaultDataTableCellTransformerDefinition, 130 | input: String, 131 | toType: java.lang.reflect.Type, 132 | expectedOutput: AnyRef 133 | ): Unit = { 134 | assertEquals( 135 | toType, 136 | typeDef.tableCellByTypeTransformer().transform(input, toType).getClass 137 | ) 138 | assertEquals( 139 | expectedOutput.toString, 140 | typeDef.tableCellByTypeTransformer().transform(input, toType).toString 141 | ) 142 | } 143 | 144 | } 145 | -------------------------------------------------------------------------------- /docs/usage.md: -------------------------------------------------------------------------------- 1 | # Basic Usage 2 | 3 | ## Glue code 4 | 5 | To use Cucumber Scala, all your glue code (steps or hooks) has to be defined in **classes** extending both the `ScalaDsl` trait and a language trait. 6 | 7 | For instance, to use the English flavour: 8 | ```scala 9 | import io.cucumber.scala.{EN, ScalaDsl} 10 | 11 | class MyGlueClass extends ScalaDsl with EN { 12 | 13 | // Here some steps or hooks definitions 14 | 15 | Given("""I have {int} cucumbers in my belly"""){ (cucumberCount: Int) => 16 | // Do something 17 | } 18 | 19 | } 20 | ``` 21 | 22 | Cucumber will automatically load all the glue code defined in classes available in the "glue path" (more details in the Run documentation) inheriting `ScalaDsl`. 23 | 24 | ### Using traits 25 | 26 | You can define glue code in **traits** as well and have a **class** extending the traits you need. 27 | 28 | For instance, you can do things like this: 29 | ```scala 30 | import io.cucumber.scala.{EN, ScalaDsl} 31 | 32 | trait StepsForThis extends ScalaDsl with EN { 33 | // Glue code 34 | } 35 | 36 | trait StepsForThat extends ScalaDsl with EN { 37 | // Glue code 38 | } 39 | 40 | class MyStepDefinitions extends StepsForThis with StepsForThat { 41 | } 42 | ``` 43 | 44 | **Note:** using traits can help you split your tests in different groups and provide some steps only to some tests. 45 | 46 | ### Using objects 47 | 48 | You can also define glue code in **objects**. 49 | 50 | Be aware that by definition objects are singleton and if your glue code is stateful you will probably have "state conflicts" 51 | between your scenarios if you use shared variables from objects. 52 | 53 | ### Using dependency-injection 54 | 55 | Starting with cucumber-scala 8.4, it is possible to use DI modules in order to share state between steps. 56 | 57 | You can for instance have the following definition: 58 | ```scala 59 | import io.cucumber.scala.{EN, ScalaDsl} 60 | 61 | class A extends ScalaDsl with EN { 62 | 63 | var input: String = _ 64 | 65 | Given("""a step defined in class A with arg {string}""") { (arg: String) => 66 | input = arg 67 | } 68 | 69 | } 70 | 71 | class B(a: A) extends ScalaDsl with EN { 72 | 73 | When("""a step defined in class B uses A""") { () => 74 | // Do something with a.input 75 | println(a.input) 76 | } 77 | 78 | } 79 | ``` 80 | 81 | To make it work, you only need a Cucumber DI module to be added as a dependency of your project 82 | (like `cucumber-picocontainer`, or `cucumber-guice`, or any other provided by Cucumber). 83 | 84 | ## Running Cucumber tests 85 | 86 | See also the Running Cucumber for Java [documentation](https://docs.cucumber.io/docs/cucumber/api/#running-cucumber). 87 | 88 | ### JUnit 5 89 | 90 | Add the `cucumber-junit-platform-engine` dependency to your project. 91 | 92 | Then create a runner class like this: 93 | ```scala 94 | import io.cucumber.junit.platform.engine.Constants 95 | import org.junit.platform.suite.api._ 96 | 97 | @Suite 98 | @IncludeEngines(Array("cucumber")) // Mandatory to load Cucumber engine 99 | @SelectPackages(Array("cucumber.examples.scalacalculator")) // Load all *.feature files in the given package 100 | // @SelectClasspathResource("cucumber/examples/scalacalculator/basic_arithmetic.feature") // Or, load a single feature file 101 | @ConfigurationParameter( // Set packages in which to look for glue code (classes containing steps definition) 102 | key = Constants.GLUE_PROPERTY_NAME, 103 | value = "cucumber.examples.scalacalculator" 104 | ) 105 | @ConfigurationParameter(key = Constants.PLUGIN_PROPERTY_NAME, value = "pretty") 106 | class RunCucumberTest 107 | ``` 108 | 109 | Some properties can also be applied for all suites by adding them in the `junit-platform.properties` file (must be in the test resources classpath, 110 | usually `src/test/resources`). For instance: 111 | ```properties 112 | cucumber.plugin=pretty 113 | ``` 114 | 115 | #### Additional settings if using SBT 116 | 117 | You need to enable the support of JUnit 5 in SBT: 118 | ```scala 119 | // plugins.sbt 120 | // version 0.15.1+ is important, earlier versions have a bug preventing properly running Cucumber tests (https://github.com/sbt/sbt-jupiter-interface/issues/142) 121 | addSbtPlugin("com.github.sbt.junit" % "sbt-jupiter-interface" % "0.15.1") 122 | // build.sbt 123 | libraryDependencies += "com.github.sbt.junit" % "jupiter-interface" % JupiterKeys.jupiterVersion.value % Test 124 | ``` 125 | 126 | ### JUnit 4 127 | 128 | Add the `cucumber-junit` dependency to your project. 129 | 130 | Then create a runner class like this: 131 | ```scala 132 | import io.cucumber.junit.{Cucumber, CucumberOptions} 133 | import org.junit.runner.RunWith 134 | 135 | @RunWith(classOf[Cucumber]) 136 | @CucumberOptions() 137 | class RunCucumberTest 138 | ``` 139 | 140 | You can define several options via the `@CucumberOptions` parameters like: 141 | - the "glue path" (default to current package): packages in which to look for glue code 142 | - the "features path" (default to current folder): folder in which to look for features file 143 | - some plugins 144 | -------------------------------------------------------------------------------- /project/ScalacOptions.scala: -------------------------------------------------------------------------------- 1 | object ScalacOptions { 2 | 3 | val scalacOptions3 = Seq( 4 | "-encoding", 5 | "utf-8", // Specify character encoding used by source files. 6 | "-deprecation", // Emit warning and location for usages of deprecated APIs. 7 | "-explain", // Explain type errors in more detail. 8 | // "-explaintypes", // Explain type errors in more detail. 9 | "-feature", // Emit warning and location for usages of features that should be imported explicitly. 10 | "-language:existentials", // Existential types (besides wildcard types) can be written and inferred 11 | "-language:experimental.macros", // Allow macro definition (besides implementation and application) 12 | "-language:higherKinds", // Allow higher-kinded types 13 | "-language:implicitConversions", // Allow definition of implicit functions called views 14 | "-unchecked", // Enable additional warnings where generated code depends on assumptions. 15 | "-Wvalue-discard", // Warn when non-Unit expression results are unused. 16 | "-Wunused:implicits", // Warn if an implicit parameter is unused. 17 | "-Wunused:explicits", 18 | "-Wunused:imports", // Warn if an import selector is not referenced. 19 | "-Wunused:locals", // Warn if a local definition is unused. 20 | "-Wunused:params", // Warn if a value parameter is unused. 21 | "-Wunused:privates", // Warn if a private member is unused. 22 | "-Ykind-projector", 23 | "-Ysafe-init", 24 | "-Xfatal-warnings" // Fail the compilation if there are any warnings. 25 | ) 26 | 27 | // Source: https://nathankleyn.com/2019/05/13/recommended-scalac-flags-for-2-13/ 28 | val scalacOptions213 = Seq( 29 | "-deprecation", // Emit warning and location for usages of deprecated APIs. 30 | "-explaintypes", // Explain type errors in more detail. 31 | "-feature", // Emit warning and location for usages of features that should be imported explicitly. 32 | "-language:existentials", // Existential types (besides wildcard types) can be written and inferred 33 | "-language:experimental.macros", // Allow macro definition (besides implementation and application) 34 | "-language:higherKinds", // Allow higher-kinded types 35 | "-language:implicitConversions", // Allow definition of implicit functions called views 36 | "-unchecked", // Enable additional warnings where generated code depends on assumptions. 37 | "-Xcheckinit", // Wrap field accessors to throw an exception on uninitialized access. 38 | "-Xfatal-warnings", // Fail the compilation if there are any warnings. 39 | "-Xlint:adapted-args", // Warn if an argument list is modified to match the receiver. 40 | "-Xlint:constant", // Evaluation of a constant arithmetic expression results in an error. 41 | "-Xlint:delayedinit-select", // Selecting member of DelayedInit. 42 | "-Xlint:doc-detached", // A Scaladoc comment appears to be detached from its element. 43 | "-Xlint:inaccessible", // Warn about inaccessible types in method signatures. 44 | "-Xlint:infer-any", // Warn when a type argument is inferred to be `Any`. 45 | "-Xlint:missing-interpolator", // A string literal appears to be missing an interpolator id. 46 | // "-Xlint:nullary-override", // Warn when non-nullary `def f()' overrides nullary `def f'. 47 | "-Xlint:nullary-unit", // Warn when nullary methods return Unit. 48 | "-Xlint:option-implicit", // Option.apply used implicit view. 49 | "-Xlint:package-object-classes", // Class or object defined in package object. 50 | "-Xlint:poly-implicit-overload", // Parameterized overloaded implicit methods are not visible as view bounds. 51 | "-Xlint:private-shadow", // A private field (or class parameter) shadows a superclass field. 52 | "-Xlint:stars-align", // Pattern sequence wildcard must align with sequence component. 53 | "-Xlint:type-parameter-shadow", // A local type parameter shadows a type already in scope. 54 | "-Ywarn-dead-code", // Warn when dead code is identified. 55 | "-Ywarn-extra-implicit", // Warn when more than one implicit parameter section is defined. 56 | "-Ywarn-numeric-widen", // Warn when numerics are widened. 57 | "-Ywarn-unused:implicits", // Warn if an implicit parameter is unused. 58 | "-Ywarn-unused:imports", // Warn if an import selector is not referenced. 59 | "-Ywarn-unused:locals", // Warn if a local definition is unused. 60 | "-Ywarn-unused:params", // Warn if a value parameter is unused. 61 | "-Ywarn-unused:patvars", // Warn if a variable bound in a pattern is unused. 62 | "-Ywarn-unused:privates", // Warn if a private member is unused. 63 | "-Ywarn-value-discard", // Warn when non-Unit expression results are unused. 64 | "-Ybackend-parallelism", 65 | "8", // Enable paralellisation — change to desired number! 66 | "-Ycache-plugin-class-loader:last-modified", // Enables caching of classloaders for compiler plugins 67 | "-Ycache-macro-class-loader:last-modified" // and macro definitions. This can lead to performance improvements. 68 | ) 69 | 70 | val scalacOptions212 = Seq( 71 | "-deprecation", // Emit warning and location for usages of deprecated APIs. 72 | "-encoding", 73 | "utf-8", // Specify character encoding used by source files. 74 | "-feature", // Emit warning and location for usages of features that should be imported explicitly. 75 | "-language:implicitConversions", // Allow definition of implicit functions called views 76 | "-language:higherKinds" // Allow higher-kinded types 77 | ) 78 | 79 | } 80 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/resources/datatables/DataTableType.feature: -------------------------------------------------------------------------------- 1 | Feature: As Cucumber Scala, I want to parse properly Datatables and use types and transformers 2 | 3 | Scenario: Using a DataTableType for Entry - JList 4 | Given the following authors as entries 5 | | name | surname | famousBook | 6 | | Alan | Alou | The Lion King | 7 | | Robert | Bob | Le Petit Prince | 8 | When I concat their names 9 | Then I get "Alan,Robert" 10 | 11 | Scenario: Using a DataTableType for Entry with empty values - JList 12 | Given the following authors as entries with empty 13 | | name | surname | famousBook | 14 | | Alan | Alou | The Lion King | 15 | | [empty] | Bob | Le Petit Prince | 16 | When I concat their names 17 | Then I get "Alan," 18 | 19 | Scenario: Using a DataTableType for Entry with empty values - DataTable 20 | Given the following authors as entries with empty, as table 21 | | name | surname | famousBook | 22 | | Alan | Alou | The Lion King | 23 | | [empty] | Bob | Le Petit Prince | 24 | When I concat their names 25 | Then I get "Alan," 26 | 27 | Scenario: Using a DataTableType for Entry with Option values - DataTable 28 | Given the following authors as entries with null, as table 29 | | name | surname | famousBook | 30 | | [empty] | Alou | The Lion King | 31 | | | Bob | Le Petit Prince | 32 | When I concat their names 33 | Then I get ",NoName" 34 | 35 | Scenario: Using a DataTableType for Row - Jlist 36 | Given the following authors as rows 37 | | Alan | Alou | The Lion King | 38 | | Robert | Bob | Le Petit Prince | 39 | When I concat their names 40 | Then I get "Alan,Robert" 41 | 42 | Scenario: Using a DataTableType for Row, with empty values - Jlist 43 | Given the following authors as rows with empty 44 | | Alan | Alou | The Lion King | 45 | | [empty] | Bob | Le Petit Prince | 46 | When I concat their names 47 | Then I get "Alan," 48 | 49 | Scenario: Using a DataTableType for Row, with empty values - DataTable 50 | Given the following authors as rows with empty, as table 51 | | Alan | Alou | The Lion King | 52 | | [empty] | Bob | Le Petit Prince | 53 | When I concat their names 54 | Then I get "Alan," 55 | 56 | Scenario: Using a DataTableType for Row, with Option values - DataTable 57 | Given the following authors as rows with null, as table 58 | | | Alou | The Lion King | 59 | | [empty] | Bob | Le Petit Prince | 60 | When I concat their names 61 | Then I get "NoName," 62 | 63 | Scenario: Using a DataTableType for Cell - Jlist[Jlist] 64 | Given the following authors as cells 65 | | Alan | Alou | The Lion King | 66 | | Robert | Bob | Le Petit Prince | 67 | When I concat their names 68 | Then I get "Alan,Robert" 69 | 70 | Scenario: Using a DataTableType for Cell, with empty values - Jlist[Jlist] 71 | Given the following authors as cells with empty 72 | | Alan | Alou | The Lion King | 73 | | [empty] | Bob | Le Petit Prince | 74 | When I concat their names 75 | Then I get "Alan," 76 | 77 | Scenario: Using a DataTableType for Cell, with empty values - JList[JMap] 78 | Given the following authors as cells with empty, as map 79 | | name | surname | famousBook | 80 | | Alan | Alou | The Lion King | 81 | | [empty] | Bob | Le Petit Prince | 82 | When I concat their names 83 | Then I get "Alan," 84 | 85 | Scenario: Using a DataTableType for Cell, with empty values - DataTable -> asMaps 86 | Given the following authors as cells with empty, as table as map 87 | | name | surname | famousBook | 88 | | Alan | Alou | The Lion King | 89 | | [empty] | Bob | Le Petit Prince | 90 | When I concat their names 91 | Then I get "Alan," 92 | 93 | Scenario: Using a DataTableType for Cell, with Option values - DataTable -> asMaps 94 | Given the following authors as cells with null, as table as map 95 | | name | surname | famousBook | 96 | | | Alou | The Lion King | 97 | | [empty] | Bob | Le Petit Prince | 98 | When I concat their names 99 | Then I get "NoName," 100 | 101 | Scenario: Using a DataTableType for Cell, with empty values - DataTable -> asLists 102 | Given the following authors as cells with empty, as table as list 103 | | Alan | Alou | The Lion King | 104 | | [empty] | Bob | Le Petit Prince | 105 | When I concat their names 106 | Then I get "Alan," 107 | 108 | Scenario: Using a DataTableType for Cell, with Option values - DataTable -> asLists 109 | Given the following authors as cells with null, as table as list 110 | | | Alou | The Lion King | 111 | | [empty] | Bob | Le Petit Prince | 112 | When I concat their names 113 | Then I get "NoName," 114 | 115 | Scenario: Using a DataTableType for DataTable - DataTable 116 | Given the following authors as table 117 | | name | surname | famousBook | 118 | | Alan | Alou | The Lion King | 119 | | Robert | Bob | Le Petit Prince | 120 | When I concat their names 121 | Then I get "Alan,Robert" 122 | 123 | Scenario: Using a DataTableType for DataTable with empty values - DataTable 124 | Given the following authors as table with empty 125 | | name | surname | famousBook | 126 | | Alan | Alou | The Lion King | 127 | | [empty] | Bob | Le Petit Prince | 128 | When I concat their names 129 | Then I get "Alan," 130 | -------------------------------------------------------------------------------- /integration-tests/common/src/test/scala/cukes/StepDefs.scala: -------------------------------------------------------------------------------- 1 | package cukes 2 | 3 | import cukes.model.{Cukes, Person, Snake} 4 | import java.util.{List => JList, Map => JMap} 5 | 6 | import io.cucumber.datatable.DataTable 7 | import io.cucumber.scala.{EN, ScalaDsl} 8 | import org.junit.jupiter.api.Assertions.assertEquals 9 | 10 | import scala.annotation.nowarn 11 | import scala.jdk.CollectionConverters._ 12 | 13 | /** Test step definitions to exercise Scala cucumber 14 | */ 15 | @nowarn 16 | class CukesStepDefinitions extends ScalaDsl with EN { 17 | 18 | var calorieCount = 0.0 19 | var intBelly: Int = 0 20 | var longBelly: Long = 0L 21 | var stringBelly: String = "" 22 | var doubleBelly: Double = 0.0 23 | var floatBelly: Float = 0.0f 24 | var shortBelly: Short = 0.toShort 25 | var byteBelly: Byte = 0.toByte 26 | var bigDecimalBelly: BigDecimal = BigDecimal(0) 27 | var bigIntBelly: BigInt = BigInt(0) 28 | var charBelly: Char = 'A' 29 | var boolBelly: Boolean = false 30 | var snake: Snake = null 31 | var person: Person = null 32 | var cukes: JList[Cukes] = null 33 | var gin: Int = 13 34 | var vermouth: Int = 42 35 | var maritinis: Int = 0 36 | 37 | Given("""I have {} {string} in my belly""") { (howMany: Int, what: String) => 38 | } 39 | 40 | Given("""^I have the following foods :$""") { (table: DataTable) => 41 | val maps: JList[JMap[String, String]] = 42 | table.asMaps(classOf[String], classOf[String]) 43 | calorieCount = 44 | maps.asScala.map(_.get("CALORIES")).map(_.toDouble).fold(0.0)(_ + _) 45 | } 46 | And("""have eaten {double} calories today""") { (calories: Double) => 47 | assertEquals(calories, calorieCount, 0.0) 48 | } 49 | 50 | Given("""I have eaten an int {int}""") { (arg0: Int) => 51 | intBelly = arg0 52 | } 53 | Then("""^I should have one hundred in my belly$""") { () => 54 | assertEquals(100, intBelly) 55 | } 56 | 57 | Given("""I have eaten a long {long}""") { (arg0: Long) => 58 | longBelly = arg0 59 | } 60 | Then("""^I should have long one hundred in my belly$""") { () => 61 | assertEquals(100L, longBelly) 62 | } 63 | 64 | Given("""^I have eaten "(.*)"$""") { (arg0: String) => 65 | stringBelly = arg0 66 | } 67 | Then("""^I should have numnumnum in my belly$""") { () => 68 | assertEquals("numnumnum", stringBelly) 69 | } 70 | 71 | Given("""I have eaten {double} doubles""") { (arg0: Double) => 72 | doubleBelly = arg0 73 | } 74 | Then("""^I should have one and a half doubles in my belly$""") { () => 75 | assertEquals(1.5, doubleBelly, 0.0) 76 | } 77 | 78 | Given("""I have eaten {} floats""") { (arg0: Float) => 79 | floatBelly = arg0 80 | } 81 | Then("""^I should have one and a half floats in my belly$""") { () => 82 | assertEquals(1.5f, floatBelly, 0.0) 83 | } 84 | 85 | Given("""I have eaten a short {short}""") { (arg0: Short) => 86 | shortBelly = arg0 87 | } 88 | Then("""^I should have short one hundred in my belly$""") { () => 89 | assertEquals(100.toShort, shortBelly) 90 | } 91 | 92 | Given("""I have eaten a byte {byte}""") { (arg0: Byte) => 93 | byteBelly = arg0 94 | } 95 | Then("""^I should have two byte in my belly$""") { () => 96 | assertEquals(2.toByte, byteBelly) 97 | } 98 | 99 | Given("""I have eaten {bigdecimal} big decimals""") { 100 | (arg0: java.math.BigDecimal) => 101 | bigDecimalBelly = arg0 102 | } 103 | Then("""^I should have one and a half big decimals in my belly$""") { () => 104 | assertEquals(BigDecimal(1.5), bigDecimalBelly) 105 | } 106 | 107 | Given("""I have eaten {biginteger} big int""") { 108 | (arg0: java.math.BigInteger) => 109 | bigIntBelly = arg0.intValue() 110 | } 111 | Then("""^I should have a ten big int in my belly$""") { () => 112 | assertEquals(BigInt(10), bigIntBelly) 113 | } 114 | 115 | Given("""I have eaten char '{char}'""") { (arg0: Char) => 116 | charBelly = 'C' 117 | } 118 | Then("""^I should have character C in my belly$""") { () => 119 | assertEquals('C', charBelly) 120 | } 121 | 122 | Given("""I have eaten boolean {boolean}""") { (arg0: Boolean) => 123 | boolBelly = arg0 124 | } 125 | Then("""^I should have truth in my belly$""") { () => 126 | assertEquals(true, boolBelly) 127 | } 128 | 129 | Given("""I have a table the sum of all rows should be {int} :""") { 130 | (value: Int, table: DataTable) => 131 | assertEquals( 132 | value, 133 | table 134 | .asList(classOf[String]) 135 | .asScala 136 | .drop(1) 137 | .map(String.valueOf(_: String).toInt) 138 | .foldLeft(0)(_ + _) 139 | ) 140 | } 141 | 142 | Given("""I see in the distance ... {snake}""") { (s: Snake) => 143 | snake = s 144 | } 145 | Then("""^I have a snake of length (\d+) moving (.*)$""") { 146 | (size: Int, dir: String) => 147 | assertEquals(size, snake.length) 148 | assertEquals(Symbol(dir), snake.direction) 149 | } 150 | 151 | Given("""I have a person {person}""") { (p: Person) => 152 | person = p 153 | } 154 | 155 | Then("""^he should say \"(.*)\"""") { (s: String) => 156 | assertEquals(person.hello, s) 157 | } 158 | 159 | Given("^I have eaten the following cukes$") { (cs: JList[Cukes]) => 160 | cukes = cs 161 | } 162 | 163 | Then("""I should have eaten {int} cukes""") { (total: Int) => 164 | assertEquals(total, cukes.asScala.map(_.number).sum) 165 | } 166 | 167 | And("^they should have been (.*)$") { (colors: String) => 168 | assertEquals(colors, cukes.asScala.map(_.color).mkString(", ")) 169 | } 170 | 171 | Given("^I drink gin and vermouth$") { () => 172 | gin = 13 173 | vermouth = 42 174 | } 175 | 176 | When("^I shake my belly$") { // note the lack of () => 177 | maritinis += vermouth * gin 178 | } 179 | 180 | Then("^I should have lots of martinis$") { () => 181 | assertEquals(13 * 42, maritinis) 182 | } 183 | } 184 | 185 | @nowarn 186 | class ThenDefs extends ScalaDsl with EN { 187 | Then("""^I am "([^"]*)"$""") { (arg0: String) => } 188 | } 189 | --------------------------------------------------------------------------------