From 98c189a4c8405cdb7c602ab539e39411c1b2ea89 Mon Sep 17 00:00:00 2001
From: Pushpak-Jaiswal <pushpakmjaiswal@gmail.com>
Date: Fri, 16 Oct 2026 11:04:50 +0530
Subject: [PATCH 1/2] fix(chore): test-cleanup

---
 pom.xml                                       |   7 +
 .../cucumber/BaseCucumberTest.java            |   7 +
 .../cucumber/CucumberStepLogger.java          |   2 +-
 .../unit/CucumberStepLoggerTest.java          | 177 ++++++++++++++++++
 4 files changed, 192 insertions(+), 1 deletion(-)
 create mode 100644 src/test/java/com/seleniumboot/unit/CucumberStepLoggerTest.java

diff --git a/pom.xml b/pom.xml
index 9f35ff5..72ca550 100644
--- a/pom.xml
+++ b/pom.xml
@@ -86,6 +86,13 @@
             <optional>true</optional>
         </dependency>
 
+        <dependency>
+            <groupId>io.cucumber</groupId>
+            <artifactId>cucumber-junit-platform-engine</artifactId>
+            <version>8.0.3</version>
+            <optional>true</optional>
+        </dependency>
+
         <!--
             JUnit 5 support — optional so it is NOT pulled transitively for TestNG users.
             Consumers who use JUnit 5 must add junit-jupiter and junit-platform-launcher
diff --git a/src/main/java/com/seleniumboot/cucumber/BaseCucumberTest.java b/src/main/java/com/seleniumboot/cucumber/BaseCucumberTest.java
index a5d0c7d..d5d9f3b 100644
--- a/src/main/java/com/seleniumboot/cucumber/BaseCucumberTest.java
+++ b/src/main/java/com/seleniumboot/cucumber/BaseCucumberTest.java
@@ -28,7 +28,14 @@
  *
  * <p>Step definition classes should extend {@link BaseCucumberSteps} to get
  * {@code getDriver()}, {@code open()}, {@code $()} and {@code assertThat()}.
+ *
+ * @deprecated since 3.9.0. {@link AbstractTestNGCucumberTests} has been deprecated for
+ *     removal upstream in Cucumber 8.x. New suites should use JUnit Platform Engine
+ *     ({@code cucumber-junit-platform-engine}) with {@code @Suite}. This class will be
+ *     removed in 4.0.0 once Cucumber drops TestNG runner support.
  */
+@Deprecated(since = "3.9.0")
+@SuppressWarnings({"deprecation", "removal"})
 @SeleniumBootApi(since = "1.9.0")
 @Listeners({SuiteExecutionListener.class, TestExecutionListener.class})
 public abstract class BaseCucumberTest extends AbstractTestNGCucumberTests {
diff --git a/src/main/java/com/seleniumboot/cucumber/CucumberStepLogger.java b/src/main/java/com/seleniumboot/cucumber/CucumberStepLogger.java
index 8be7d19..117ce37 100644
--- a/src/main/java/com/seleniumboot/cucumber/CucumberStepLogger.java
+++ b/src/main/java/com/seleniumboot/cucumber/CucumberStepLogger.java
@@ -43,7 +43,7 @@ private void onStepStarted(TestStepStarted event) {
             return;
         }
         if (event.getTestStep() instanceof PickleStepTestStep step) {
-            CURRENT_STEP.set(step.getStepText());
+            CURRENT_STEP.set(step.getStep().getText());
         }
     }
 
diff --git a/src/test/java/com/seleniumboot/unit/CucumberStepLoggerTest.java b/src/test/java/com/seleniumboot/unit/CucumberStepLoggerTest.java
new file mode 100644
index 0000000..3b6b3e2
--- /dev/null
+++ b/src/test/java/com/seleniumboot/unit/CucumberStepLoggerTest.java
@@ -0,0 +1,177 @@
+package com.seleniumboot.unit;
+
+import com.seleniumboot.cucumber.CucumberStepLogger;
+import com.seleniumboot.steps.StepLogger;
+import com.seleniumboot.steps.StepStatus;
+import io.cucumber.plugin.event.EventHandler;
+import io.cucumber.plugin.event.EventPublisher;
+import io.cucumber.plugin.event.HookTestStep;
+import io.cucumber.plugin.event.PickleStepTestStep;
+import io.cucumber.plugin.event.Result;
+import io.cucumber.plugin.event.Status;
+import io.cucumber.plugin.event.Step;
+import io.cucumber.plugin.event.TestStepFinished;
+import io.cucumber.plugin.event.TestStepStarted;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+import static org.testng.Assert.*;
+
+/**
+ * Unit tests for {@link CucumberStepLogger}.
+ */
+public class CucumberStepLoggerTest {
+
+    private MockedStatic<StepLogger> stepLoggerMock;
+
+    @BeforeMethod
+    public void setup() {
+        stepLoggerMock = mockStatic(StepLogger.class);
+    }
+
+    @AfterMethod
+    public void teardown() {
+        stepLoggerMock.close();
+    }
+
+    @Test
+    public void registersHandlersAndLogsSuccessfulStep() {
+        CucumberStepLogger cucumberStepLogger = new CucumberStepLogger();
+        EventPublisher publisher = mock(EventPublisher.class);
+
+        ArgumentCaptor<EventHandler> handlerCaptor = ArgumentCaptor.forClass(EventHandler.class);
+        cucumberStepLogger.setEventPublisher(publisher);
+
+        verify(publisher).registerHandlerFor(eq(TestStepStarted.class), handlerCaptor.capture());
+        verify(publisher).registerHandlerFor(eq(TestStepFinished.class), handlerCaptor.capture());
+
+        EventHandler<TestStepStarted> startHandler = handlerCaptor.getAllValues().get(0);
+        EventHandler<TestStepFinished> finishHandler = handlerCaptor.getAllValues().get(1);
+
+        // Given a pickle step
+        PickleStepTestStep pickleStep = mock(PickleStepTestStep.class);
+        Step step = mock(Step.class);
+        when(step.getText()).thenReturn("Given user navigates to login");
+        when(pickleStep.getStep()).thenReturn(step);
+
+        TestStepStarted startEvent = mock(TestStepStarted.class);
+        when(startEvent.getTestStep()).thenReturn(pickleStep);
+
+        TestStepFinished finishEvent = mock(TestStepFinished.class);
+        when(finishEvent.getTestStep()).thenReturn(pickleStep);
+        Result result = mock(Result.class);
+        when(result.getStatus()).thenReturn(Status.PASSED);
+        when(finishEvent.getResult()).thenReturn(result);
+
+        // When step starts and finishes
+        startHandler.receive(startEvent);
+        finishHandler.receive(finishEvent);
+
+        // Then logged to StepLogger with PASS and no screenshot
+        stepLoggerMock.verify(() -> StepLogger.step("Given user navigates to login", StepStatus.PASS, false), times(1));
+    }
+
+    @Test
+    public void logsFailedStepWithScreenshot() {
+        CucumberStepLogger cucumberStepLogger = new CucumberStepLogger();
+        EventPublisher publisher = mock(EventPublisher.class);
+
+        ArgumentCaptor<EventHandler> handlerCaptor = ArgumentCaptor.forClass(EventHandler.class);
+        cucumberStepLogger.setEventPublisher(publisher);
+
+        verify(publisher).registerHandlerFor(eq(TestStepStarted.class), handlerCaptor.capture());
+        verify(publisher).registerHandlerFor(eq(TestStepFinished.class), handlerCaptor.capture());
+
+        EventHandler<TestStepStarted> startHandler = handlerCaptor.getAllValues().get(0);
+        EventHandler<TestStepFinished> finishHandler = handlerCaptor.getAllValues().get(1);
+
+        PickleStepTestStep pickleStep = mock(PickleStepTestStep.class);
+        Step step = mock(Step.class);
+        when(step.getText()).thenReturn("When user enters invalid password");
+        when(pickleStep.getStep()).thenReturn(step);
+
+        TestStepStarted startEvent = mock(TestStepStarted.class);
+        when(startEvent.getTestStep()).thenReturn(pickleStep);
+
+        TestStepFinished finishEvent = mock(TestStepFinished.class);
+        when(finishEvent.getTestStep()).thenReturn(pickleStep);
+        Result result = mock(Result.class);
+        when(result.getStatus()).thenReturn(Status.FAILED);
+        when(finishEvent.getResult()).thenReturn(result);
+
+        startHandler.receive(startEvent);
+        finishHandler.receive(finishEvent);
+
+        // Failure must trigger screenshot = true
+        stepLoggerMock.verify(() -> StepLogger.step("When user enters invalid password", StepStatus.FAIL, true), times(1));
+    }
+
+    @Test
+    public void mapsSkippedStatusToWarn() {
+        CucumberStepLogger cucumberStepLogger = new CucumberStepLogger();
+        EventPublisher publisher = mock(EventPublisher.class);
+
+        ArgumentCaptor<EventHandler> handlerCaptor = ArgumentCaptor.forClass(EventHandler.class);
+        cucumberStepLogger.setEventPublisher(publisher);
+
+        verify(publisher).registerHandlerFor(eq(TestStepStarted.class), handlerCaptor.capture());
+        verify(publisher).registerHandlerFor(eq(TestStepFinished.class), handlerCaptor.capture());
+
+        EventHandler<TestStepStarted> startHandler = handlerCaptor.getAllValues().get(0);
+        EventHandler<TestStepFinished> finishHandler = handlerCaptor.getAllValues().get(1);
+
+        PickleStepTestStep pickleStep = mock(PickleStepTestStep.class);
+        Step step = mock(Step.class);
+        when(step.getText()).thenReturn("Then dashboard should display");
+        when(pickleStep.getStep()).thenReturn(step);
+
+        TestStepStarted startEvent = mock(TestStepStarted.class);
+        when(startEvent.getTestStep()).thenReturn(pickleStep);
+
+        TestStepFinished finishEvent = mock(TestStepFinished.class);
+        when(finishEvent.getTestStep()).thenReturn(pickleStep);
+        Result result = mock(Result.class);
+        when(result.getStatus()).thenReturn(Status.SKIPPED);
+        when(finishEvent.getResult()).thenReturn(result);
+
+        startHandler.receive(startEvent);
+        finishHandler.receive(finishEvent);
+
+        stepLoggerMock.verify(() -> StepLogger.step("Then dashboard should display", StepStatus.WARN, false), times(1));
+    }
+
+    @Test
+    public void ignoresHookTestSteps() {
+        CucumberStepLogger cucumberStepLogger = new CucumberStepLogger();
+        EventPublisher publisher = mock(EventPublisher.class);
+
+        ArgumentCaptor<EventHandler> handlerCaptor = ArgumentCaptor.forClass(EventHandler.class);
+        cucumberStepLogger.setEventPublisher(publisher);
+
+        verify(publisher).registerHandlerFor(eq(TestStepStarted.class), handlerCaptor.capture());
+        verify(publisher).registerHandlerFor(eq(TestStepFinished.class), handlerCaptor.capture());
+
+        EventHandler<TestStepStarted> startHandler = handlerCaptor.getAllValues().get(0);
+        EventHandler<TestStepFinished> finishHandler = handlerCaptor.getAllValues().get(1);
+
+        HookTestStep hookStep = mock(HookTestStep.class);
+        TestStepStarted startEvent = mock(TestStepStarted.class);
+        when(startEvent.getTestStep()).thenReturn(hookStep);
+
+        TestStepFinished finishEvent = mock(TestStepFinished.class);
+        when(finishEvent.getTestStep()).thenReturn(hookStep);
+
+        startHandler.receive(startEvent);
+        finishHandler.receive(finishEvent);
+
+        // Hook step must never be logged to StepLogger
+        stepLoggerMock.verify(() -> StepLogger.step(any(), any(), anyBoolean()), never());
+    }
+}
+

From 5d0a1b9d36399105da1c0c19491ec779316c470b Mon Sep 17 00:00:00 2001
From: Mohammad Saddam Hossain <sddmhossain786@gmail.com>
Date: Sat, 17 Oct 2026 06:53:59 +0530
Subject: [PATCH 2/2] docs(changelog): BaseCucumberTest deprecation (#155)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 915392e..abc645b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ### Unreleased
 
+- **`BaseCucumberTest` deprecated** — `@Deprecated(since = "3.9.0")`, because `AbstractTestNGCucumberTests` is deprecated for removal upstream in Cucumber 8.x. Nothing changes at runtime and existing TestNG Cucumber suites keep working; subclasses now get a deprecation warning. Plan to remove it in 4.0.0, once Cucumber drops its TestNG runner, in favour of `cucumber-junit-platform-engine` (added as an optional dependency). `CucumberStepLogger` also moves off the deprecated `getStepText()`. (#155, #157)
+
 - **Bounded failure detail record** — every failed test now exports one optional-field `failureDetail` object with the failing locator, top application frame, last successful step, page URL/title, heal events, console errors, retry/history status, and representative same-cause context. The HTML failure panel and opt-in AI prompt reuse this record; raw errors and stack traces remain available. Text/list/URL limits and the exact AI data disclosure are documented. (#142)
 
 - **`Locator`: `waitFor(State)`, `allTextContents()`, and element `screenshot()`** — `waitFor(State)` (and `waitFor()`) waits for an element to reach a target lifecycle state (`VISIBLE`, `HIDDEN`, `ATTACHED`, `DETACHED`), retrying up to `timeouts.explicit`. `allTextContents()` returns the text content of all matched elements in a single pass without waiting if empty, re-resolving if an element goes stale during read. `screenshot()` returns the element's PNG bytes, and `screenshot(Path)` writes them to a file path; both terminal actions re-resolve on every poll to survive stale elements. (#135)