Enhance and add more tests for ResizeRequest (#68502)

server/src/main/java/org/elasticsearch/action/admin/indices/create/CreateIndexRequest.java

@@ -479,4 +479,22 @@ public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest>
         }
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        CreateIndexRequest that = (CreateIndexRequest) obj;
+        return Objects.equals(cause, that.cause) &&
+            Objects.equals(index, that.index) &&
+            Objects.equals(settings, that.settings) &&
+            Objects.equals(mappings, that.mappings) &&
+            Objects.equals(aliases, that.aliases) &&
+            Objects.equals(waitForActiveShards, that.waitForActiveShards) &&
+            Objects.equals(origin, that.origin);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cause, index, settings, mappings, aliases, waitForActiveShards, origin);
+    }
 }

server/src/main/java/org/elasticsearch/action/admin/indices/shrink/ResizeRequest.java

@@ -237,4 +237,21 @@ public class ResizeRequest extends AcknowledgedRequest<ResizeRequest> implements
     public void fromXContent(XContentParser parser) throws IOException {
         PARSER.parse(parser, this, null);
     }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        ResizeRequest that = (ResizeRequest) obj;
+        return Objects.equals(targetIndexRequest, that.targetIndexRequest) &&
+            Objects.equals(sourceIndex, that.sourceIndex) &&
+            Objects.equals(type, that.type) &&
+            Objects.equals(copySettings, that.copySettings) &&
+            Objects.equals(maxPrimaryShardSize, that.maxPrimaryShardSize);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(targetIndexRequest, sourceIndex, type, copySettings, maxPrimaryShardSize);
+    }
 }

server/src/test/java/org/elasticsearch/action/admin/indices/create/CreateIndexRequestTests.java

@@ -13,6 +13,7 @@ import org.elasticsearch.action.admin.indices.alias.Alias;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.io.stream.BytesStreamOutput;
 import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.common.xcontent.XContentBuilder;
@@ -20,7 +21,8 @@ import org.elasticsearch.common.xcontent.XContentFactory;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.common.xcontent.json.JsonXContent;
-import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.index.RandomCreateIndexGenerator;
+import org.elasticsearch.test.AbstractWireSerializingTestCase;
 
 import java.io.IOException;
 import java.util.Map;
@@ -28,9 +30,9 @@ import java.util.Set;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 
-public class CreateIndexRequestTests extends ESTestCase {
+public class CreateIndexRequestTests extends AbstractWireSerializingTestCase<CreateIndexRequest> {
 
-    public void testSerialization() throws IOException {
+    public void testSimpleSerialization() throws IOException {
         CreateIndexRequest request = new CreateIndexRequest("foo");
         String mapping = Strings.toString(JsonXContent.contentBuilder().startObject().startObject("_doc").endObject().endObject());
         request.mapping(mapping);
@@ -145,4 +147,12 @@ public class CreateIndexRequestTests extends ESTestCase {
             }
         }
     }
+
+    @Override
+    protected Writeable.Reader<CreateIndexRequest> instanceReader() { return CreateIndexRequest::new; }
+
+    @Override
+    protected CreateIndexRequest createTestInstance() {
+        return RandomCreateIndexGenerator.randomCreateIndexRequest();
+    }
 }

server/src/test/java/org/elasticsearch/action/admin/indices/shrink/ResizeRequestTests.java

@@ -10,28 +10,34 @@ package org.elasticsearch.action.admin.indices.shrink;
 
 import org.elasticsearch.action.admin.indices.alias.Alias;
 import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
-import org.elasticsearch.action.admin.indices.create.CreateIndexRequestTests;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.bytes.BytesReference;
+import org.elasticsearch.common.io.stream.BytesStreamOutput;
+import org.elasticsearch.common.io.stream.NamedWriteableAwareStreamInput;
+import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.common.network.NetworkModule;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.ByteSizeUnit;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.index.RandomCreateIndexGenerator;
-import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.test.AbstractWireSerializingTestCase;
 import org.elasticsearch.test.hamcrest.ElasticsearchAssertions;
 
 import java.io.IOException;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
+import static org.elasticsearch.action.admin.indices.create.CreateIndexRequestTests.assertAliasesEqual;
 import static org.elasticsearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
 import static org.elasticsearch.common.xcontent.ToXContent.EMPTY_PARAMS;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.hasToString;
 
-public class ResizeRequestTests extends ESTestCase {
+public class ResizeRequestTests extends AbstractWireSerializingTestCase<ResizeRequest> {
 
     public void testCopySettingsValidation() {
         runTestCopySettingsValidation(false, r -> {
@@ -83,39 +89,63 @@ public class ResizeRequestTests extends ESTestCase {
     }
 
     public void testToAndFromXContent() throws IOException {
-        final ResizeRequest resizeRequest = createTestItem();
+        final ResizeRequest resizeRequest = createTestInstance();
 
         boolean humanReadable = randomBoolean();
         final XContentType xContentType = randomFrom(XContentType.values());
         BytesReference originalBytes = toShuffledXContent(resizeRequest, xContentType, EMPTY_PARAMS, humanReadable);
 
-        ResizeRequest parsedResizeRequest = new ResizeRequest(resizeRequest.getTargetIndexRequest().index(),
-                resizeRequest.getSourceIndex());
+        ResizeRequest parsedResizeRequest = new ResizeRequest(
+            randomValueOtherThan(resizeRequest.getTargetIndexRequest().index(), () -> randomAlphaOfLength(5)),
+            randomValueOtherThan(resizeRequest.getSourceIndex(), () -> randomAlphaOfLength(5))
+        );
         try (XContentParser xParser = createParser(xContentType.xContent(), originalBytes)) {
             parsedResizeRequest.fromXContent(xParser);
         }
 
-        assertEquals(resizeRequest.getSourceIndex(), parsedResizeRequest.getSourceIndex());
-        assertEquals(resizeRequest.getTargetIndexRequest().index(), parsedResizeRequest.getTargetIndexRequest().index());
-        CreateIndexRequestTests.assertAliasesEqual(resizeRequest.getTargetIndexRequest().aliases(),
-                parsedResizeRequest.getTargetIndexRequest().aliases());
+        // these are not expected to be equal in the general case because ResizeRequest.toXContent doesn't include everything
+        assertNotEquals(resizeRequest, parsedResizeRequest);
+        assertNotEquals(resizeRequest.getSourceIndex(), parsedResizeRequest.getSourceIndex());
+        assertNotEquals(resizeRequest.getTargetIndexRequest(), parsedResizeRequest.getTargetIndexRequest());
+        assertNotEquals(resizeRequest.getTargetIndexRequest().index(), parsedResizeRequest.getTargetIndexRequest().index());
+
+        // but these are expected to be equal
+        assertAliasesEqual(resizeRequest.getTargetIndexRequest().aliases(), parsedResizeRequest.getTargetIndexRequest().aliases());
         assertEquals(resizeRequest.getTargetIndexRequest().settings(), parsedResizeRequest.getTargetIndexRequest().settings());
+        assertEquals(resizeRequest.getMaxPrimaryShardSize(), parsedResizeRequest.getMaxPrimaryShardSize());
 
         BytesReference finalBytes = toShuffledXContent(parsedResizeRequest, xContentType, EMPTY_PARAMS, humanReadable);
         ElasticsearchAssertions.assertToXContentEquivalent(originalBytes, finalBytes, xContentType);
     }
 
-    private static ResizeRequest createTestItem() {
+    public void testSerializeRequest() throws IOException {
+        ResizeRequest request = createTestInstance();
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        BytesReference bytes = out.bytes();
+        NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(NetworkModule.getNamedWriteables());
+        StreamInput wrap = new NamedWriteableAwareStreamInput(bytes.streamInput(), namedWriteableRegistry);
+        ResizeRequest deserializedReq = new ResizeRequest(wrap);
+
+        assertEquals(request.getSourceIndex(), deserializedReq.getSourceIndex());
+        assertEquals(request.getTargetIndexRequest().settings(), deserializedReq.getTargetIndexRequest().settings());
+        assertEquals(request.getTargetIndexRequest().aliases(), deserializedReq.getTargetIndexRequest().aliases());
+        assertEquals(request.getCopySettings(), deserializedReq.getCopySettings());
+        assertEquals(request.getResizeType(), deserializedReq.getResizeType());
+        assertEquals(request.getMaxPrimaryShardSize(), deserializedReq.getMaxPrimaryShardSize());
+    }
+
+    @Override
+    protected Writeable.Reader<ResizeRequest> instanceReader() { return ResizeRequest::new; }
+
+    @Override
+    protected ResizeRequest createTestInstance() {
         ResizeRequest resizeRequest = new ResizeRequest(randomAlphaOfLengthBetween(3, 10), randomAlphaOfLengthBetween(3, 10));
         if (randomBoolean()) {
-            CreateIndexRequest createIndexRequest = new CreateIndexRequest(randomAlphaOfLengthBetween(3, 10));
-            if (randomBoolean()) {
-                RandomCreateIndexGenerator.randomAliases(createIndexRequest);
-            }
-            if (randomBoolean()) {
-                createIndexRequest.settings(RandomCreateIndexGenerator.randomIndexSettings());
-            }
-            resizeRequest.setTargetIndex(createIndexRequest);
+            resizeRequest.setTargetIndex(RandomCreateIndexGenerator.randomCreateIndexRequest());
+        }
+        if (randomBoolean()) {
+            resizeRequest.setMaxPrimaryShardSize(new ByteSizeValue(randomIntBetween(1, 100)));
         }
         return resizeRequest;
     }

test/framework/src/main/java/org/elasticsearch/index/RandomCreateIndexGenerator.java

@@ -35,7 +35,7 @@ public final class RandomCreateIndexGenerator {
      * Randomizes the index name, the aliases, mappings and settings associated with the
      * index. If present, the mapping definition will be nested under a type name.
      */
-    public static CreateIndexRequest randomCreateIndexRequest() throws IOException {
+    public static CreateIndexRequest randomCreateIndexRequest() {
         String index = randomAlphaOfLength(5);
         CreateIndexRequest request = new CreateIndexRequest(index);
         randomAliases(request);
@@ -73,36 +73,44 @@ public final class RandomCreateIndexGenerator {
      * Creates a random mapping, with the mapping definition nested
      * under the given type name.
      */
-    public static XContentBuilder randomMapping(String type) throws IOException {
-        XContentBuilder builder = XContentFactory.contentBuilder(randomFrom(XContentType.values()));
-        builder.startObject().startObject(type);
+    public static XContentBuilder randomMapping(String type)  {
+        try {
+            XContentBuilder builder = XContentFactory.contentBuilder(randomFrom(XContentType.values()));
+            builder.startObject().startObject(type);
 
-        randomMappingFields(builder, true);
+            randomMappingFields(builder, true);
 
-        builder.endObject().endObject();
-        return builder;
+            builder.endObject().endObject();
+            return builder;
+        } catch (IOException e) {
+            throw new AssertionError(e);
+        }
     }
 
     /**
      * Adds random mapping fields to the provided {@link XContentBuilder}
      */
-    public static void randomMappingFields(XContentBuilder builder, boolean allowObjectField) throws IOException {
-        builder.startObject("properties");
-
-        int fieldsNo = randomIntBetween(0, 5);
-        for (int i = 0; i < fieldsNo; i++) {
-            builder.startObject(randomAlphaOfLength(5));
+    public static void randomMappingFields(XContentBuilder builder, boolean allowObjectField) {
+        try {
+            builder.startObject("properties");
+
+            int fieldsNo = randomIntBetween(0, 5);
+            for (int i = 0; i < fieldsNo; i++) {
+                builder.startObject(randomAlphaOfLength(5));
+
+                if (allowObjectField && randomBoolean()) {
+                    randomMappingFields(builder, false);
+                } else {
+                    builder.field("type", "text");
+                }
 
-            if (allowObjectField && randomBoolean()) {
-                randomMappingFields(builder, false);
-            } else {
-                builder.field("type", "text");
+                builder.endObject();
             }
 
             builder.endObject();
+        } catch (IOException e) {
+            throw new AssertionError(e);
         }
-
-        builder.endObject();
     }
 
     /**