cleanup

Author: lkts

test/framework/src/main/java/org/elasticsearch/logsdb/datageneration/matchers/source/DynamicFieldMatcher.java

@@ -10,6 +10,7 @@
 package org.elasticsearch.logsdb.datageneration.matchers.source;
 
 import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.logsdb.datageneration.matchers.ListEqualMatcher;
 import org.elasticsearch.logsdb.datageneration.matchers.MatchResult;
 import org.elasticsearch.xcontent.XContentBuilder;
 
@@ -46,9 +47,12 @@ class DynamicFieldMatcher {
      * @return {#{@link MatchResult}} if field values need special treatment by this matcher.
      * If field values can be matched using generic mapper, returns {@link Optional#empty()}.
      */
-    public Optional<MatchResult> match(List<Object> actual, List<Object> expected) {
+    public MatchResult match(List<Object> actual, List<Object> expected) {
         if (expected == null) {
-            return Optional.empty();
+            expected = List.of();
+        }
+        if (actual == null) {
+            actual = List.of();
         }
 
         // Floating point values are always mapped as float with dynamic mapping.
@@ -59,7 +63,7 @@ public Optional<MatchResult> match(List<Object> actual, List<Object> expected) {
             var normalizedActual = normalizeDoubles(actual);
             var normalizedExpected = normalizeDoubles(expected);
 
-            var matchResult = normalizedActual.equals(normalizedExpected)
+            return normalizedActual.equals(normalizedExpected)
                 ? MatchResult.match()
                 : MatchResult.noMatch(
                     formatErrorMessage(
@@ -71,10 +75,9 @@ public Optional<MatchResult> match(List<Object> actual, List<Object> expected) {
                             + prettyPrintCollections(normalizedActual, normalizedExpected)
                     )
                 );
-            return Optional.of(matchResult);
         }
 
-        return Optional.empty();
+        return matchWithGenericMatcher(actual, expected);
     }
 
     private static Set<Float> normalizeDoubles(List<Object> values) {
@@ -85,4 +88,18 @@ private static Set<Float> normalizeDoubles(List<Object> values) {
         Function<Object, Float> toFloat = (o) -> o instanceof Number n ? n.floatValue() : Float.parseFloat((String) o);
         return values.stream().filter(Objects::nonNull).map(toFloat).collect(Collectors.toSet());
     }
+
+    private MatchResult matchWithGenericMatcher(List<Object> actualValues, List<Object> expectedValues) {
+        var genericListMatcher = new ListEqualMatcher(
+            actualMappings,
+            actualSettings,
+            expectedMappings,
+            expectedSettings,
+            SourceTransforms.normalizeValues(actualValues),
+            SourceTransforms.normalizeValues(expectedValues),
+            true
+        );
+
+        return genericListMatcher.match();
+    }
 }

test/framework/src/main/java/org/elasticsearch/logsdb/datageneration/matchers/source/SourceMatcher.java

@@ -13,15 +13,13 @@
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.XContentHelper;
 import org.elasticsearch.logsdb.datageneration.matchers.GenericEqualsMatcher;
-import org.elasticsearch.logsdb.datageneration.matchers.ListEqualMatcher;
 import org.elasticsearch.logsdb.datageneration.matchers.MatchResult;
 import org.elasticsearch.xcontent.XContentBuilder;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 
 import static org.elasticsearch.logsdb.datageneration.matchers.Messages.formatErrorMessage;
 import static org.elasticsearch.logsdb.datageneration.matchers.Messages.prettyPrintCollections;
@@ -138,9 +136,7 @@ private MatchResult compareSource(Map<String, List<Object>> actual, Map<String,
             var actualValues = actual.get(name);
             var expectedValues = expectedFieldEntry.getValue();
 
-            var matchIncludingFieldSpecificMatchers = matchWithFieldSpecificMatcher(name, actualValues, expectedValues).orElseGet(
-                () -> matchWithGenericMatcher(actualValues, expectedValues)
-            );
+            var matchIncludingFieldSpecificMatchers = matchWithFieldSpecificMatcher(name, actualValues, expectedValues);
             if (matchIncludingFieldSpecificMatchers.isMatch() == false) {
                 var message = "Source documents don't match for field [" + name + "]: " + matchIncludingFieldSpecificMatchers.getMessage();
                 return MatchResult.noMatch(message);
@@ -149,7 +145,7 @@ private MatchResult compareSource(Map<String, List<Object>> actual, Map<String,
         return MatchResult.match();
     }
 
-    private Optional<MatchResult> matchWithFieldSpecificMatcher(String fieldName, List<Object> actualValues, List<Object> expectedValues) {
+    private MatchResult matchWithFieldSpecificMatcher(String fieldName, List<Object> actualValues, List<Object> expectedValues) {
         var actualFieldMapping = actualNormalizedMapping.get(fieldName);
         if (actualFieldMapping == null) {
             if (expectedNormalizedMapping.get(fieldName) != null
@@ -189,30 +185,13 @@ private Optional<MatchResult> matchWithFieldSpecificMatcher(String fieldName, Li
         }
 
         var fieldSpecificMatcher = fieldSpecificMatchers.get(actualFieldType);
-        if (fieldSpecificMatcher == null) {
-            return Optional.empty();
-        }
+        assert fieldSpecificMatcher != null : "Missing matcher for field type [" + actualFieldType + "]";
 
-        MatchResult matched = fieldSpecificMatcher.match(
+        return fieldSpecificMatcher.match(
             actualValues,
             expectedValues,
             actualFieldMapping.mappingParameters(),
             expectedFieldMapping.mappingParameters()
         );
-        return Optional.of(matched);
-    }
-
-    private MatchResult matchWithGenericMatcher(List<Object> actualValues, List<Object> expectedValues) {
-        var genericListMatcher = new ListEqualMatcher(
-            actualMappings,
-            actualSettings,
-            expectedMappings,
-            expectedSettings,
-            SourceTransforms.normalizeValues(actualValues),
-            SourceTransforms.normalizeValues(expectedValues),
-            true
-        );
-
-        return genericListMatcher.match();
     }
 }