Simplify tests

Author: carlosdelest

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/VerifierTests.java

@@ -1341,31 +1341,17 @@ public void testNonFieldBasedFullTextFunctionsNotAllowedAfterCommands(String fun
         );
     }
 
-    public void testQueryStringFunctionOnlyAllowedInWhere() throws Exception {
-        assertEquals("1:9: [QSTR] function is only supported in WHERE and STATS commands", error("row a = qstr(\"Anna\")"));
-        checkFullTextFunctionsOnlyAllowedInWhere("QSTR", "qstr(\"Anna\")", "function");
-    }
-
-    public void testKqlFunctionOnlyAllowedInWhere() throws Exception {
-        assertEquals("1:9: [KQL] function is only supported in WHERE and STATS commands", error("row a = kql(\"Anna\")"));
-        checkFullTextFunctionsOnlyAllowedInWhere("KQL", "kql(\"Anna\")", "function");
-    }
-
-    public void testMatchFunctionOnlyAllowedInWhere() throws Exception {
+    public void testFullTextFunctionsOnlyAllowedInWhere() throws Exception {
         checkFullTextFunctionsOnlyAllowedInWhere("MATCH", "match(first_name, \"Anna\")", "function");
-    }
-
-    public void testTermFunctionOnlyAllowedInWhere() throws Exception {
-        assumeTrue("term function capability not available", EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled());
-        checkFullTextFunctionsOnlyAllowedInWhere("Term", "term(first_name, \"Anna\")", "function");
-    }
-
-    public void testMatchOperatornOnlyAllowedInWhere() throws Exception {
         checkFullTextFunctionsOnlyAllowedInWhere(":", "first_name:\"Anna\"", "operator");
-    }
-
-    public void testKnnFunctionOnlyAllowedInWhere() throws Exception {
-        checkFullTextFunctionsOnlyAllowedInWhere("KNN", "knn(vector, [1, 2, 3])", "function");
+        checkFullTextFunctionsOnlyAllowedInWhere("QSTR", "qstr(\"Anna\")", "function");
+        checkFullTextFunctionsOnlyAllowedInWhere("KQL", "kql(\"Anna\")", "function");
+        if (EsqlCapabilities.Cap.KNN_FUNCTION.isEnabled()) {
+            checkFullTextFunctionsOnlyAllowedInWhere("KNN", "knn(vector, [1, 2, 3])", "function");
+        }
+        if (EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled()) {
+            checkFullTextFunctionsOnlyAllowedInWhere("Term", "term(first_name, \"Anna\")", "function");
+        }
     }
 
     private void checkFullTextFunctionsOnlyAllowedInWhere(String functionName, String functionInvocation, String functionType)
@@ -1382,6 +1368,12 @@ private void checkFullTextFunctionsOnlyAllowedInWhere(String functionName, Strin
             "1:47: [" + functionName + "] " + functionType + " is only supported in WHERE and STATS commands",
             error("from test | stats max_salary = max(salary) by " + functionInvocation)
         );
+        if( "KQL".equals(functionName) || "QSTR".equals(functionName)) {
+            assertEquals(
+                "1:9: [" + functionName + "] " + functionType + " is only supported in WHERE and STATS commands",
+                error("row a = " + functionInvocation)
+            );
+        }
     }
 
     public void testQueryStringFunctionArgNotNullOrConstant() throws Exception {
@@ -1456,25 +1448,20 @@ private void checkWithFullTextFunctionsDisjunctions(String functionInvocation) {
 
     }
 
-    public void testQueryStringFunctionWithNonBooleanFunctions() {
-        checkFullTextFunctionsWithNonBooleanFunctions("QSTR", "qstr(\"first_name: Anna\")", "function");
-    }
-
-    public void testKqlFunctionWithNonBooleanFunctions() {
-        checkFullTextFunctionsWithNonBooleanFunctions("KQL", "kql(\"first_name: Anna\")", "function");
-    }
-
-    public void testMatchFunctionWithNonBooleanFunctions() {
+    public void testFullTextFunctionsWithNonBooleanFunctions() {
         checkFullTextFunctionsWithNonBooleanFunctions("MATCH", "match(first_name, \"Anna\")", "function");
-    }
-
-    public void testTermFunctionWithNonBooleanFunctions() {
-        assumeTrue("term function capability not available", EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled());
-        checkFullTextFunctionsWithNonBooleanFunctions("Term", "term(first_name, \"Anna\")", "function");
-    }
-
-    public void testMatchOperatorWithNonBooleanFunctions() {
         checkFullTextFunctionsWithNonBooleanFunctions(":", "first_name:\"Anna\"", "operator");
+        checkFullTextFunctionsWithNonBooleanFunctions("QSTR", "qstr(\"first_name: Anna\")", "function");
+        checkFullTextFunctionsWithNonBooleanFunctions("KQL", "kql(\"first_name: Anna\")", "function");
+        if (EsqlCapabilities.Cap.MULTI_MATCH_FUNCTION.isEnabled()) {
+            checkFullTextFunctionsWithNonBooleanFunctions("MultiMatch", "multi_match(\"Anna\", first_name, last_name)", "function");
+        }
+        if (EsqlCapabilities.Cap.KNN_FUNCTION.isEnabled()) {
+            checkFullTextFunctionsWithNonBooleanFunctions("KNN", "knn(vector, [1, 2, 3])", "function");
+        }
+        if (EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled()) {
+            checkFullTextFunctionsWithNonBooleanFunctions("Term", "term(first_name, \"Anna\")", "function");
+        }
     }
 
     private void checkFullTextFunctionsWithNonBooleanFunctions(String functionName, String functionInvocation, String functionType) {
@@ -1545,18 +1532,6 @@ public void testMatchFunctionArgNotConstant() throws Exception {
         // Other value types are tested in QueryStringFunctionTests
     }
 
-    // These should pass eventually once we lift some restrictions on match function
-    public void testMatchFunctionCurrentlyUnsupportedBehaviour() throws Exception {
-        assertEquals(
-            "1:68: Unknown column [first_name]",
-            error("from test | stats max_salary = max(salary) by emp_no | where match(first_name, \"Anna\")")
-        );
-        assertEquals(
-            "1:62: Unknown column [first_name]",
-            error("from test | stats max_salary = max(salary) by emp_no | where first_name : \"Anna\"")
-        );
-    }
-
     public void testMatchFunctionNullArgs() throws Exception {
         assertEquals(
             "1:19: first argument of [match(null, \"query\")] cannot be null, received [null]",
@@ -1586,15 +1561,6 @@ public void testTermFunctionArgNotConstant() throws Exception {
         // Other value types are tested in QueryStringFunctionTests
     }
 
-    // These should pass eventually once we lift some restrictions on match function
-    public void testTermFunctionCurrentlyUnsupportedBehaviour() throws Exception {
-        assumeTrue("term function capability not available", EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled());
-        assertEquals(
-            "1:67: Unknown column [first_name]",
-            error("from test | stats max_salary = max(salary) by emp_no | where term(first_name, \"Anna\")")
-        );
-    }
-
     public void testTermFunctionNullArgs() throws Exception {
         assumeTrue("term function capability not available", EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled());
         assertEquals(
@@ -2124,21 +2090,15 @@ public void testLookupJoinDataTypeMismatch() {
         );
     }
 
-    public void testMatchOptions() {
+    public void testFullTextFunctionOptions() {
         checkOptionDataTypes(Match.ALLOWED_OPTIONS, "FROM test | WHERE match(first_name, \"Jean\", {\"%s\": %s})");
-    }
-
-    public void testMultiMatchOptions() {
-        checkOptionDataTypes(MultiMatch.OPTIONS, "FROM test | WHERE MULTI_MATCH(\"Jean\", first_name, last_name, {\"%s\": %s})");
-    }
-
-    public void testQueryStringOptions() {
         checkOptionDataTypes(QueryString.ALLOWED_OPTIONS, "FROM test | WHERE QSTR(\"first_name: Jean\", {\"%s\": %s})");
-    }
-
-    public void testKnnOptions() {
-        assumeTrue("knn must be enabled", EsqlCapabilities.Cap.KNN_FUNCTION.isEnabled());
-        checkOptionDataTypes(Knn.ALLOWED_OPTIONS, "FROM test | WHERE KNN(vector, [0.1, 0.2, 0.3], {\"%s\": %s})");
+        if (EsqlCapabilities.Cap.MULTI_MATCH_FUNCTION.isEnabled()){
+            checkOptionDataTypes(MultiMatch.OPTIONS, "FROM test | WHERE MULTI_MATCH(\"Jean\", first_name, last_name, {\"%s\": %s})");
+        }
+        if (EsqlCapabilities.Cap.KNN_FUNCTION.isEnabled()) {
+            checkOptionDataTypes(Knn.ALLOWED_OPTIONS, "FROM test | WHERE KNN(vector, [0.1, 0.2, 0.3], {\"%s\": %s})");
+        }
     }
 
     /**
@@ -2189,39 +2149,6 @@ private static String exampleValueForType(DataType currentType) {
         };
     }
 
-    public void testMultiMatchFunctionIsNotNullable() {
-        assertEquals(
-            "1:62: [MultiMatch] function cannot operate on [text::keyword], which is not a field from an index mapping",
-            error("row n = null | eval text = n + 5 | where multi_match(\"Anna\", text::keyword)")
-        );
-    }
-
-    public void testMultiMatchWithNonIndexedColumnCurrentlyUnsupported() {
-        assertEquals(
-            "1:78: [MultiMatch] function cannot operate on [initial], which is not a field from an index mapping",
-            error("from test | eval initial = substring(first_name, 1) | where multi_match(\"A\", initial)")
-        );
-        assertEquals(
-            "1:80: [MultiMatch] function cannot operate on [text], which is not a field from an index mapping",
-            error("from test | eval text=concat(first_name, last_name) | where multi_match(\"cat\", text)")
-        );
-    }
-
-    public void testMultiMatchFunctionNotAllowedAfterCommands() throws Exception {
-        assertEquals(
-            "1:24: [MultiMatch] function cannot be used after LIMIT",
-            error("from test | limit 10 | where multi_match(\"Anna\", first_name)")
-        );
-        assertEquals(
-            "1:47: [MultiMatch] function cannot be used after STATS",
-            error("from test | STATS c = AVG(salary) BY gender | where multi_match(\"F\", gender)")
-        );
-    }
-
-    public void testMultiMatchFunctionWithNonBooleanFunctions() {
-        checkFullTextFunctionsWithNonBooleanFunctions("MultiMatch", "multi_match(\"Anna\", first_name, last_name)", "function");
-    }
-
     public void testMultiMatchFunctionArgNotConstant() throws Exception {
         assertEquals(
             "1:19: second argument of [match(first_name, first_name)] must be a constant, received [first_name]",
@@ -2231,14 +2158,24 @@ public void testMultiMatchFunctionArgNotConstant() throws Exception {
             "1:59: second argument of [match(first_name, query)] must be a constant, received [query]",
             error("from test | eval query = concat(\"first\", \" name\") | where match(first_name, query)")
         );
-        // Other value types are tested in QueryStringFunctionTests
     }
 
-    // Should pass eventually once we lift some restrictions on the multi-match function.
+    // Should pass eventually once we lift some restrictions on full text search functions.
     public void testMultiMatchFunctionCurrentlyUnsupportedBehaviour() throws Exception {
-        assertEquals(
-            "1:82: Unknown column [first_name]\nline 1:94: Unknown column [last_name]",
-            error("from test | stats max_salary = max(salary) by emp_no | where multi_match(\"Anna\", first_name, last_name)")
+        testFullTextFunctionsCurrentlyUnsupportedBehaviour("match(first_name, \"Anna\")");
+        testFullTextFunctionsCurrentlyUnsupportedBehaviour("first_name : \"Anna\"");
+        if (EsqlCapabilities.Cap.MULTI_MATCH_FUNCTION.isEnabled()) {
+            testFullTextFunctionsCurrentlyUnsupportedBehaviour("multi_match(\"Anna\", first_name)");
+        }
+        if (EsqlCapabilities.Cap.TERM_FUNCTION.isEnabled()) {
+            testFullTextFunctionsCurrentlyUnsupportedBehaviour("term(first_name, \"Anna\")");
+        }
+    }
+
+    private void testFullTextFunctionsCurrentlyUnsupportedBehaviour(String functionInvocation) throws Exception {
+        assertThat(
+            error("from test | stats max_salary = max(salary) by emp_no | where " + functionInvocation),
+            containsString("Unknown column [first_name]")
         );
     }