Refactor tests

Author: carlosdelest

x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/LuceneQueryEvaluatorTests.java

@@ -29,6 +29,7 @@
 import org.elasticsearch.compute.data.BytesRefVector;
 import org.elasticsearch.compute.data.DocBlock;
 import org.elasticsearch.compute.data.DoubleBlock;
+import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.data.Vector;
@@ -71,7 +72,7 @@ public void testDenseCollectorSmall() throws IOException {
             collector.finish();
             try (T result = (T) collector.build()) {
                 for (int i = 0; i <= 2; i++) {
-                    assertEquals(getValueAt(result, i), valueForMatch());
+                    assertCollectedResultMatch(result, i, true);
                 }
             }
         }
@@ -86,7 +87,7 @@ public void testDenseCollectorSimple() throws IOException {
             collector.finish();
             try (T result = (T) collector.build()) {
                 for (int i = 0; i < 11; i++) {
-                    assertEquals(getValueAt(result, i), i == 2 || i == 5 ? valueForMatch() : valueForNoMatch());
+                    assertCollectedResultMatch(result, i, i == 2 || i == 5);
                 }
             }
         }
@@ -109,12 +110,22 @@ public void testDenseCollector() throws IOException {
             collector.finish();
             try (T result = (T) collector.build()) {
                 for (int i = 0; i < length; i++) {
-                    assertEquals(getValueAt(result, i), expected[i] ? valueForMatch() : valueForNoMatch());
+                    assertCollectedResultMatch(result, i, expected[i]);
                 }
             }
         }
     }
 
+    /**
+     * Create a dense collector for the given range.
+     */
+    protected abstract LuceneQueryEvaluator.DenseCollector<U> createDenseCollector(int min, int max);
+
+    /**
+     * Chceks that the collected results at the given position corresponds to a match or no match
+     */
+    protected abstract void assertCollectedResultMatch(T resultVector, int position, boolean isMatch);
+
     public void testTermQuery() throws IOException {
         Set<String> values = values();
         String term = values.iterator().next();
@@ -162,7 +173,7 @@ protected void assertTermsQuery(List<Page> results, Set<String> matching, int ex
             for (int i = 0; i < page.getPositionCount(); i++) {
                 BytesRef termAtPosition = terms.getBytesRef(i, new BytesRef());
                 boolean isMatch = matching.contains(termAtPosition.utf8ToString());
-                assertResultMatch(resultVector, i, isMatch);
+                assertTermResultMatch(resultVector, i, isMatch);
                 if (isMatch) {
                     matchCount++;
                 }
@@ -171,7 +182,10 @@ protected void assertTermsQuery(List<Page> results, Set<String> matching, int ex
         assertThat(matchCount, equalTo(expectedMatchCount));
     }
 
-    protected abstract void assertResultMatch(T resultVector, int position, boolean isMatch);
+    /**
+     * Checks that the result at the given position corresponds to a term match or no match
+     */
+    protected abstract void assertTermResultMatch(T resultVector, int position, boolean isMatch);
 
     private List<Page> runQuery(Set<String> values, Query query, boolean shuffleDocs) throws IOException {
         DriverContext driverContext = driverContext();
@@ -278,31 +292,11 @@ private static LuceneOperator.Factory luceneOperatorFactory(IndexReader reader,
     // Returns the block index for the results to check
     protected abstract int resultsBlockIndex(Page page);
 
-    /**
-     * Create a dense collector for the given range.
-     */
-    protected abstract LuceneQueryEvaluator.DenseCollector<U> createDenseCollector(int min, int max);
-
     /**
      * Returns a test scorer to use for scoring docs. Can be null
      */
     protected abstract Scorable getScorer();
 
-    /**
-     * Retrieves the value at a given index from the vector. Need to do this as Vector does not export a generic get() method
-     */
-    protected abstract Object getValueAt(T vector, int i);
-
-    /**
-     * Value that should be returned for a matching doc from the resulting vector
-     */
-    protected abstract Object valueForMatch();
-
-    /**
-     * Value that should be returned for a non-matching doc from the resulting vector
-     */
-    protected abstract Object valueForNoMatch();
-
     /**
      * Create the operator to test
      */

x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/LuceneQueryExpressionEvaluatorTests.java

@@ -8,20 +8,13 @@
 package org.elasticsearch.compute.lucene;
 
 import org.apache.lucene.search.Scorable;
-import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.BlockFactory;
-import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.BytesRefVector;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.lucene.LuceneQueryEvaluator.DenseCollector;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.compute.operator.Operator;
 
-import java.util.List;
-import java.util.Set;
-
 import static org.hamcrest.Matchers.equalTo;
 
 public class LuceneQueryExpressionEvaluatorTests extends LuceneQueryEvaluatorTests<BooleanVector, BooleanVector.Builder> {
@@ -43,21 +36,6 @@ protected Scorable getScorer() {
         return null;
     }
 
-    @Override
-    protected Object getValueAt(BooleanVector vector, int i) {
-        return vector.getBoolean(i);
-    }
-
-    @Override
-    protected Object valueForMatch() {
-        return true;
-    }
-
-    @Override
-    protected Object valueForNoMatch() {
-        return false;
-    }
-
     @Override
     protected Operator createOperator(BlockFactory blockFactory, LuceneQueryEvaluator.ShardConfig[] shards) {
         return new EvalOperator(blockFactory,  new LuceneQueryExpressionEvaluator(
@@ -78,7 +56,12 @@ protected int resultsBlockIndex(Page page) {
     }
 
     @Override
-    protected void assertResultMatch(BooleanVector resultVector, int position, boolean isMatch) {
+    protected void assertCollectedResultMatch(BooleanVector resultVector, int position, boolean isMatch) {
+        assertThat(resultVector.getBoolean(position), equalTo(isMatch));
+    }
+
+    @Override
+    protected void assertTermResultMatch(BooleanVector resultVector, int position, boolean isMatch) {
         assertThat(resultVector.getBoolean(position), equalTo(isMatch));
     }
 }

x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/LuceneQueryScoreEvaluatorTests.java

@@ -45,21 +45,6 @@ public float score() throws IOException {
         };
     }
 
-    @Override
-    protected Object getValueAt(DoubleVector vector, int i) {
-        return vector.getDouble(i);
-    }
-
-    @Override
-    protected Object valueForMatch() {
-        return (double) TEST_SCORE;
-    }
-
-    @Override
-    protected Object valueForNoMatch() {
-        return NO_MATCH_SCORE;
-    }
-
     @Override
     protected Operator createOperator(BlockFactory blockFactory, LuceneQueryEvaluator.ShardConfig[] shards) {
         return new ScoreOperator(blockFactory, new LuceneQueryScoreEvaluator(blockFactory, shards), 1);
@@ -72,12 +57,22 @@ protected boolean usesScoring() {
 
     @Override
     protected int resultsBlockIndex(Page page) {
-        // Uses the score block
+        // Reuses the score block
         return 1;
     }
 
     @Override
-    protected void assertResultMatch(DoubleVector resultVector, int position, boolean isMatch) {
+    protected void assertCollectedResultMatch(DoubleVector resultVector, int position, boolean isMatch) {
+        if (isMatch) {
+            assertThat(resultVector.getDouble(position), equalTo((double)TEST_SCORE));
+        } else {
+            // All docs have a default score coming from Lucene
+            assertThat(resultVector.getDouble(position), equalTo(NO_MATCH_SCORE));
+        }
+    }
+
+        @Override
+    protected void assertTermResultMatch(DoubleVector resultVector, int position, boolean isMatch) {
         if (isMatch) {
             assertThat(resultVector.getDouble(position), greaterThan(DEFAULT_SCORE));
         } else {