core: actual exception capture (#733)

MykolaGolubyev · web-flow · commit c4c194e87086 · 2020-12-01T15:21:06.000-05:00
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertion.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertion.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,10 +17,7 @@
 
 package org.testingisdocumenting.webtau.documentation;
 
-import org.testingisdocumenting.webtau.expectation.ActualPath;
-import org.testingisdocumenting.webtau.expectation.ExpectationHandler;
-import org.testingisdocumenting.webtau.expectation.ExpectedValuesAware;
-import org.testingisdocumenting.webtau.expectation.ValueMatcher;
+import org.testingisdocumenting.webtau.expectation.*;
 
 import java.util.List;
 import java.util.stream.Collectors;
@@ -34,6 +32,12 @@ public void onValueMatch(ValueMatcher valueMatcher, ActualPath actualPath, Objec
         lastExpectedValues.set(extractExpectedValues(valueMatcher));
     }
 
+    @Override
+    public void onCodeMatch(CodeMatcher codeMatcher) {
+        lastActualValue.set(extractActualValue(codeMatcher));
+        lastExpectedValues.set(extractExpectedValues(codeMatcher));
+    }
+
     Object actualValue() {
         return lastActualValue.get();
     }
@@ -42,12 +46,12 @@ Object expectedValue() {
         return lastExpectedValues.get();
     }
 
-    private static Object extractExpectedValues(ValueMatcher valueMatcher) {
-        if (!(valueMatcher instanceof ExpectedValuesAware)) {
+    private static Object extractExpectedValues(Object matcher) {
+        if (!(matcher instanceof ExpectedValuesAware)) {
             return null;
         }
 
-        List<Object> list = ((ExpectedValuesAware) valueMatcher).expectedValues().collect(Collectors.toList());
+        List<Object> list = ((ExpectedValuesAware) matcher).expectedValues().collect(Collectors.toList());
         if (list.isEmpty()) {
             return null;
         }
@@ -58,4 +62,12 @@ private static Object extractExpectedValues(ValueMatcher valueMatcher) {
 
         return list.get(0);
     }
+
+    private static Object extractActualValue(CodeMatcher codeMatcher) {
+        if (!(codeMatcher instanceof ActualValueAware)) {
+            return null;
+        }
+
+        return ((ActualValueAware) codeMatcher).actualValue();
+    }
 }
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertionValue.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertionValue.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,6 +33,6 @@ public class CoreDocumentationAssertionValue {
      * @param artifactName artifact name (file name without extension)
      */
     public void capture(Class<?> testClass, String artifactName) {
-        DocumentationArtifacts.createAsJson(testClass, artifactName, valueSupplier.get());
+        DocumentationArtifacts.createTextOrJson(testClass, artifactName, valueSupplier.get());
     }
 }
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/DocumentationArtifacts.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/documentation/DocumentationArtifacts.java
@@ -45,6 +45,15 @@ public static void create(Class<?> testClass, String artifactName, String text)
         FileUtils.writeTextContent(path, text);
     }
 
+    public static void createTextOrJson(Class<?> testClass, String artifactName, Object value) {
+        if (value instanceof String) {
+            Path path = DocumentationArtifactsLocation.classBasedLocation(testClass).resolve(artifactName + ".txt");
+            FileUtils.writeTextContent(path, value.toString());
+        } else {
+            createAsJson(testClass, artifactName, value);
+        }
+    }
+
     public static void createAsJson(Class<?> testClass, String artifactName, Object value) {
         artifactName += ".json";
 
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualCode.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualCode.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,7 +18,7 @@
 package org.testingisdocumenting.webtau.expectation;
 
 public class ActualCode implements ActualCodeExpectations {
-    private CodeBlock actual;
+    private final CodeBlock actual;
 
     public ActualCode(CodeBlock actual) {
         this.actual = actual;
@@ -26,8 +27,23 @@ public ActualCode(CodeBlock actual) {
     @Override
     public void should(CodeMatcher codeMatcher) {
         boolean matches = codeMatcher.matches(actual);
-        if (! matches) {
-            throw new AssertionError("\n" + codeMatcher.mismatchedMessage(actual));
+
+        if (matches) {
+            handleMatch(codeMatcher);
+        } else {
+            handleMismatch(codeMatcher, codeMatcher.mismatchedMessage(actual));
+        }
+    }
+
+    private void handleMatch(CodeMatcher codeMatcher) {
+        ExpectationHandlers.onCodeMatch(codeMatcher);
+    }
+
+    private void handleMismatch(CodeMatcher codeMatcher, String message) {
+        final ExpectationHandler.Flow flow = ExpectationHandlers.onCodeMismatch(codeMatcher, message);
+
+        if (flow != ExpectationHandler.Flow.Terminate) {
+            throw new AssertionError("\n" + message);
         }
     }
 }
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualValue.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualValue.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +25,7 @@
 import static org.testingisdocumenting.webtau.WebTauCore.createActualPath;
 
 public class ActualValue implements ActualValueExpectations {
-    private Object actual;
+    private final Object actual;
 
     public ActualValue(Object actual) {
         this.actual = actual;
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualValueAware.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ActualValueAware.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2020 webtau maintainers
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.testingisdocumenting.webtau.expectation;
+
+public interface ActualValueAware {
+    Object actualValue();
+}
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ExpectationHandler.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ExpectationHandler.java
@@ -27,4 +27,10 @@ default Flow onValueMismatch(ValueMatcher valueMatcher, ActualPath actualPath, O
     }
 
     default void onValueMatch(ValueMatcher valueMatcher, ActualPath actualPath, Object actualValue) {}
+
+    default Flow onCodeMismatch(CodeMatcher codeMatcher, String message) {
+        return Flow.PassToNext;
+    }
+
+    default void onCodeMatch(CodeMatcher codeMatcher) {}
 }
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ExpectationHandlers.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/ExpectationHandlers.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,8 +26,8 @@
 import java.util.stream.Stream;
 
 public class ExpectationHandlers {
-    private static List<ExpectationHandler> globalHandlers = ServiceLoaderUtils.load(ExpectationHandler.class);
-    private static ThreadLocal<List<ExpectationHandler>> localHandlers = ThreadLocal.withInitial(ArrayList::new);
+    private static final List<ExpectationHandler> globalHandlers = ServiceLoaderUtils.load(ExpectationHandler.class);
+    private static final ThreadLocal<List<ExpectationHandler>> localHandlers = ThreadLocal.withInitial(ArrayList::new);
 
     public static void add(ExpectationHandler handler) {
         globalHandlers.add(handler);
@@ -60,6 +61,18 @@ public static Flow onValueMismatch(ValueMatcher valueMatcher, ActualPath actualP
                 .findFirst().orElse(Flow.PassToNext);
     }
 
+    public static void onCodeMatch(CodeMatcher codeMatcher) {
+        handlersStream().forEach(h -> h.onCodeMatch(codeMatcher));
+    }
+
+    public static Flow onCodeMismatch(CodeMatcher codeMatcher, String message) {
+        return handlersStream()
+                .map(h -> h.onCodeMismatch(codeMatcher, message))
+                .filter(flow -> flow == Flow.Terminate)
+                .findFirst().orElse(Flow.PassToNext);
+    }
+
+
     private static void addLocal(ExpectationHandler handler) {
         localHandlers.get().add(handler);
     }
diff --git a/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/code/ThrowExceptionMatcher.java b/webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/code/ThrowExceptionMatcher.java
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,18 +19,21 @@
 
 import static org.testingisdocumenting.webtau.WebTauCore.createActualPath;
 
+import org.testingisdocumenting.webtau.expectation.ActualValueAware;
 import org.testingisdocumenting.webtau.expectation.CodeBlock;
 import org.testingisdocumenting.webtau.expectation.CodeMatcher;
+import org.testingisdocumenting.webtau.expectation.ExpectedValuesAware;
 import org.testingisdocumenting.webtau.expectation.equality.CompareToComparator;
 import java.lang.reflect.UndeclaredThrowableException;
 import java.util.regex.Pattern;
+import java.util.stream.Stream;
 
-public class ThrowExceptionMatcher implements CodeMatcher {
+public class ThrowExceptionMatcher implements CodeMatcher, ExpectedValuesAware, ActualValueAware {
     private String expectedMessage;
     private Pattern expectedMessageRegexp;
-    private Class expectedClass;
+    private Class<?> expectedClass;
     private String thrownMessage;
-    private Class thrownClass;
+    private Class<?> thrownClass;
     private CompareToComparator comparator;
 
     public ThrowExceptionMatcher(String expectedMessage) {
@@ -40,16 +44,16 @@ public ThrowExceptionMatcher(Pattern expectedMessageRegexp) {
         this.expectedMessageRegexp = expectedMessageRegexp;
     }
 
-    public ThrowExceptionMatcher(Class expectedClass) {
+    public ThrowExceptionMatcher(Class<?> expectedClass) {
         this.expectedClass = expectedClass;
     }
 
-    public ThrowExceptionMatcher(Class expectedClass, Pattern expectedMessageRegexp) {
+    public ThrowExceptionMatcher(Class<?> expectedClass, Pattern expectedMessageRegexp) {
         this.expectedClass = expectedClass;
         this.expectedMessageRegexp = expectedMessageRegexp;
     }
 
-    public ThrowExceptionMatcher(Class expectedClass, String expectedMessage) {
+    public ThrowExceptionMatcher(Class<?> expectedClass, String expectedMessage) {
         this.expectedClass = expectedClass;
         this.expectedMessage = expectedMessage;
     }
@@ -112,4 +116,22 @@ private void extractExceptionDetails(Throwable t) {
             thrownClass = t.getClass();
         }
     }
+
+    @Override
+    public Stream<Object> expectedValues() {
+        if (expectedMessage != null) {
+            return Stream.of(expectedMessage);
+        }
+
+        if (expectedClass != null) {
+            return Stream.of(expectedClass);
+        }
+
+        return Stream.empty();
+    }
+
+    @Override
+    public Object actualValue() {
+        return thrownMessage;
+    }
 }
diff --git a/webtau-core/src/test/groovy/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertionTest.groovy b/webtau-core/src/test/groovy/org/testingisdocumenting/webtau/documentation/CoreDocumentationAssertionTest.groovy
@@ -64,9 +64,35 @@ class CoreDocumentationAssertionTest {
                 '} ]')
     }
 
+    @Test
+    void "should capture actual exception"() {
+        code {
+            throw new RuntimeException("actual full\nexception")
+        } should throwException(~/actual/)
+
+        doc.actual.capture(CoreDocumentationAssertionTest, "actual-exception")
+        validateArtifactContent("actual-exception", "txt",
+                "actual full\nexception")
+    }
+
+    @Test
+    void "should capture expected exception"() {
+        code {
+            throw new RuntimeException("actual full\nexception")
+        } should throwException(RuntimeException)
+
+        doc.expected.capture(CoreDocumentationAssertionTest, "expected-exception")
+        validateArtifactContent("expected-exception", "json",
+                '"java.lang.RuntimeException"')
+    }
+
     private static void validateArtifactContent(String artifactName, String expectedFileContent) {
+        validateArtifactContent(artifactName, "json", expectedFileContent)
+    }
+
+    private static void validateArtifactContent(String artifactName, String extension, String expectedFileContent) {
         def path = DocumentationArtifactsLocation.classBasedLocation(CoreDocumentationAssertionTest)
-                .resolve(artifactName + ".json")
+                .resolve(artifactName + "." + extension)
 
         actual(FileUtils.fileTextContent(path)).should(equal(expectedFileContent))
     }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`/*`
	`2`	`+ * Copyright 2020 webtau maintainers`
`2`	`3`	`* Copyright 2019 TWO SIGMA OPEN SOURCE, LLC`
`3`	`4`	`*`
`4`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`@@ -32,6 +33,6 @@ public class CoreDocumentationAssertionValue {`
`32`	`33`	`* @param artifactName artifact name (file name without extension)`
`33`	`34`	`*/`
`34`	`35`	`public void capture(Class<?> testClass, String artifactName) {`
`35`		`- DocumentationArtifacts.createAsJson(testClass, artifactName, valueSupplier.get());`
	`36`	`+ DocumentationArtifacts.createTextOrJson(testClass, artifactName, valueSupplier.get());`
`36`	`37`	`}`
`37`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,4 +27,10 @@ default Flow onValueMismatch(ValueMatcher valueMatcher, ActualPath actualPath, O`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`default void onValueMatch(ValueMatcher valueMatcher, ActualPath actualPath, Object actualValue) {}`
	`30`	`+`
	`31`	`+ default Flow onCodeMismatch(CodeMatcher codeMatcher, String message) {`
	`32`	`+ return Flow.PassToNext;`
	`33`	`+ }`
	`34`	`+`
	`35`	`+ default void onCodeMatch(CodeMatcher codeMatcher) {}`
`30`	`36`	`}`