test!

Author: nik9000

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/querydsl/query/SingleValueQueryTests.java

@@ -31,6 +31,7 @@
 import org.elasticsearch.xcontent.XContentBuilder;
 import org.elasticsearch.xpack.esql.core.querydsl.query.MatchAll;
 import org.elasticsearch.xpack.esql.core.querydsl.query.RangeQuery;
+import org.elasticsearch.xpack.esql.core.querydsl.query.TermQuery;
 import org.elasticsearch.xpack.esql.core.tree.Source;
 
 import java.io.IOException;
@@ -46,12 +47,14 @@ interface Setup {
         XContentBuilder mapping(XContentBuilder builder) throws IOException;
 
         List<List<Object>> build(RandomIndexWriter iw) throws IOException;
+
+        boolean useSyntheticSourceDelegate();
     }
 
     @ParametersFactory
     public static List<Object[]> params() {
         List<Object[]> params = new ArrayList<>();
-        for (String fieldType : new String[] { "long", "integer", "short", "byte", "double", "float", "keyword" }) {
+        for (String fieldType : new String[] { "long", "integer", "short", "byte", "double", "float", "keyword", "text" }) {
             for (boolean multivaluedField : new boolean[] { true, false }) {
                 for (boolean allowEmpty : new boolean[] { true, false }) {
                     params.add(new Object[] { new StandardSetup(fieldType, multivaluedField, allowEmpty, 100) });
@@ -69,54 +72,66 @@ public SingleValueQueryTests(Setup setup) {
     }
 
     public void testMatchAll() throws IOException {
-        testCase(new SingleValueQuery(new MatchAll(Source.EMPTY), "foo", false).asBuilder(), this::runCase);
+        testCase(new SingleValueQuery(new MatchAll(Source.EMPTY), "foo", setup.useSyntheticSourceDelegate()).asBuilder(), this::runCase);
     }
 
     public void testMatchSome() throws IOException {
         int max = between(1, 100);
         testCase(
-            new SingleValueQuery.Builder(new RangeQueryBuilder("i").lt(max), "foo", Source.EMPTY),
+            new SingleValueQuery(
+                new RangeQuery(Source.EMPTY, "i", null, false, max, false, randomZone()),
+                "foo",
+                setup.useSyntheticSourceDelegate()
+            ).asBuilder(),
             (fieldValues, count) -> runCase(fieldValues, count, null, max)
         );
     }
 
     public void testSubPhrase() throws IOException {
-        testCase(new SingleValueQuery.Builder(new MatchPhraseQueryBuilder("str", "fox jumped"), "foo", Source.EMPTY), this::runCase);
+        SingleValueQuery.AbstractBuilder builder = setup.useSyntheticSourceDelegate()
+            ? new SingleValueQuery.SyntheticSourceDelegateBuilder(new MatchPhraseQueryBuilder("str", "fox jumped"), "foo", Source.EMPTY)
+            : new SingleValueQuery.Builder(new MatchPhraseQueryBuilder("str", "fox jumped"), "foo", Source.EMPTY);
+        testCase(builder, this::runCase);
     }
 
     public void testMatchNone() throws IOException {
         testCase(
-            new SingleValueQuery.Builder(new MatchNoneQueryBuilder(), "foo", Source.EMPTY),
+            new SingleValueQuery(new MatchAll(Source.EMPTY).negate(Source.EMPTY), "foo", setup.useSyntheticSourceDelegate()).asBuilder(),
             (fieldValues, count) -> assertThat(count, equalTo(0))
         );
     }
 
     public void testRewritesToMatchNone() throws IOException {
         testCase(
-            new SingleValueQuery.Builder(new TermQueryBuilder("missing", 0), "foo", Source.EMPTY),
+            new SingleValueQuery(new TermQuery(Source.EMPTY, "missing", 0), "foo", setup.useSyntheticSourceDelegate()).asBuilder(),
             (fieldValues, count) -> assertThat(count, equalTo(0))
         );
     }
 
     public void testNotMatchAll() throws IOException {
         testCase(
-            new SingleValueQuery(new MatchAll(Source.EMPTY), "foo", false).negate(Source.EMPTY).asBuilder(),
+            new SingleValueQuery(new MatchAll(Source.EMPTY), "foo", setup.useSyntheticSourceDelegate()).negate(Source.EMPTY).asBuilder(),
             (fieldValues, count) -> assertThat(count, equalTo(0))
         );
     }
 
     public void testNotMatchNone() throws IOException {
         testCase(
-            new SingleValueQuery(new MatchAll(Source.EMPTY).negate(Source.EMPTY), "foo", false).negate(Source.EMPTY).asBuilder(),
+            new SingleValueQuery(new MatchAll(Source.EMPTY).negate(Source.EMPTY), "foo", setup.useSyntheticSourceDelegate()).negate(
+                Source.EMPTY
+            ).asBuilder(),
             this::runCase
         );
     }
 
     public void testNotMatchSome() throws IOException {
         int max = between(1, 100);
         testCase(
-            new SingleValueQuery(new RangeQuery(Source.EMPTY, "i", null, false, max, false, null), "foo", false).negate(Source.EMPTY)
-                .asBuilder(),
+            new SingleValueQuery(
+                new RangeQuery(Source.EMPTY, "i", null, false, max, false, null),
+                "foo",
+                setup.useSyntheticSourceDelegate()
+            ).negate(Source.EMPTY).asBuilder(),
             (fieldValues, count) -> runCase(fieldValues, count, max, 100)
         );
     }
@@ -186,7 +201,13 @@ private record StandardSetup(String fieldType, boolean multivaluedField, boolean
         public XContentBuilder mapping(XContentBuilder builder) throws IOException {
             builder.startObject("i").field("type", "long").endObject();
             builder.startObject("str").field("type", "text").endObject();
-            return builder.startObject("foo").field("type", fieldType).endObject();
+            builder.startObject("foo").field("type", fieldType);
+            if (fieldType.equals("text")) {
+                builder.startObject("fields");
+                builder.startObject("raw").field("type", "keyword").field("ignore_above", 256).endObject();
+                builder.endObject();
+            }
+            return builder.endObject();
         }
 
         @Override
@@ -200,6 +221,11 @@ public List<List<Object>> build(RandomIndexWriter iw) throws IOException {
             return fieldValues;
         }
 
+        @Override
+        public boolean useSyntheticSourceDelegate() {
+            return fieldType.equals("text");
+        }
+
         private List<Object> values(int i) {
             // i == 10 forces at least one multivalued field when we're configured for multivalued fields
             boolean makeMultivalued = multivaluedField && (i == 10 || randomBoolean());
@@ -226,7 +252,7 @@ private Object randomValue() {
                 case "byte" -> randomByte();
                 case "double" -> randomDouble();
                 case "float" -> randomFloat();
-                case "keyword" -> randomAlphaOfLength(5);
+                case "keyword", "text" -> randomAlphaOfLength(5);
                 default -> throw new UnsupportedOperationException();
             };
         }
@@ -253,6 +279,12 @@ private List<IndexableField> docFor(int i, Iterable<Object> values) {
                         fields.add(new KeywordField("foo", v.toString(), Field.Store.NO));
                     }
                 }
+                case "text" -> {
+                    for (Object v : values) {
+                        fields.add(new TextField("foo", v.toString(), Field.Store.NO));
+                        fields.add(new KeywordField("foo.raw", v.toString(), Field.Store.NO));
+                    }
+                }
                 default -> throw new UnsupportedOperationException();
             }
             return fields;
@@ -280,5 +312,10 @@ public List<List<Object>> build(RandomIndexWriter iw) throws IOException {
             }
             return fieldValues;
         }
+
+        @Override
+        public boolean useSyntheticSourceDelegate() {
+            return randomBoolean();
+        }
     }
 }