matchers: notEqual matcher delegates to nested matcher (#1441)

Author: MykolaGolubyev

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/equality/EqualMatcher.java

@@ -65,7 +65,6 @@ public TokenizedMessage matchedTokenizedMessage(ValuePath actualPath, Object act
         return tokenizedMessage().matcher("equals").valueFirstLinesOnly(expected);
     }
 
-
     @Override
     public Set<ValuePath> matchedPaths() {
         if (expectedMatcher != null) {

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/equality/NotEqualMatcher.java

@@ -18,6 +18,7 @@
 package org.testingisdocumenting.webtau.expectation.equality;
 
 import org.testingisdocumenting.webtau.data.ValuePath;
+import org.testingisdocumenting.webtau.data.converters.ValueConverter;
 import org.testingisdocumenting.webtau.expectation.ExpectedValuesAware;
 import org.testingisdocumenting.webtau.expectation.ValueMatcher;
 import org.testingisdocumenting.webtau.reporter.TokenizedMessage;
@@ -30,51 +31,93 @@ public class NotEqualMatcher implements ValueMatcher, ExpectedValuesAware {
     private CompareToComparator comparator;
 
     private final Object expected;
+    private final ValueMatcher expectedMatcher;
 
     public NotEqualMatcher(Object expected) {
         this.expected = expected;
+        this.expectedMatcher = expected instanceof ValueMatcher ?
+                (ValueMatcher) expected :
+                null;
+    }
+
+    @Override
+    public ValueConverter valueConverter() {
+        return comparator == null ? ValueConverter.EMPTY : comparator.createValueConverter();
     }
 
     @Override
     public TokenizedMessage matchingTokenizedMessage(ValuePath actualPath, Object actual) {
-        comparator = CompareToComparator.comparator();
+        if (expectedMatcher != null) {
+            return expectedMatcher.negativeMatchingTokenizedMessage(actualPath, actual);
+        }
 
+        comparator = CompareToComparator.comparator();
         return tokenizedMessage().matcher("to not equal").valueFirstLinesOnly(expected);
     }
 
     @Override
     public TokenizedMessage matchedTokenizedMessage(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.negativeMatchedTokenizedMessage(actualPath, actual);
+        }
+
         return tokenizedMessage().matcher("doesn't equal").valueFirstLinesOnly(expected);
     }
 
     @Override
     public TokenizedMessage mismatchedTokenizedMessage(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.negativeMismatchedTokenizedMessage(actualPath, actual);
+        }
+
         return comparator.generateNotEqualMismatchReport();
     }
 
     @Override
     public boolean matches(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.negativeMatches(actualPath, actual);
+        }
+
+        comparator.resetReportData();
         return comparator.compareIsNotEqual(actualPath, actual, expected);
     }
 
     @Override
     public TokenizedMessage negativeMatchingTokenizedMessage(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.matchingTokenizedMessage(actualPath, actual);
+        }
+
         comparator = CompareToComparator.comparator();
         return tokenizedMessage().matcher("to equal").valueFirstLinesOnly(expected);
     }
 
     @Override
     public TokenizedMessage negativeMatchedTokenizedMessage(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.matchedTokenizedMessage(actualPath, actual);
+        }
+
         return tokenizedMessage().matcher("equals").valueFirstLinesOnly(expected);
     }
 
     @Override
     public TokenizedMessage negativeMismatchedTokenizedMessage(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.mismatchedTokenizedMessage(actualPath, actual);
+        }
+
         return comparator.generateEqualMismatchReport();
     }
 
     @Override
     public boolean negativeMatches(ValuePath actualPath, Object actual) {
+        if (expectedMatcher != null) {
+            return expectedMatcher.matches(actualPath, actual);
+        }
+
+        comparator.resetReportData();
         return comparator.compareIsEqual(actualPath, actual, expected);
     }
 

webtau-core/src/test/groovy/org/testingisdocumenting/webtau/expectation/equality/NotEqualMatcherTest.groovy

@@ -60,6 +60,40 @@ class NotEqualMatcherTest {
         }
     }
 
+    @Test
+    void "delegates to matcher in case of negative mismatch if passed as expected"() {
+        runExpectExceptionAndValidateOutput(AssertionError.class, 'X failed expecting [value] to not match any of [30, 100]:\n' +
+                '      actual: 100 <java.lang.Integer>\n' +
+                '    expected: not 100 <java.lang.Integer> (Xms)') {
+            actual(100).should(notEqual(anyOf(30, 100)))
+        }
+    }
+
+    @Test
+    void "delegates to matcher in case of negative match if passed as expected"() {
+        runAndValidateOutput(". [value] doesn't match any of [30, 110] (Xms)") {
+            actual(100).should(notEqual(anyOf(30, 110)))
+        }
+    }
+
+    @Test
+    void "delegates to matcher in case of positive mismatch if passed as expected"() {
+        runExpectExceptionAndValidateOutput(AssertionError.class, 'X failed expecting [value] to match any of [30, 110]:\n' +
+                '      actual: 100 <java.lang.Integer>\n' +
+                '    expected: 30 <java.lang.Integer>\n' +
+                '      actual: 100 <java.lang.Integer>\n' +
+                '    expected: 110 <java.lang.Integer> (Xms)') {
+            actual(100).shouldNot(notEqual(anyOf(30, 110)))
+        }
+    }
+
+    @Test
+    void "delegates to matcher in case of positive match if passed as expected"() {
+        runAndValidateOutput(". [value] matches any of [30, 100] (Xms)") {
+            actual(100).shouldNot(notEqual(anyOf(30, 100)))
+        }
+    }
+
     @Test
     void "matching message"() {
         assert matcher.matchingTokenizedMessage(actualPath, 100).toString() == "to not equal $expected"

webtau-docs/znai/release-notes/1.52/fix-2023-04-17-not-equal-matcher-delegate.md

@@ -0,0 +1 @@
+* Fix: `notEqual` [Matcher](matchers/introduction) now properly delegates to nested matcher such as `anyOf`