Fix wait_for_no_initializing_shards params (#58379)

Author: weizijun

server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterHealthAction.java

@@ -56,6 +56,11 @@ public String getName() {
 
     @Override
     public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
+        final ClusterHealthRequest clusterHealthRequest = fromRequest(request);
+        return channel -> client.admin().cluster().health(clusterHealthRequest, new RestStatusToXContentListener<>(channel));
+    }
+
+    public static ClusterHealthRequest fromRequest(final RestRequest request) {
         final ClusterHealthRequest clusterHealthRequest = clusterHealthRequest(Strings.splitStringByCommaToArray(request.param("index")));
         clusterHealthRequest.indicesOptions(IndicesOptions.fromRequest(request, clusterHealthRequest.indicesOptions()));
         clusterHealthRequest.local(request.paramAsBoolean("local", clusterHealthRequest.local()));
@@ -68,11 +73,11 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         clusterHealthRequest.waitForNoRelocatingShards(
             request.paramAsBoolean("wait_for_no_relocating_shards", clusterHealthRequest.waitForNoRelocatingShards()));
         clusterHealthRequest.waitForNoInitializingShards(
-            request.paramAsBoolean("wait_for_no_initializing_shards", clusterHealthRequest.waitForNoRelocatingShards()));
+            request.paramAsBoolean("wait_for_no_initializing_shards", clusterHealthRequest.waitForNoInitializingShards()));
         if (request.hasParam("wait_for_relocating_shards")) {
             // wait_for_relocating_shards has been removed in favor of wait_for_no_relocating_shards
             throw new IllegalArgumentException("wait_for_relocating_shards has been removed, " +
-                                               "use wait_for_no_relocating_shards [true/false] instead");
+                "use wait_for_no_relocating_shards [true/false] instead");
         }
         String waitForActiveShards = request.param("wait_for_active_shards");
         if (waitForActiveShards != null) {
@@ -82,7 +87,7 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         if (request.param("wait_for_events") != null) {
             clusterHealthRequest.waitForEvents(Priority.valueOf(request.param("wait_for_events").toUpperCase(Locale.ROOT)));
         }
-        return channel -> client.admin().cluster().health(clusterHealthRequest, new RestStatusToXContentListener<>(channel));
+        return clusterHealthRequest;
     }
 
     private static final Set<String> RESPONSE_PARAMS = Collections.singleton("level");

server/src/test/java/org/elasticsearch/rest/action/admin/cluster/RestClusterHealthActionTests.java

@@ -0,0 +1,89 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.rest.action.admin.cluster;
+
+import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
+import org.elasticsearch.action.support.ActiveShardCount;
+import org.elasticsearch.cluster.health.ClusterHealthStatus;
+import org.elasticsearch.common.Priority;
+import org.elasticsearch.common.unit.TimeValue;
+import org.elasticsearch.rest.RestRequest;
+import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.test.rest.FakeRestRequest;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.hamcrest.Matchers.equalTo;
+
+public class RestClusterHealthActionTests extends ESTestCase {
+
+    public void testFromRequest() {
+        Map<String, String> params = new HashMap<>();
+        String index = "index";
+        boolean local = randomBoolean();
+        String masterTimeout = randomTimeValue();
+        String timeout = randomTimeValue();
+        ClusterHealthStatus waitForStatus = randomFrom(ClusterHealthStatus.values());
+        boolean waitForNoRelocatingShards = randomBoolean();
+        boolean waitForNoInitializingShards = randomBoolean();
+        int waitForActiveShards = randomIntBetween(1, 3);
+        String waitForNodes = "node";
+        Priority waitForEvents = randomFrom(Priority.values());
+
+        params.put("index", index);
+        params.put("local", String.valueOf(local));
+        params.put("master_timeout", masterTimeout);
+        params.put("timeout", timeout);
+        params.put("wait_for_status", waitForStatus.name());
+        if (waitForNoRelocatingShards || randomBoolean()) {
+            params.put("wait_for_no_relocating_shards", String.valueOf(waitForNoRelocatingShards));
+        }
+        if (waitForNoInitializingShards || randomBoolean()) {
+            params.put("wait_for_no_initializing_shards", String.valueOf(waitForNoInitializingShards));
+        }
+        params.put("wait_for_active_shards", String.valueOf(waitForActiveShards));
+        params.put("wait_for_nodes", waitForNodes);
+        params.put("wait_for_events", waitForEvents.name());
+
+        FakeRestRequest restRequest = buildRestRequest(params);
+        ClusterHealthRequest clusterHealthRequest = RestClusterHealthAction.fromRequest(restRequest);
+        assertThat(clusterHealthRequest.indices().length, equalTo(1));
+        assertThat(clusterHealthRequest.indices()[0], equalTo(index));
+        assertThat(clusterHealthRequest.local(), equalTo(local));
+        assertThat(clusterHealthRequest.masterNodeTimeout(), equalTo(TimeValue.parseTimeValue(masterTimeout, "test")));
+        assertThat(clusterHealthRequest.timeout(), equalTo(TimeValue.parseTimeValue(timeout, "test")));
+        assertThat(clusterHealthRequest.waitForStatus(), equalTo(waitForStatus));
+        assertThat(clusterHealthRequest.waitForNoRelocatingShards(), equalTo(waitForNoRelocatingShards));
+        assertThat(clusterHealthRequest.waitForNoInitializingShards(), equalTo(waitForNoInitializingShards));
+        assertThat(clusterHealthRequest.waitForActiveShards(), equalTo(ActiveShardCount.parseString(String.valueOf(waitForActiveShards))));
+        assertThat(clusterHealthRequest.waitForNodes(), equalTo(waitForNodes));
+        assertThat(clusterHealthRequest.waitForEvents(), equalTo(waitForEvents));
+
+    }
+
+    private FakeRestRequest buildRestRequest(Map<String, String> params) {
+        return new FakeRestRequest.Builder(xContentRegistry())
+            .withMethod(RestRequest.Method.GET)
+            .withPath("/_cluster/health")
+            .withParams(params)
+            .build();
+    }
+}