CTP-11036 Send full Cucumber feature name to CTP

Author: Roberto Nares

README.md

@@ -281,14 +281,14 @@ Each Cucumber scenario is reported as an individual test case.
 For example:
 
 ```text
-Feature: petclinic.feature
+Feature: PetClinic browser actions
 Scenario: Add a new pet
 ```
 
 is reported to CTP as:
 
 ```text
-test=petclinic.feature#Add a new pet
+test=Feature: PetClinic browser actions#Add a new pet
 testCase=Add a new pet
 ```
 ## Browser Integrations

coverage-integration-cucumber/pom.xml

@@ -25,6 +25,18 @@
             <scope>provided</scope>
         </dependency>
 
+        <dependency>
+            <groupId>io.cucumber</groupId>
+            <artifactId>gherkin</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.cucumber</groupId>
+            <artifactId>messages</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

coverage-integration-cucumber/src/main/java/com/parasoft/coverage/integration/cucumber/ParasoftCucumberScenarioListener.java

@@ -16,13 +16,21 @@
 
 package com.parasoft.coverage.integration.cucumber;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
 
+import io.cucumber.gherkin.GherkinParser;
 import io.cucumber.java.After;
 import io.cucumber.java.Before;
 import io.cucumber.java.Scenario;
 import io.cucumber.java.Status;
+import io.cucumber.messages.types.Feature;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -43,6 +51,8 @@ public class ParasoftCucumberScenarioListener
 
     private static final int COVERAGE_HOOK_ORDER = Integer.MIN_VALUE;
     private static final int MAX_RESULT_MESSAGE_LENGTH = 500;
+    private static final String CLASSPATH_SCHEME = "classpath";
+    private static final Map<URI, String> FEATURE_NAME_CACHE = new ConcurrentHashMap<>();
 
     private final CoverageApiClient coverageApiClient;
 
@@ -178,11 +188,125 @@ void stopScenario(ResultEnum result, String resultMessage)
 
     static String buildTestId(URI scenarioUri, String scenarioName)
     {
-        String featureFileName = extractFeatureFileName(scenarioUri);
+        String featureName = resolveFeatureName(scenarioUri);
 
-        return featureFileName == null
-                ? scenarioName
-                : featureFileName + '#' + scenarioName;
+        if (featureName == null) {
+            featureName = extractFeatureFileName(scenarioUri);
+        }
+
+        return featureName == null ? scenarioName : featureName + '#' + scenarioName;
+    }
+
+    static String resolveFeatureName(URI uri)
+    {
+        if (uri == null) {
+            return null;
+        }
+
+        String cachedFeatureName = FEATURE_NAME_CACHE.get(uri);
+
+        if (cachedFeatureName != null) {
+            return cachedFeatureName;
+        }
+
+        String resolvedFeatureName = parseFeatureName(uri);
+
+        if (resolvedFeatureName == null) {
+            return null;
+        }
+
+        String existingFeatureName = FEATURE_NAME_CACHE.putIfAbsent(uri, resolvedFeatureName);
+
+        return existingFeatureName == null ? resolvedFeatureName : existingFeatureName;
+    }
+
+    private static String parseFeatureName(URI uri)
+    {
+        try (InputStream featureSource = openFeatureSource(uri)) {
+            GherkinParser parser = GherkinParser.builder()
+                    .includeSource(false)
+                    .includeGherkinDocument(true)
+                    .includePickles(false)
+                    .build();
+
+            return parser.parse(uri.toString(), featureSource)
+                    .flatMap(envelope -> envelope.getGherkinDocument().stream())
+                    .flatMap(gherkinDocument -> gherkinDocument.getFeature().stream())
+                    .map(ParasoftCucumberScenarioListener::formatFeatureName)
+                    .filter(Objects::nonNull)
+                    .findFirst()
+                    .orElse(null);
+        }
+        catch (IOException | RuntimeException e) {
+            LOGGER.warn("Unable to resolve Cucumber feature name from {}; using the feature file name instead", uri, e);
+
+            return null;
+        }
+    }
+
+    private static String formatFeatureName(Feature feature)
+    {
+        String featureName = feature.getName();
+
+        if (featureName == null || featureName.isBlank()) {
+            return null;
+        }
+
+        String normalizedFeatureName = featureName.strip();
+        String featureKeyword = feature.getKeyword();
+
+        if (featureKeyword == null || featureKeyword.isBlank()) {
+            return normalizedFeatureName;
+        }
+
+        String normalizedFeatureKeyword = featureKeyword.strip();
+
+        return normalizedFeatureKeyword.endsWith(":")
+                ? normalizedFeatureKeyword + ' ' + normalizedFeatureName
+                : normalizedFeatureKeyword + ": " + normalizedFeatureName;
+    }
+
+    private static InputStream openFeatureSource(URI uri) throws IOException
+    {
+        String scheme = uri.getScheme();
+
+        if (CLASSPATH_SCHEME.equalsIgnoreCase(scheme)) {
+            String resourceName = uri.getSchemeSpecificPart();
+
+            while (resourceName != null && resourceName.startsWith("/")) {
+                resourceName = resourceName.substring(1);
+            }
+
+            if (resourceName == null || resourceName.isBlank()) {
+                throw new IOException("Cucumber classpath feature URI has no resource name: " + uri);
+            }
+
+            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+
+            if (classLoader == null) {
+                classLoader = ParasoftCucumberScenarioListener.class.getClassLoader();
+            }
+
+            InputStream featureSource = classLoader.getResourceAsStream(resourceName);
+
+            if (featureSource == null) {
+                throw new IOException("Unable to open Cucumber feature resource: " + uri);
+            }
+
+            return featureSource;
+        }
+
+        if (scheme == null || scheme.isBlank()) {
+            String path = uri.getPath();
+
+            if (path == null || path.isBlank()) {
+                path = uri.toString();
+            }
+
+            return Files.newInputStream(Path.of(path));
+        }
+
+        return uri.toURL().openStream();
     }
 
     static String extractFeatureFileName(URI uri)

coverage-integration-cucumber/src/test/java/com/parasoft/coverage/integration/cucumber/ParasoftCucumberScenarioListenerTest.java

@@ -20,6 +20,10 @@
 import static org.junit.Assert.assertNull;
 
 import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import io.cucumber.java.Status;
 
@@ -33,22 +37,83 @@
 public class ParasoftCucumberScenarioListenerTest
 {
     @Test
-    public void buildsTestIdentifierFromFeatureFileAndScenarioName()
+    public void buildsTestIdentifierFromClasspathFeatureNameAndScenarioName() throws Exception
+    {
+        Path classpathRoot = Files.createTempDirectory("cucumber-feature-classpath-");
+        Path featureFile = classpathRoot.resolve("features/coverage-reporting.feature");
+
+        Files.createDirectories(featureFile.getParent());
+        Files.writeString(
+                featureFile,
+                """
+                Feature: Cucumber coverage reporting
+
+                  Scenario: Reports feature name
+                    Given the test is running
+                """);
+
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+
+        try (URLClassLoader classLoader = new URLClassLoader(new URL[] { classpathRoot.toUri().toURL() }, originalClassLoader)) {
+            Thread.currentThread().setContextClassLoader(classLoader);
+
+            assertEquals(
+                    "Feature: Cucumber coverage reporting#Reports feature name",
+                    ParasoftCucumberScenarioListener.buildTestId(
+                            URI.create(
+                                "classpath:features/coverage-reporting.feature"),
+                                "Reports feature name"));
+        }
+        finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+
+            Files.deleteIfExists(featureFile);
+            Files.deleteIfExists(featureFile.getParent());
+            Files.deleteIfExists(classpathRoot);
+        }
+    }
+
+    @Test
+    public void resolvesFeatureNameFromFileFeature() throws Exception
+    {
+        Path featureFile = Files.createTempFile("coverage-reporting-", ".feature");
+
+        Files.writeString(
+                featureFile,
+                """
+                Feature: File-based coverage reporting
+
+                  Scenario: Reports feature name
+                    Given the test is running
+                """);
+
+        try {
+            assertEquals(
+                    "Feature: File-based coverage reporting",
+                    ParasoftCucumberScenarioListener.resolveFeatureName(featureFile.toUri()));
+        }
+        finally {
+            Files.deleteIfExists(featureFile);
+        }
+    }
+
+    @Test
+    public void fallsBackToFeatureFileNameWhenFeatureCannotBeRead()
     {
         assertEquals(
-                "petclinic.feature#Navigate to home page",
+                "missing.feature#Reports feature name",
                 ParasoftCucumberScenarioListener.buildTestId(
-                        URI.create("classpath:features/petclinic.feature"),
-                        "Navigate to home page"));
+                        URI.create("classpath:features/missing.feature"),
+                        "Reports feature name"));
     }
 
     @Test
     public void extractsFeatureFileFromFileUri()
     {
         assertEquals(
-                "parabank-demo.feature",
+                "coverage-reporting.feature",
                 ParasoftCucumberScenarioListener.extractFeatureFileName(
-                        URI.create("file:///tmp/features/parabank-demo.feature")));
+                        URI.create("file:///tmp/features/coverage-reporting.feature")));
     }
 
     @Test
@@ -93,8 +158,8 @@ public void startsAndStopsScenarioAndManagesExecutionContext()
 
         try {
             listener.startScenario(
-                    "petclinic.feature#Navigate to home page",
-                    "Navigate to home page");
+                    "Feature: Cucumber coverage reporting#Reports feature name",
+                    "Reports feature name");
 
             assertEquals(
                     "test-operator-id=automation-user+parallel-123",
@@ -103,16 +168,16 @@ public void startsAndStopsScenarioAndManagesExecutionContext()
             listener.stopScenario(ResultEnum.PASS, null);
 
             assertEquals(
-                    "petclinic.feature#Navigate to home page",
+                    "Feature: Cucumber coverage reporting#Reports feature name",
                     client.startedTest);
             assertEquals(
-                    "Navigate to home page",
+                    "Reports feature name",
                     client.startedTestCase);
             assertEquals(
-                    "petclinic.feature#Navigate to home page",
+                    "Feature: Cucumber coverage reporting#Reports feature name",
                     client.stoppedTest);
             assertEquals(
-                    "Navigate to home page",
+                    "Reports feature name",
                     client.stoppedTestCase);
             assertEquals(ResultEnum.PASS, client.result);
             assertNull(client.message);

pom.xml

@@ -32,6 +32,8 @@
         <gsonfire.version>1.9.0</gsonfire.version>
         <jakarta.annotation.version>3.0.0</jakarta.annotation.version>
         <cucumber.version>7.34.4</cucumber.version>
+        <gherkin.version>36.1.0</gherkin.version>
+        <messages.version>30.1.0</messages.version>
         <junit4.version>4.13.2</junit4.version>
         <junit5.version>5.14.2</junit5.version>
         <maven.javadoc.version>3.11.2</maven.javadoc.version>
@@ -75,6 +77,16 @@
                 <artifactId>cucumber-java</artifactId>
                 <version>${cucumber.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.cucumber</groupId>
+                <artifactId>gherkin</artifactId>
+                <version>${gherkin.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.cucumber</groupId>
+                <artifactId>messages</artifactId>
+                <version>${messages.version}</version>
+            </dependency>
             <dependency>
                 <groupId>com.microsoft.playwright</groupId>
                 <artifactId>playwright</artifactId>