Add support for 'But' step type in Gherkin scenarios (#34)

Author: EtaCassiopeia

core/src/main/scala/zio/bdd/core/ScenarioExecutor.scala

@@ -60,10 +60,10 @@ object ScenarioExecutor {
     ZIO
       .foldLeft(steps)((List.empty[(Step, StepType)], Option.empty[StepType])) { case ((acc, prevType), step) =>
         val effectiveType = step.stepType match {
-          case StepType.AndStep =>
+          case StepType.AndStep | StepType.ButStep =>
             prevType match {
               case Some(t) => ZIO.succeed(t)
-              case None    => ZIO.fail(new Exception("And step without previous step"))
+              case None    => ZIO.fail(new Exception("And or But step without previous step"))
             }
           case other => ZIO.succeed(other)
         }

core/src/test/scala/zio/bdd/core/FeatureExecutorSpec.scala

@@ -66,6 +66,14 @@ object FeatureExecutorSpec extends ZIOSpecDefault {
     Then("an error occurs") {
       ZIO.fail(new RuntimeException("Simulated error")).unit
     }
+
+    Then("the user " / string / " should not have the role " / string) { (name: String, role: String) =>
+      for {
+        state <- ScenarioContext.get
+        user  <- ZIO.fromOption(state.users.get(name)).orElseFail(new RuntimeException(s"User $name does not exist"))
+        _     <- Assertions.assertTrue(user.role != role, s"User $name should not have role $role")
+      } yield ()
+    }
   }
 
   private val testFile = "test.feature"
@@ -203,6 +211,20 @@ object FeatureExecutorSpec extends ZIOSpecDefault {
         feature <- GherkinParser.parseFeature(content, testFile)
         results <- FeatureExecutor.executeFeatures[Any, SystemState](List(feature), steps.getSteps, steps)
       } yield assertTrue(results.head.isPassed)
+    },
+    test("execute scenario with But step for role check") {
+      val content = """
+                      |Feature: User Role Check
+                      |  Scenario: Check user role
+                      |    Given a system is running
+                      |    Given a user named "Alice" with age 30 and role "admin"
+                      |    Then the user "Alice" should exist
+                      |    But the user "Alice" should not have the role "manager"
+  """.stripMargin
+      for {
+        feature <- GherkinParser.parseFeature(content, testFile)
+        results <- FeatureExecutor.executeFeatures[Any, SystemState](List(feature), steps.getSteps, steps)
+      } yield assertTrue(results.head.isPassed)
     }
   )
 }

gherkin/src/main/scala/zio/bdd/gherkin/GherkinParser.scala

@@ -48,7 +48,7 @@ case class Scenario(
 }
 
 enum StepType {
-  case GivenStep, WhenStep, ThenStep, AndStep
+  case GivenStep, WhenStep, ThenStep, ButStep, AndStep
 }
 
 case class DataTableRow(cells: List[String]) {
@@ -100,6 +100,7 @@ case class Step(
       case StepType.GivenStep => "Given"
       case StepType.WhenStep  => "When"
       case StepType.ThenStep  => "Then"
+      case StepType.ButStep   => "But"
       case StepType.AndStep   => "And"
     }
     val stepLine     = indent + stepTypeStr + " " + pattern + "\n"
@@ -124,7 +125,7 @@ object GherkinParser {
 
   // Keyword parser: handles Gherkin keywords with optional colon
   private def keyword(using P[?]): P[String] = P(
-    ("Feature" | "Background" | "Scenario Outline" | "Scenario" | "Given" | "When" | "Then" | "And" | "Examples") ~ (":".?)
+    ("Feature" | "Background" | "Scenario Outline" | "Scenario" | "Given" | "When" | "Then" | "But" | "And" | "Examples") ~ (":".?)
   ).!.map(_.stripSuffix(":"))
 
   // Text parser: captures text until newline, including typed placeholders like {name:String}
@@ -161,12 +162,13 @@ object GherkinParser {
 
   // Step parser: captures step type as StepType and pattern separately
   private def step(ctx: ParseContext)(using P[?]): P[Step] =
-    P(Index ~ ("Given" | "When" | "Then" | "And").! ~ ":".? ~/ text ~ dataTableParser.?).map {
+    P(Index ~ ("Given" | "When" | "Then" | "But" | "And").! ~ ":".? ~/ text ~ dataTableParser.?).map {
       case (idx, stepTypeStr, pattern, dataTableOpt) =>
         val stepType = stepTypeStr match {
           case "Given" => StepType.GivenStep
           case "When"  => StepType.WhenStep
           case "Then"  => StepType.ThenStep
+          case "But"   => StepType.ButStep
           case "And"   => StepType.AndStep
         }
         Step(stepType, pattern.trim, dataTableOpt, Some(ctx.file), Some(ctx.lineAt(idx)))

gherkin/src/test/scala/zio/bdd/gherkin/GherkinParserSpec.scala

@@ -436,6 +436,7 @@ object GherkinParserSpec extends ZIOSpecDefault {
                       |  Scenario: Successful password reset with logging
                       |    When the user requests a password reset
                       |    And the reset email is logged
+                      |    But the user is not deactivated
                       |    Then an email should be sent to "default@example.com"
         """.stripMargin
       checkParse(content, testFile) { feature =>
@@ -451,11 +452,12 @@ object GherkinParserSpec extends ZIOSpecDefault {
             Step(StepType.GivenStep, """a user exists with name "Default"""", file = Some(testFile), line = Some(4)),
             Step(StepType.WhenStep, "the user requests a password reset", file = Some(testFile), line = Some(6)),
             Step(StepType.AndStep, "the reset email is logged", file = Some(testFile), line = Some(7)),
+            Step(StepType.ButStep, "the user is not deactivated", file = Some(testFile), line = Some(8)),
             Step(
               StepType.ThenStep,
               """an email should be sent to "default@example.com"""",
               file = Some(testFile),
-              line = Some(8)
+              line = Some(9)
             )
           )
         )

project/StepGeneratorPlugin.scala

@@ -43,6 +43,7 @@ object StepMethodGenerator {
       ("Given", "StepType.GivenStep"),
       ("When", "StepType.WhenStep"),
       ("Then", "StepType.ThenStep"),
+      ("But", "StepType.ButStep"),
       ("And", "StepType.AndStep")
     )