Clean RestRequestTests

Fix IntelliJ code clean suggestions inside `RestRequestTests`

Author: joshua-adams-1

server/src/test/java/org/elasticsearch/rest/RestRequestTests.java

@@ -22,6 +22,7 @@
 import org.elasticsearch.xcontent.XContentParser;
 import org.elasticsearch.xcontent.XContentParserConfiguration;
 import org.elasticsearch.xcontent.XContentType;
+import org.junit.Assert;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -105,7 +106,9 @@ public void testContentParser() throws IOException {
         assertEquals("request body is required", e.getMessage());
         e = expectThrows(ElasticsearchParseException.class, () -> contentRestRequest("", singletonMap("source", "{}")).contentParser());
         assertEquals("request body is required", e.getMessage());
-        assertEquals(emptyMap(), contentRestRequest("{}", emptyMap()).contentParser().map());
+        try (XContentParser parser = contentRestRequest("{}", emptyMap()).contentParser()) {
+            assertEquals(emptyMap(), parser.map());
+        }
         e = expectThrows(ElasticsearchParseException.class, () -> contentRestRequest("", emptyMap(), emptyMap()).contentParser());
         assertEquals("request body is required", e.getMessage());
     }
@@ -170,29 +173,37 @@ public void testParamAsIntegerWithNonIntegerParameter() {
         assertThrows(IllegalArgumentException.class, () -> restRequest.paramAsInteger(parameterKey, defaultValue));
     }
 
-    public void testContentOrSourceParam() throws IOException {
+    public void testContentOrSourceParam() {
         Exception e = expectThrows(ElasticsearchParseException.class, () -> contentRestRequest("", emptyMap()).contentOrSourceParam());
         assertEquals("request body or source parameter is required", e.getMessage());
-        assertEquals(new BytesArray("stuff"), contentRestRequest("stuff", emptyMap()).contentOrSourceParam().v2());
-        assertEquals(
-            new BytesArray("stuff"),
-            contentRestRequest("stuff", Map.of("source", "stuff2", "source_content_type", "application/json")).contentOrSourceParam().v2()
-        );
-        assertEquals(
-            new BytesArray("{\"foo\": \"stuff\"}"),
-            contentRestRequest("", Map.of("source", "{\"foo\": \"stuff\"}", "source_content_type", "application/json"))
-                .contentOrSourceParam()
-                .v2()
-        );
+        try (ReleasableBytesReference ref = contentRestRequest("stuff", emptyMap()).contentOrSourceParam().v2()) {
+            assertEquals("stuff", ref.utf8ToString());
+        }
+        try (
+            ReleasableBytesReference ref = contentRestRequest(
+                "stuff",
+                Map.of("source", "stuff2", "source_content_type", "application/json")
+            ).contentOrSourceParam().v2()
+        ) {
+            assertEquals("stuff", ref.utf8ToString());
+        }
+        try (
+            ReleasableBytesReference ref = contentRestRequest(
+                "",
+                Map.of("source", "{\"foo\": \"stuff\"}", "source_content_type", "application/json")
+            ).contentOrSourceParam().v2()
+        ) {
+            assertEquals("{\"foo\": \"stuff\"}", ref.utf8ToString());
+        }
         e = expectThrows(ValidationException.class, () -> contentRestRequest("", Map.of("source", "stuff2")).contentOrSourceParam());
         assertThat(e.getMessage(), containsString("source and source_content_type parameters are required"));
     }
 
-    public void testHasContentOrSourceParam() throws IOException {
-        assertEquals(false, contentRestRequest("", emptyMap()).hasContentOrSourceParam());
-        assertEquals(true, contentRestRequest("stuff", emptyMap()).hasContentOrSourceParam());
-        assertEquals(true, contentRestRequest("stuff", singletonMap("source", "stuff2")).hasContentOrSourceParam());
-        assertEquals(true, contentRestRequest("", singletonMap("source", "stuff")).hasContentOrSourceParam());
+    public void testHasContentOrSourceParam() {
+        assertFalse(contentRestRequest("", emptyMap()).hasContentOrSourceParam());
+        assertTrue(contentRestRequest("stuff", emptyMap()).hasContentOrSourceParam());
+        assertTrue(contentRestRequest("stuff", singletonMap("source", "stuff2")).hasContentOrSourceParam());
+        assertTrue(contentRestRequest("", singletonMap("source", "stuff")).hasContentOrSourceParam());
     }
 
     public void testContentOrSourceParamParser() throws IOException {
@@ -201,16 +212,25 @@ public void testContentOrSourceParamParser() throws IOException {
             () -> contentRestRequest("", emptyMap()).contentOrSourceParamParser()
         );
         assertEquals("request body or source parameter is required", e.getMessage());
-        assertEquals(emptyMap(), contentRestRequest("{}", emptyMap()).contentOrSourceParamParser().map());
-        assertEquals(emptyMap(), contentRestRequest("{}", singletonMap("source", "stuff2")).contentOrSourceParamParser().map());
-        assertEquals(
-            emptyMap(),
-            contentRestRequest("", Map.of("source", "{}", "source_content_type", "application/json")).contentOrSourceParamParser().map()
-        );
+
+        try (XContentParser parser = contentRestRequest("{}", emptyMap()).contentOrSourceParamParser()) {
+            assertEquals(emptyMap(), parser.map());
+        }
+
+        try (XContentParser parser = contentRestRequest("{}", singletonMap("source", "stuff2")).contentOrSourceParamParser()) {
+            assertEquals(emptyMap(), parser.map());
+        }
+
+        try (
+            XContentParser parser = contentRestRequest("", Map.of("source", "{}", "source_content_type", "application/json"))
+                .contentOrSourceParamParser()
+        ) {
+            assertEquals(emptyMap(), parser.map());
+        }
     }
 
     public void testWithContentOrSourceParamParserOrNull() throws IOException {
-        contentRestRequest("", emptyMap()).withContentOrSourceParamParserOrNull(parser -> assertNull(parser));
+        contentRestRequest("", emptyMap()).withContentOrSourceParamParserOrNull(Assert::assertNull);
         contentRestRequest("{}", emptyMap()).withContentOrSourceParamParserOrNull(parser -> assertEquals(emptyMap(), parser.map()));
         contentRestRequest("{}", singletonMap("source", "stuff2")).withContentOrSourceParamParserOrNull(
             parser -> assertEquals(emptyMap(), parser.map())
@@ -289,11 +309,17 @@ public void testMultipleContentTypeHeaders() {
     public void testRequiredContent() {
         Exception e = expectThrows(ElasticsearchParseException.class, () -> contentRestRequest("", emptyMap()).requiredContent());
         assertEquals("request body is required", e.getMessage());
-        assertEquals(new BytesArray("stuff"), contentRestRequest("stuff", emptyMap()).requiredContent());
-        assertEquals(
-            new BytesArray("stuff"),
-            contentRestRequest("stuff", Map.of("source", "stuff2", "source_content_type", "application/json")).requiredContent()
-        );
+        try (ReleasableBytesReference ref = contentRestRequest("stuff", emptyMap()).requiredContent()) {
+            assertEquals("stuff", ref.utf8ToString());
+        }
+        try (
+            ReleasableBytesReference ref = contentRestRequest(
+                "stuff",
+                Map.of("source", "stuff2", "source_content_type", "application/json")
+            ).requiredContent()
+        ) {
+            assertEquals("stuff", ref.utf8ToString());
+        }
         e = expectThrows(
             ElasticsearchParseException.class,
             () -> contentRestRequest("", Map.of("source", "{\"foo\": \"stuff\"}", "source_content_type", "application/json"))
@@ -307,7 +333,7 @@ public void testRequiredContent() {
     public void testIsServerlessRequest() {
         RestRequest request1 = contentRestRequest("content", new HashMap<>());
         request1.markAsServerlessRequest();
-        assertEquals(request1.param(SERVERLESS_REQUEST), "true");
+        assertEquals("true", request1.param(SERVERLESS_REQUEST));
         assertTrue(request1.isServerlessRequest());
         IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, request1::markAsServerlessRequest);
         assertThat(exception.getMessage(), is("The parameter [" + SERVERLESS_REQUEST + "] is already defined."));
@@ -320,7 +346,7 @@ public void testIsServerlessRequest() {
     public void testIsOperatorRequest() {
         RestRequest request1 = contentRestRequest("content", new HashMap<>());
         request1.markAsOperatorRequest();
-        assertEquals(request1.param(OPERATOR_REQUEST), "true");
+        assertEquals("true", request1.param(OPERATOR_REQUEST));
         assertTrue(request1.isOperatorRequest());
         IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, request1::markAsOperatorRequest);
         assertThat(exception.getMessage(), is("The parameter [" + OPERATOR_REQUEST + "] is already defined."));