Support diff toolwindow in IntelliJ IDEA

For the toolwindow are required the "expected" and "actual" attributes in the test-failed-output message.

This fixes issue: cucumber#2607

Author: avokin

cucumber-core/src/main/java/io/cucumber/core/plugin/TeamCityPlugin.java

@@ -77,6 +77,9 @@ public class TeamCityPlugin implements EventListener {
             + "[testFinished timestamp = '%s' duration = '%s' name = '%s']";
     private static final String TEMPLATE_TEST_FAILED = TEAMCITY_PREFIX
             + "[testFailed timestamp = '%s' duration = '%s' message = '%s' details = '%s' name = '%s']";
+
+    private static final String TEMPLATE_TEST_COMPARISON_FAILED = TEAMCITY_PREFIX
+            + "[testFailed timestamp = '%s' duration = '%s' message = '%s' details = '%s' expected='%s' actual='%s' name = '%s']";
     private static final String TEMPLATE_TEST_IGNORED = TEAMCITY_PREFIX
             + "[testIgnored timestamp = '%s' duration = '%s' message = '%s' name = '%s']";
 
@@ -101,6 +104,22 @@ public class TeamCityPlugin implements EventListener {
     private static final Pattern ANNOTATION_GLUE_CODE_LOCATION_PATTERN = Pattern.compile("^(.*)\\.(.*)\\([^:]*\\)");
     private static final Pattern LAMBDA_GLUE_CODE_LOCATION_PATTERN = Pattern.compile("^(.*)\\.(.*)\\(.*:.*\\)");
 
+    private static final Pattern[] COMPARE_PATTERNS = new Pattern[] {
+            Pattern.compile("expected: is \"(.*)\"\n\\s*got: \"(.*)\"",
+                Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected: is \"(.*)\"\n\\s*but:\\s+was \"(.*)\"",
+                Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected:\\s*(.*)\n\\s*got:\\s*(.*)", Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected same:<(.*)> was not:<(.*)>", Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected:\\s*\"(.*)\"\n\\s*but: was\\s*\"(.*)\"",
+                Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected:\\s*(.*)\n\\s*but: was\\s*(.*)", Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expected:\\s*(.*)\\s+but was:\\s*(.*)",
+                Pattern.DOTALL | Pattern.CASE_INSENSITIVE),
+            Pattern.compile("expecting:\\s+<(.*)> to be equal to:\\s+<(.*)>\\s+but was not",
+                Pattern.DOTALL | Pattern.CASE_INSENSITIVE)
+    };
+
     private final PrintStream out;
     private final List<SnippetsSuggestedEvent> suggestions = new ArrayList<>();
     private final Map<URI, Collection<Node>> parsedTestSources = new HashMap<>();
@@ -281,7 +300,16 @@ private void printTestStepFinished(TestStepFinished event) {
             case AMBIGUOUS:
             case FAILED: {
                 String details = printStackTrace(error);
-                print(TEMPLATE_TEST_FAILED, timeStamp, duration, "Step failed", details, name);
+                String message = error.getMessage();
+                ComparisonFailureData comparisonFailureData = message != null
+                        ? createExceptionNotification(message.trim())
+                        : null;
+                if (comparisonFailureData != null) {
+                    print(TEMPLATE_TEST_COMPARISON_FAILED, timeStamp, duration, "Step failed", details,
+                        comparisonFailureData.getExpected(), comparisonFailureData.getActual(), name);
+                } else {
+                    print(TEMPLATE_TEST_FAILED, timeStamp, duration, "Step failed", details, name);
+                }
                 break;
             }
             default:
@@ -290,6 +318,27 @@ private void printTestStepFinished(TestStepFinished event) {
         print(TEMPLATE_TEST_FINISHED, timeStamp, duration, name);
     }
 
+    private static ComparisonFailureData createExceptionNotification(String message, Pattern pattern) {
+        final Matcher matcher = pattern.matcher(message);
+        if (matcher.find() && matcher.end() == message.length()) {
+            String expected = matcher.group(1);
+            String actual = matcher.group(2);
+            return new ComparisonFailureData(expected.replaceAll("\\\\n", "\n"),
+                actual.replaceAll("\\\\n", "\n"));
+        }
+        return null;
+    }
+
+    private static ComparisonFailureData createExceptionNotification(String message) {
+        for (Pattern pattern : COMPARE_PATTERNS) {
+            ComparisonFailureData result = createExceptionNotification(message, pattern);
+            if (result != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+
     private String extractName(TestStep step) {
         if (step instanceof PickleStepTestStep) {
             PickleStepTestStep pickleStepTestStep = (PickleStepTestStep) step;
@@ -420,4 +469,39 @@ private String escape(String source) {
                 .replace("]", "|]");
     }
 
+    private static class ComparisonFailureData {
+        private final String expected;
+
+        private final String actual;
+
+        ComparisonFailureData(String expected, String actual) {
+            if (isWrappedWith(expected, '<', '>') && isWrappedWith(actual, '<', '>')) {
+                expected = unwrap(expected);
+                actual = unwrap(actual);
+            }
+            if (isWrappedWith(expected, '[', ']') && isWrappedWith(actual, '[', ']')) {
+                expected = unwrap(expected);
+                actual = unwrap(actual);
+            }
+            this.expected = expected;
+            this.actual = actual;
+        }
+
+        private static boolean isWrappedWith(String text, char startChar, char endChar) {
+            return text != null && text.length() > 0 &&
+                    text.charAt(0) == startChar && text.charAt(text.length() - 1) == endChar;
+        }
+
+        private static String unwrap(String text) {
+            return text.substring(1, text.length() - 1);
+        }
+
+        public String getExpected() {
+            return expected;
+        }
+
+        public String getActual() {
+            return actual;
+        }
+    }
 }

cucumber-core/src/test/java/io/cucumber/core/plugin/TeamCityPluginTest.java

@@ -342,4 +342,47 @@ void should_print_system_failure_for_failed_hooks() {
                 "##teamcity[testFinished timestamp = '1970-01-01T12:00:00.000+0000' name = 'Before All/After All']"));
     }
 
+    @Test
+    void should_print_comparison_failure_for_failed_assert_equal() {
+        Feature feature = TestFeatureParser.parse("path/test.feature", "" +
+                "Feature: feature name\n" +
+                "  Scenario: scenario name\n" +
+                "    Given first step\n");
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        Runtime.builder()
+                .withFeatureSupplier(new StubFeatureSupplier(feature))
+                .withAdditionalPlugins(new TeamCityPlugin(new PrintStream(out)))
+                .withEventBus(new TimeServiceEventBus(fixed(EPOCH, of("UTC")), UUID::randomUUID))
+                .withBackendSupplier(new StubBackendSupplier(
+                        emptyList(),
+                        singletonList(new StubStepDefinition("first step", new RuntimeException("expected: <1> but was: <2>"))),
+                        emptyList()))
+                .build()
+                .run();
+
+        assertThat(out, bytesContainsString("expected='one value' actual='1' name = '2']"));
+    }
+
+    @Test
+    void should_print_comparison_failure_for_failed_assert_equal_for_strings() {
+        Feature feature = TestFeatureParser.parse("path/test.feature", "" +
+                "Feature: feature name\n" +
+                "  Scenario: scenario name\n" +
+                "    Given first step\n");
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        Runtime.builder()
+                .withFeatureSupplier(new StubFeatureSupplier(feature))
+                .withAdditionalPlugins(new TeamCityPlugin(new PrintStream(out)))
+                .withEventBus(new TimeServiceEventBus(fixed(EPOCH, of("UTC")), UUID::randomUUID))
+                .withBackendSupplier(new StubBackendSupplier(
+                        emptyList(),
+                        singletonList(new StubStepDefinition("first step", new RuntimeException("expected: <[one value]> but was: <[another value]>"))),
+                        emptyList()))
+                .build()
+                .run();
+
+        assertThat(out, bytesContainsString("expected='one value' actual='another value' name = 'first step']"));
+    }
 }