Replace annotation with case class, simplify to single example test

Co-authored-by: gaeljw <[email protected]>

Author: Copilot

build.sbt

@@ -92,7 +92,6 @@ lazy val root = (project in file("."))
       integrationTestsJackson2.projectRefs ++
       integrationTestsJackson3.projectRefs ++
       integrationTestsPicoContainer.projectRefs ++
-      integrationTestsScalatest.projectRefs ++
       examplesJunit4.projectRefs ++
       examplesJunit5.projectRefs ++
       examplesScalatest.projectRefs: _*
@@ -231,22 +230,6 @@ lazy val integrationTestsPicoContainer =
     .dependsOn(cucumberScala % Test)
     .jvmPlatform(scalaVersions = Seq(scala3, scala213, scala212))
 
-lazy val integrationTestsScalatest =
-  (projectMatrix in file("integration-tests/scalatest"))
-    .settings(commonSettings)
-    .settings(scalatestSbtSupport)
-    .settings(
-      name := "integration-tests-scalatest",
-      libraryDependencies ++= Seq(
-        "org.scalatest" %% "scalatest" % scalatestVersion % Test,
-        "org.junit.jupiter" % "junit-jupiter" % junitBom.key.value % Test
-      ),
-      publishArtifact := false
-    )
-    .dependsOn(cucumberScala % Test)
-    .dependsOn(cucumberScalatest % Test)
-    .jvmPlatform(scalaVersions = Seq(scala3, scala213, scala212))
-
 // Examples project
 lazy val examplesJunit4 = (projectMatrix in file("examples/examples-junit4"))
   .settings(commonSettings)

cucumber-scalatest/src/main/java/io/cucumber/scalatest/CucumberOptions.java

@@ -1,35 +1,52 @@
 package io.cucumber.scalatest
 
-import io.cucumber.core.options.{
-  RuntimeOptionsBuilder,
-  CucumberOptionsAnnotationParser
-}
+import io.cucumber.core.options.RuntimeOptionsBuilder
 import io.cucumber.core.runtime.{Runtime => CucumberRuntime}
 import org.scalatest.{Args, Status, Suite}
 
 import scala.annotation.nowarn
 
+/** Configuration for Cucumber tests.
+  *
+  * @param features
+  *   paths to feature files or directories (e.g., "classpath:features")
+  * @param glue
+  *   packages containing step definitions (e.g., "com.example.steps")
+  * @param plugin
+  *   plugins to use (e.g., "pretty", "json:target/cucumber.json")
+  */
+case class CucumberOptions(
+    features: List[String] = List.empty,
+    glue: List[String] = List.empty,
+    plugin: List[String] = List.empty
+)
+
 /** A trait that allows Cucumber scenarios to be run with ScalaTest.
   *
-  * Mix this trait into your test class and optionally annotate it with
-  * `@CucumberOptions` to configure the Cucumber runtime.
+  * Mix this trait into your test class and define the `cucumberOptions` value
+  * to configure the Cucumber runtime.
   *
   * Example:
   * {{{
-  * import io.cucumber.scalatest.CucumberSuite
-  * import io.cucumber.core.options.CucumberOptions
+  * import io.cucumber.scalatest.{CucumberOptions, CucumberSuite}
   *
-  * @CucumberOptions(
-  *   features = Array("classpath:features"),
-  *   glue = Array("com.example.stepdefinitions"),
-  *   plugin = Array("pretty")
-  * )
-  * class RunCucumberTest extends CucumberSuite
+  * class RunCucumberTest extends CucumberSuite {
+  *   override val cucumberOptions = CucumberOptions(
+  *     features = List("classpath:features"),
+  *     glue = List("com.example.stepdefinitions"),
+  *     plugin = List("pretty")
+  *   )
+  * }
   * }}}
   */
 @nowarn
 trait CucumberSuite extends Suite {
 
+  /** Override this value to configure Cucumber options. If not overridden,
+    * defaults will be used based on the package name.
+    */
+  def cucumberOptions: CucumberOptions = CucumberOptions()
+
   /** Runs the Cucumber scenarios.
     *
     * @param testName
@@ -75,35 +92,34 @@ trait CucumberSuite extends Suite {
   }
 
   private def buildRuntimeOptions(): io.cucumber.core.options.RuntimeOptions = {
-    // Try the built-in annotation parser which works with various annotations
-    val annotationParser = new CucumberOptionsAnnotationParser()
     val packageName = getClass.getPackage.getName
-    val featurePath = "classpath:" + packageName.replace('.', '/')
-
-    try {
-      val annotationOptions = annotationParser.parse(getClass).build()
-      val options = new RuntimeOptionsBuilder().build(annotationOptions)
-
-      // If no features were specified, use convention (classpath:package/name)
-      if (options.getFeaturePaths().isEmpty) {
-        val builder = new RuntimeOptionsBuilder()
-        builder.addFeature(
-          io.cucumber.core.feature.FeatureWithLines.parse(featurePath)
-        )
-        builder.addGlue(java.net.URI.create("classpath:" + packageName))
-        builder.build(annotationOptions)
-      } else {
-        options
-      }
-    } catch {
-      case _: Exception =>
-        // If that fails, use convention based on package name
-        val builder = new RuntimeOptionsBuilder()
-        builder.addFeature(
-          io.cucumber.core.feature.FeatureWithLines.parse(featurePath)
-        )
-        builder.addGlue(java.net.URI.create("classpath:" + packageName))
-        builder.build()
+    val builder = new RuntimeOptionsBuilder()
+
+    // Add features
+    val features =
+      if (cucumberOptions.features.nonEmpty) cucumberOptions.features
+      else List("classpath:" + packageName.replace('.', '/'))
+
+    features.foreach { feature =>
+      builder.addFeature(
+        io.cucumber.core.feature.FeatureWithLines.parse(feature)
+      )
+    }
+
+    // Add glue
+    val glue =
+      if (cucumberOptions.glue.nonEmpty) cucumberOptions.glue
+      else List(packageName)
+
+    glue.foreach { g =>
+      builder.addGlue(java.net.URI.create("classpath:" + g))
     }
+
+    // Add plugins
+    cucumberOptions.plugin.foreach { p =>
+      builder.addPluginName(p)
+    }
+
+    builder.build()
   }
 }

cucumber-scalatest/src/main/scala/io/cucumber/scalatest/CucumberSuite.scala

@@ -2,9 +2,10 @@ package cucumber.examples.scalacalculator
 
 import io.cucumber.scalatest.{CucumberOptions, CucumberSuite}
 
-@CucumberOptions(
-  features = Array("classpath:cucumber/examples/scalacalculator"),
-  glue = Array("cucumber.examples.scalacalculator"),
-  plugin = Array("pretty")
-)
-class RunCukesTest extends CucumberSuite
+class RunCukesTest extends CucumberSuite {
+  override val cucumberOptions = CucumberOptions(
+    features = List("classpath:cucumber/examples/scalacalculator"),
+    glue = List("cucumber.examples.scalacalculator"),
+    plugin = List("pretty")
+  )
+}