[Core] Include all fields in JsonFormatters failure feature (#1954)

Consumers of the json output expect all fields to be present. To avoid
breaking consumers we include all fields in the dummy feature that is
generated when cucumber fails to execute.

Author: mpkorstanje

core/pom.xml

@@ -137,6 +137,33 @@
                     </archive>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <artifactSet>
+                                <includes>
+                                    <include>io.cucumber:gherkin</include>
+                                </includes>
+                            </artifactSet>
+                            <relocations>
+                                <relocation>
+                                    <pattern>gherkin</pattern>
+                                    <shadedPattern>io.cucumber.core.internal.gherkin</shadedPattern>
+                                </relocation>
+                            </relocations>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
         </plugins>
     </build>
 

core/src/main/java/io/cucumber/core/plugin/JsonFormatter.java

@@ -36,13 +36,15 @@
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 import static io.cucumber.core.exception.ExceptionUtils.printStackTrace;
+import static java.util.Collections.singletonList;
 import static java.util.Locale.ROOT;
 import static java.util.stream.Collectors.toList;
 
@@ -140,16 +142,7 @@ private void handleTestStepFinished(TestStepFinished event) {
     private void finishReport(TestRunFinished event) {
         Throwable exception = event.getResult().getError();
         if (exception != null) {
-            Map<String, Object> feature = new LinkedHashMap<>();
-            feature.put("description", "Test run failed");
-            Map<String, Object> elements = new LinkedHashMap<>();
-            feature.put("elements", elements);
-            elements.put("description", "There were errors during the execution");
-            Map<String, Object> result = new LinkedHashMap<>();
-            elements.put("result", result);
-            result.put("error_message", exception.getMessage());
-            result.put("status", "failed");
-            featureMaps.add(feature);
+            featureMaps.add(createDummyFeatureForFailure(event));
         }
 
         gson.toJson(featureMaps, out);
@@ -160,6 +153,69 @@ private void finishReport(TestRunFinished event) {
         }
     }
 
+    private Map<String, Object> createDummyFeatureForFailure(TestRunFinished event) {
+        Throwable exception = event.getResult().getError();
+
+        Map<String, Object> feature = new LinkedHashMap<>();
+        feature.put("line", 1);
+        {
+            Map<String, Object> scenario = new LinkedHashMap<>();
+            feature.put("elements", singletonList(scenario));
+
+            scenario.put("start_timestamp", getDateTimeFromTimeStamp(event.getInstant()));
+            scenario.put("line", 2);
+            scenario.put("name", "Could not execute Cucumber");
+            scenario.put("description", "");
+            scenario.put("id", "failure;could-not-execute-cucumber");
+            scenario.put("type", "scenario");
+            scenario.put("keyword", "Scenario");
+
+            Map<String, Object> when = new LinkedHashMap<>();
+            Map<String, Object> then = new LinkedHashMap<>();
+            scenario.put("steps", Arrays.asList(when, then));
+            {
+
+                {
+                    Map<String, Object> whenResult = new LinkedHashMap<>();
+                    when.put("result", whenResult);
+                    whenResult.put("duration", 0);
+                    whenResult.put("status", "passed");
+                }
+                when.put("line", 3);
+                when.put("name", "Cucumber could not execute");
+                Map<String, Object> whenMatch = new LinkedHashMap<>();
+                when.put("match", whenMatch);
+                whenMatch.put("arguments", new ArrayList<>());
+                whenMatch.put("location", "io.cucumber.core.Failure.cucumber_could_not_execute()");
+                when.put("keyword", "When ");
+
+                {
+                    Map<String, Object> thenResult = new LinkedHashMap<>();
+                    then.put("result", thenResult);
+                    thenResult.put("duration", 0);
+                    thenResult.put("error_message", exception.getMessage());
+                    thenResult.put("status", "failed");
+                }
+                then.put("line", 4);
+                then.put("name", "Cucumber will report this error:");
+                Map<String, Object> thenMatch = new LinkedHashMap<>();
+                then.put("match", thenMatch);
+                thenMatch.put("arguments", new ArrayList<>());
+                thenMatch.put("location", "io.cucumber.core.Failure.cucumber_reports_this_error()");
+                then.put("keyword", "Then ");
+            }
+
+            feature.put("name", "Test run failed");
+            feature.put("description", "There were errors during the execution");
+            feature.put("id", "failure");
+            feature.put("keyword", "Feature");
+            feature.put("uri", "classpath:io/cucumber/core/failure.feature");
+            feature.put("tags", new ArrayList<>());
+        }
+
+        return feature;
+    }
+
     private Map<String, Object> createFeatureMap(TestCase testCase) {
         Map<String, Object> featureMap = new HashMap<>();
         featureMap.put("uri", TestSourcesModel.relativize(testCase.getUri()));

core/src/main/java/io/cucumber/core/stepexpression/StepExpressionFactory.java

@@ -102,7 +102,7 @@ private static Supplier<Type> stepDefinitionDoesNotTakeAnyParameter(StepDefiniti
     private CucumberException registerTypeInConfiguration(String expressionString, UndefinedParameterTypeException e) {
         return new CucumberException(format("" +
                 "Could not create a cucumber expression for '%s'.\n" +
-                "It appears you did not register parameter type.",
+                "It appears you did not register a parameter type.",
             expressionString
         ), e);
     }

core/src/test/java/io/cucumber/core/stepexpression/StepExpressionFactoryTest.java

@@ -97,7 +97,7 @@ void throws_for_unknown_parameter_types() {
         );
         assertThat(exception.getMessage(), is("" +
             "Could not create a cucumber expression for 'Given a {unknownParameterType}'.\n" +
-            "It appears you did not register parameter type."
+            "It appears you did not register a parameter type."
 
         ));
         assertThat(events, iterableWithSize(1));