Simplify EsqlRestValidationTestCase (elastic#139193)

Author: idegtiarenko

x-pack/plugin/esql/qa/server/src/main/java/org/elasticsearch/xpack/esql/qa/rest/EsqlRestValidationTestCase.java

@@ -8,8 +8,6 @@
 package org.elasticsearch.xpack.esql.qa.rest;
 
 import org.elasticsearch.client.Request;
-import org.elasticsearch.client.RequestOptions;
-import org.elasticsearch.client.Response;
 import org.elasticsearch.client.ResponseException;
 import org.elasticsearch.client.RestClient;
 import org.elasticsearch.client.WarningsHandler;
@@ -20,6 +18,7 @@
 import org.junit.Before;
 
 import java.io.IOException;
+import java.util.List;
 
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -28,24 +27,6 @@ public abstract class EsqlRestValidationTestCase extends ESRestTestCase {
 
     private static final String indexName = "test_esql";
     private static final String aliasName = "alias-test_esql";
-    protected static final String[] existentIndexWithWildcard = new String[] {
-        indexName + ",inexistent*",
-        indexName + "*,inexistent*",
-        "inexistent*," + indexName };
-    private static final String[] existentIndexWithoutWildcard = new String[] { indexName + ",inexistent", "inexistent," + indexName };
-    protected static final String[] existentAliasWithWildcard = new String[] {
-        aliasName + ",inexistent*",
-        aliasName + "*,inexistent*",
-        "inexistent*," + aliasName };
-    private static final String[] existentAliasWithoutWildcard = new String[] { aliasName + ",inexistent", "inexistent," + aliasName };
-    private static final String[] inexistentIndexNameWithWildcard = new String[] { "inexistent*", "inexistent1*,inexistent2*" };
-    private static final String[] inexistentIndexNameWithoutWildcard = new String[] { "inexistent", "inexistent1,inexistent2" };
-    private static final String createAlias = "{\"actions\":[{\"add\":{\"index\":\"" + indexName + "\",\"alias\":\"" + aliasName + "\"}}]}";
-    private static final String removeAlias = "{\"actions\":[{\"remove\":{\"index\":\""
-        + indexName
-        + "\",\"alias\":\""
-        + aliasName
-        + "\"}}]}";
 
     @Before
     @After
@@ -73,79 +54,76 @@ public void wipeTestData() throws IOException {
         }
     }
 
-    private String getInexistentIndexErrorMessage() {
-        return "\"reason\" : \"Found 1 problem\\nline 1:1: Unknown index ";
-    }
-
-    public void testInexistentIndexNameWithWildcard() throws IOException {
-        assertErrorMessages(inexistentIndexNameWithWildcard, getInexistentIndexErrorMessage(), 400);
+    public void testInexistentIndexNameWithWildcard() {
+        for (String pattern : List.of("inexistent*", "inexistent1*,inexistent2*")) {
+            assertError(pattern, 400, "Found 1 problem\\nline 1:1: Unknown index [" + clusterSpecificIndexName(pattern) + "]");
+        }
     }
 
-    public void testInexistentIndexNameWithoutWildcard() throws IOException {
-        assertErrorMessages(inexistentIndexNameWithoutWildcard, getInexistentIndexErrorMessage(), 400);
+    public void testInexistentIndexNameWithoutWildcard() {
+        for (String pattern : List.of("inexistent", "inexistent1,inexistent2")) {
+            assertError(pattern, "Found 1 problem\\nline 1:1: Unknown index [" + clusterSpecificIndexName(pattern) + "]", 400);
+        }
     }
 
     public void testExistentIndexWithoutWildcard() throws IOException {
-        for (String indexName : existentIndexWithoutWildcard) {
-            assertErrorMessage(indexName, "\"reason\" : \"no such index [inexistent]\"", 404);
+        for (String pattern : List.of(indexName + ",inexistent", "inexistent," + indexName)) {
+            assertError(pattern, 404, "no such index [inexistent]");
         }
     }
 
     public void testExistentIndexWithWildcard() throws IOException {
-        assertValidRequestOnIndices(existentIndexWithWildcard);
+        for (String pattern : List.of(indexName + ",inexistent*", indexName + "*,inexistent*", "inexistent*," + indexName)) {
+            assertOK(client().performRequest(createRequest(pattern)));
+        }
     }
 
     public void testAlias() throws IOException {
-        createAlias();
+        updateAliases("""
+            {"actions":[{"add":{"index":"%s","alias":"%s"}}]}
+            """.formatted(indexName, aliasName));
 
-        for (String indexName : existentAliasWithoutWildcard) {
-            assertErrorMessage(indexName, "\"reason\" : \"no such index [inexistent]\"", 404);
+        for (String indexName : List.of(aliasName + ",inexistent", "inexistent," + aliasName)) {
+            assertError(indexName, "no such index [inexistent]", 404);
         }
-        assertValidRequestOnIndices(existentAliasWithWildcard);
-
-        deleteAlias();
-    }
-
-    private void assertErrorMessages(String[] indices, String errorMessage, int statusCode) throws IOException {
-        for (String indexName : indices) {
-            assertErrorMessage(indexName, errorMessage + "[" + clusterSpecificIndexName(indexName) + "]", statusCode);
+        for (String indexName : List.of(aliasName + ",inexistent*", aliasName + "*,inexistent*", "inexistent*," + aliasName)) {
+            assertOK(client().performRequest(createRequest(indexName)));
         }
+
+        updateAliases("""
+            {"actions":[{"remove":{"index":"%s","alias":"%s"}}]}
+            """.formatted(indexName, aliasName));
     }
 
     protected String clusterSpecificIndexName(String indexName) {
         return indexName;
     }
 
-    private void assertErrorMessage(String indexName, String errorMessage, int statusCode) throws IOException {
-        var specificName = clusterSpecificIndexName(indexName);
-        final var request = createRequest(specificName);
-        ResponseException exc = expectThrows(ResponseException.class, () -> client().performRequest(request));
+    private void assertError(String indexName, String errorMessage, int statusCode) {
+        ResponseException exc = expectThrows(ResponseException.class, () -> client().performRequest(createRequest(indexName)));
+        assertThat(exc.getResponse().getStatusLine().getStatusCode(), equalTo(statusCode));
+        assertThat(exc.getMessage(), containsString("\"reason\" : \"" + errorMessage + "\""));
+    }
 
+    private void assertError(String indexName, int statusCode, String errorMessage) {
+        ResponseException exc = expectThrows(ResponseException.class, () -> client().performRequest(createRequest(indexName)));
         assertThat(exc.getResponse().getStatusLine().getStatusCode(), equalTo(statusCode));
-        assertThat(exc.getMessage(), containsString(errorMessage));
+        assertThat(exc.getMessage(), containsString("\"reason\" : \"" + errorMessage + "\""));
     }
 
     private Request createRequest(String indexName) throws IOException {
         final var request = new Request("POST", "/_query");
         request.addParameter("error_trace", "true");
         request.addParameter("pretty", "true");
         request.setJsonEntity(
-            Strings.toString(JsonXContent.contentBuilder().startObject().field("query", "from " + indexName).endObject())
+            Strings.toString(
+                JsonXContent.contentBuilder().startObject().field("query", "from " + clusterSpecificIndexName(indexName)).endObject()
+            )
         );
-        RequestOptions.Builder options = request.getOptions().toBuilder();
-        options.setWarningsHandler(WarningsHandler.PERMISSIVE);
-        request.setOptions(options);
+        request.setOptions(request.getOptions().toBuilder().setWarningsHandler(WarningsHandler.PERMISSIVE));
         return request;
     }
 
-    private void assertValidRequestOnIndices(String[] indices) throws IOException {
-        for (String indexName : indices) {
-            final var request = createRequest(clusterSpecificIndexName(indexName));
-            Response response = client().performRequest(request);
-            assertOK(response);
-        }
-    }
-
     // Returned client is used to load the test data, either in the local cluster or a remote one (for
     // multi-clusters). The client()/adminClient() will always connect to the local cluster
     protected RestClient provisioningClient() throws IOException {
@@ -156,15 +134,9 @@ protected RestClient provisioningAdminClient() throws IOException {
         return adminClient();
     }
 
-    private void createAlias() throws IOException {
+    private void updateAliases(String update) throws IOException {
         var r = new Request("POST", "_aliases");
-        r.setJsonEntity(createAlias);
+        r.setJsonEntity(update);
         assertOK(provisioningClient().performRequest(r));
     }
-
-    private void deleteAlias() throws IOException {
-        var r = new Request("POST", "/_aliases/");
-        r.setJsonEntity(removeAlias);
-        assertOK(provisioningAdminClient().performRequest(r));
-    }
 }