test(http): add real JSON-RPC integration test and clean up SizeLimitHandler tests

Add testJsonRpcSizeLimitIntegration() in JsonrpcServiceTest using the
Spring-injected FullNodeJsonRpcHttpService (real JsonRpcServlet + jsonrpc4j)
to verify SizeLimitHandler does not introduce regressions. Covers: normal
request passthrough, Content-Length oversized 413, and chunked oversized
behavior (200 empty body due to RateLimiterServlet absorbing BadMessageException).

Clean up SizeLimitHandlerTest: remove 3 redundant testJsonRpcBody* tests
that used BroadCatchServlet (cannot represent real jsonrpc4j chain), rename
TestJsonRpcService to SecondHttpService, remove banner-style ruler comments,
fix stale EchoServlet Javadoc reference, and remove HTML tags from Javadoc.

Author: bladehan1

framework/src/test/java/org/tron/common/jetty/SizeLimitHandlerTest.java

@@ -32,31 +32,28 @@
 import org.tron.core.config.args.Args;
 
 /**
- * Tests the {@link org.eclipse.jetty.server.handler.SizeLimitHandler} body-size
- * enforcement configured in {@link HttpService initContextHandler()}.
+ * Tests {@link org.eclipse.jetty.server.handler.SizeLimitHandler} body-size
+ * enforcement configured in {@link HttpService#initContextHandler()}.
  *
- * <p>Covers:</p>
- * <ul>
- *   <li>Bodies within the limit are accepted ({@code 200}).</li>
- *   <li>Bodies exceeding the limit are rejected ({@code 413}).</li>
- *   <li>The limit counts raw UTF-8 <em>bytes</em>, not Java {@code char}s.</li>
- *   <li>HTTP and JSON-RPC services use independent size limits.</li>
- *   <li>Default values are {@code GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE} (4 MB).</li>
- * </ul>
+ * Covers: accept/reject by size, UTF-8 byte counting, independent limits
+ * across HttpService instances, chunked transfer, and zero-limit behavior.
+ *
+ * Real JsonRpcServlet integration is tested separately in
+ * {@code JsonrpcServiceTest#testJsonRpcSizeLimitIntegration}.
  */
 @Slf4j
 public class SizeLimitHandlerTest {
 
   private static final int HTTP_MAX_BODY_SIZE = 1024;
-  private static final int JSONRPC_MAX_BODY_SIZE = 512;
+  private static final int SECOND_SERVICE_MAX_BODY_SIZE = 512;
 
   @ClassRule
   public static final TemporaryFolder temporaryFolder = new TemporaryFolder();
 
-  private static TestHttpService     httpService;
-  private static TestJsonRpcService  jsonRpcService;
-  private static URI                 httpServerUri;
-  private static URI                 jsonRpcServerUri;
+  private static TestHttpService    httpService;
+  private static SecondHttpService  secondService;
+  private static URI                httpServerUri;
+  private static URI                secondServerUri;
   private static CloseableHttpClient client;
 
   /**
@@ -96,17 +93,17 @@ protected void addServlet(ServletContextHandler context) {
     }
   }
 
-  /** Minimal concrete {@link HttpService} simulating a JSON-RPC service. */
-  static class TestJsonRpcService extends HttpService {
-    TestJsonRpcService(int port, long maxRequestSize) {
+  /** Second HttpService instance with a different size limit, for independence tests. */
+  static class SecondHttpService extends HttpService {
+    SecondHttpService(int port, long maxRequestSize) {
       this.port = port;
       this.contextPath = "/";
       this.maxRequestSize = maxRequestSize;
     }
 
     @Override
     protected void addServlet(ServletContextHandler context) {
-      context.addServlet(new ServletHolder(new BroadCatchServlet()), "/jsonrpc");
+      context.addServlet(new ServletHolder(new BroadCatchServlet()), "/*");
     }
   }
 
@@ -115,17 +112,17 @@ public static void setup() throws Exception {
     Args.setParam(new String[]{"-d", temporaryFolder.newFolder().toString()},
         TestConstants.TEST_CONF);
     Args.getInstance().setHttpMaxMessageSize(HTTP_MAX_BODY_SIZE);
-    Args.getInstance().setJsonRpcMaxMessageSize(JSONRPC_MAX_BODY_SIZE);
+    Args.getInstance().setJsonRpcMaxMessageSize(SECOND_SERVICE_MAX_BODY_SIZE);
 
     int httpPort = PublicMethod.chooseRandomPort();
     httpService = new TestHttpService(httpPort, HTTP_MAX_BODY_SIZE);
     httpService.start().get(10, TimeUnit.SECONDS);
     httpServerUri = new URI(String.format("http://localhost:%d/", httpPort));
 
-    int jsonRpcPort = PublicMethod.chooseRandomPort();
-    jsonRpcService = new TestJsonRpcService(jsonRpcPort, JSONRPC_MAX_BODY_SIZE);
-    jsonRpcService.start().get(10, TimeUnit.SECONDS);
-    jsonRpcServerUri = new URI(String.format("http://localhost:%d/jsonrpc", jsonRpcPort));
+    int secondPort = PublicMethod.chooseRandomPort();
+    secondService = new SecondHttpService(secondPort, SECOND_SERVICE_MAX_BODY_SIZE);
+    secondService.start().get(10, TimeUnit.SECONDS);
+    secondServerUri = new URI(String.format("http://localhost:%d/", secondPort));
 
     client = HttpClients.createDefault();
   }
@@ -142,16 +139,14 @@ public static void teardown() throws Exception {
           httpService.stop();
         }
       } finally {
-        if (jsonRpcService != null) {
-          jsonRpcService.stop();
+        if (secondService != null) {
+          secondService.stop();
         }
       }
       Args.clearParam();
     }
   }
 
-  // -- HTTP service body-size tests -------------------------------------------
-
   @Test
   public void testHttpBodyWithinLimit() throws Exception {
     Assert.assertEquals(200, post(httpServerUri, new StringEntity("small body")));
@@ -169,40 +164,16 @@ public void testHttpBodyAtExactLimit() throws Exception {
         post(httpServerUri, new StringEntity(repeat('b', HTTP_MAX_BODY_SIZE))));
   }
 
-  // -- JSON-RPC service body-size tests ---------------------------------------
-
-  @Test
-  public void testJsonRpcBodyWithinLimit() throws Exception {
-    Assert.assertEquals(200,
-        post(jsonRpcServerUri, new StringEntity("{\"method\":\"eth_blockNumber\"}")));
-  }
-
-  @Test
-  public void testJsonRpcBodyExceedsLimit() throws Exception {
-    Assert.assertEquals(413,
-        post(jsonRpcServerUri, new StringEntity(repeat('x', JSONRPC_MAX_BODY_SIZE + 1))));
-  }
-
-  @Test
-  public void testJsonRpcBodyAtExactLimit() throws Exception {
-    Assert.assertEquals(200,
-        post(jsonRpcServerUri, new StringEntity(repeat('c', JSONRPC_MAX_BODY_SIZE))));
-  }
-
-  // -- Independent limit tests ------------------------------------------------
-
   @Test
-  public void testHttpAndJsonRpcHaveIndependentLimits() throws Exception {
-    // A body that exceeds JSON-RPC limit but is within HTTP limit
-    String body = repeat('d', JSONRPC_MAX_BODY_SIZE + 100);
+  public void testTwoServicesHaveIndependentLimits() throws Exception {
+    // A body that exceeds secondService limit but is within httpService limit
+    String body = repeat('d', SECOND_SERVICE_MAX_BODY_SIZE + 100);
     Assert.assertTrue(body.length() < HTTP_MAX_BODY_SIZE);
 
     Assert.assertEquals(200, post(httpServerUri, new StringEntity(body)));
-    Assert.assertEquals(413, post(jsonRpcServerUri, new StringEntity(body)));
+    Assert.assertEquals(413, post(secondServerUri, new StringEntity(body)));
   }
 
-  // -- UTF-8 byte counting test -----------------------------------------------
-
   @Test
   public void testLimitIsBasedOnBytesNotCharacters() throws Exception {
     // Each CJK character is 3 UTF-8 bytes; 342 chars x 3 = 1026 bytes > 1024
@@ -212,10 +183,8 @@ public void testLimitIsBasedOnBytesNotCharacters() throws Exception {
     Assert.assertEquals(413, post(httpServerUri, new StringEntity(cjk, "UTF-8")));
   }
 
-  // -- Chunked (no Content-Length) transfer tests ------------------------------
-
   /**
-   * Chunked request within the limit should succeed (EchoServlet).
+   * Chunked request within the limit should succeed.
    * InputStreamEntity with size=-1 sends chunked Transfer-Encoding (no Content-Length).
    */
   @Test
@@ -228,11 +197,11 @@ public void testChunkedBodyWithinLimit() throws Exception {
   /**
    * Chunked oversized body hitting a servlet with broad catch(Exception).
    *
-   * <p>SizeLimitHandler's LimitInterceptor throws BadMessageException during
+   * SizeLimitHandler's LimitInterceptor throws BadMessageException during
    * streaming read, but the servlet's catch(Exception) absorbs it and returns
    * 200 + error JSON instead of 413. This matches real TRON servlet behavior.
    *
-   * <p>OOM protection still works: the body read is truncated at the limit.
+   * OOM protection still works: the body read is truncated at the limit.
    */
   @Test
   public void testChunkedBodyExceedsLimit() throws Exception {
@@ -252,8 +221,6 @@ public void testChunkedBodyExceedsLimit() throws Exception {
         body.contains("Error"));
   }
 
-  // -- Zero-limit behavior test -----------------------------------------------
-
   /**
    * When maxRequestSize is 0, SizeLimitHandler treats it as "reject all bodies > 0 bytes".
    * Jetty's logic: {@code _requestLimit >= 0 && size > _requestLimit} — 0 >= 0 is true,
@@ -278,8 +245,6 @@ public void testZeroLimitRejectsAllBodies() throws Exception {
     }
   }
 
-  // -- checkBodySize vs SizeLimitHandler consistency tests --------------------
-
   /**
    * For pure ASCII JSON (the normal TRON API case), wire bytes and
    * {@code body.getBytes().length} (what {@code Util.checkBodySize()} measures)
@@ -320,7 +285,7 @@ public void testWireBytesMatchCheckBodySizeForUtf8Json() throws Exception {
   /**
    * When the body contains {@code \r\n} line endings, {@code lines().collect()}
    * normalizes them to {@code \n} (on Linux) or the platform line separator.
-   * This makes {@code checkBodySize} measure <em>fewer</em> bytes than the wire —
+   * This makes {@code checkBodySize} measure fewer bytes than the wire —
    * a safe direction: checkBodySize never rejects what SizeLimitHandler accepts.
    */
   @Test
@@ -338,8 +303,6 @@ public void testCheckBodySizeSafeDirectionWithNewlines() throws Exception {
         wireBytes, servletBytes, wireBytes - servletBytes);
   }
 
-  // -- helpers ----------------------------------------------------------------
-
   /** POSTs with the given entity and returns the response body as a string. */
   private String postForBody(URI uri, HttpEntity entity) throws Exception {
     HttpPost req = new HttpPost(uri);

framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java

@@ -8,13 +8,16 @@
 import com.google.gson.JsonObject;
 import com.google.protobuf.ByteString;
 import io.prometheus.client.CollectorRegistry;
+import java.io.ByteArrayInputStream;
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import javax.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.InputStreamEntity;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
@@ -25,6 +28,7 @@
 import org.junit.Test;
 import org.tron.common.BaseTest;
 import org.tron.common.TestConstants;
+import org.tron.common.application.HttpService;
 import org.tron.common.parameter.CommonParameter;
 import org.tron.common.prometheus.Metrics;
 import org.tron.common.utils.ByteArray;
@@ -1099,4 +1103,74 @@ public void testWeb3ClientVersion() {
       Assert.fail();
     }
   }
+
+  /**
+   * Verifies SizeLimitHandler integration with the real JsonRpcServlet + jsonrpc4j stack.
+   *
+   * Covers: normal request no regression, Content-Length oversized 413,
+   * and chunked oversized handled gracefully (body truncated, 200 + empty body
+   * because RateLimiterServlet absorbs the BadMessageException).
+   */
+  @Test
+  public void testJsonRpcSizeLimitIntegration() {
+    long testLimit = 1024;
+    try {
+      Field field = HttpService.class.getDeclaredField("maxRequestSize");
+      field.setAccessible(true);
+      long originalLimit = field.getLong(fullNodeJsonRpcHttpService);
+      field.setLong(fullNodeJsonRpcHttpService, testLimit);
+
+      fullNodeJsonRpcHttpService.start();
+      String url = "http://127.0.0.1:"
+          + CommonParameter.getInstance().getJsonRpcHttpFullNodePort() + "/jsonrpc";
+
+      try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
+        // Normal JSON-RPC request passes through SizeLimitHandler
+        JsonObject req = new JsonObject();
+        req.addProperty("jsonrpc", "2.0");
+        req.addProperty("method", "web3_clientVersion");
+        req.addProperty("id", 1);
+
+        HttpPost post = new HttpPost(url);
+        post.addHeader("Content-Type", "application/json");
+        post.setEntity(new StringEntity(req.toString()));
+        CloseableHttpResponse resp = httpClient.execute(post);
+        Assert.assertEquals(200, resp.getStatusLine().getStatusCode());
+        String body = EntityUtils.toString(resp.getEntity());
+        Assert.assertTrue("Normal JSON-RPC response should contain result",
+            body.contains("result"));
+        resp.close();
+
+        // Oversized request with Content-Length → 413 before JsonRpcServlet
+        HttpPost overPost = new HttpPost(url);
+        overPost.addHeader("Content-Type", "application/json");
+        overPost.setEntity(new StringEntity(
+            new String(new char[(int) testLimit + 1]).replace('\0', 'x')));
+        resp = httpClient.execute(overPost);
+        Assert.assertEquals(413, resp.getStatusLine().getStatusCode());
+        resp.close();
+
+        // Chunked oversized → BadMessageException thrown during body read,
+        // absorbed by RateLimiterServlet catch(Exception) → 200 with empty body.
+        // Body read IS truncated at the limit — OOM protection effective.
+        byte[] chunkedData = new String(new char[(int) testLimit * 2])
+            .replace('\0', 'x').getBytes("UTF-8");
+        HttpPost chunkedPost = new HttpPost(url);
+        chunkedPost.setEntity(new InputStreamEntity(
+            new ByteArrayInputStream(chunkedData), -1));
+        resp = httpClient.execute(chunkedPost);
+        Assert.assertEquals(200, resp.getStatusLine().getStatusCode());
+        body = EntityUtils.toString(resp.getEntity());
+        Assert.assertTrue("Chunked oversized should return empty body"
+            + " (RateLimiterServlet absorbs BadMessageException)", body.isEmpty());
+        resp.close();
+      } finally {
+        field.setLong(fullNodeJsonRpcHttpService, originalLimit);
+      }
+    } catch (Exception e) {
+      Assert.fail(e.getMessage());
+    } finally {
+      fullNodeJsonRpcHttpService.stop();
+    }
+  }
 }