test(rpc): cover BatchSizeLimitMiddleware with max_entries=0

The middleware's `max_entries = 0` corner case (allowed in-process
because `BatchSizeLimitMiddleware::new` has no guard, even though
the CLI value parser `parse_max_batch_entries` rejects 0) was
untested. Add a focused test that locks in the documented behaviour:
any non-empty batch is rejected with `BATCH_TOO_LARGE_ERROR_CODE`,
and the error message names the offending size and limit.

An empty-batch pass-through test was considered and dropped: the
`MockRpcService` itself rejects empty batches with a different
error code (-32600 'Invalid request'), and asserting on the
final response shape would lock in that quirk rather than the
middleware's contract. The empty-batch case is left to the
JSON-RPC layer below the middleware.

Author: Kewe63

crates/evm-node/src/rpc_middleware.rs

@@ -1179,6 +1179,33 @@ mod tests {
         assert_eq!(response.as_error_code(), Some(BATCH_TOO_LARGE_ERROR_CODE));
     }
 
+    /// `max_entries = 0` is rejected at the CLI level by
+    /// `parse_max_batch_entries`, but the in-process constructor has no
+    /// such guard — callers can build a "no batches allowed" layer
+    /// intentionally. The middleware must reject any non-empty batch
+    /// with `BATCH_TOO_LARGE_ERROR_CODE`. The empty-batch case is
+    /// covered by the JSON-RPC layer below the middleware and is
+    /// deliberately not asserted here, because the mock service
+    /// itself rejects empty batches with a different error code and
+    /// we don't want to lock in that quirk.
+    #[tokio::test]
+    async fn test_batch_size_limit_zero_max_entries_rejects_non_empty() {
+        let middleware = BatchSizeLimitMiddleware::new(MockRpcService, 0);
+        let batch = Batch::from(vec![Ok(make_call_entry("eth_blockNumber", 1))]);
+        let response = middleware.batch(batch).await;
+        assert_eq!(
+            response.as_error_code(),
+            Some(BATCH_TOO_LARGE_ERROR_CODE),
+            "max_entries=0 must reject any non-empty batch"
+        );
+        let json: serde_json::Value = serde_json::from_str(response.into_json().get()).unwrap();
+        let message = json["error"]["message"].as_str().unwrap_or("");
+        assert!(
+            message.contains("batch size 1") && message.contains("limit of 0"),
+            "error message should name the offending size and limit; got: {message}"
+        );
+    }
+
     #[tokio::test]
     async fn test_batch_size_limit_applies_when_pending_filter_disabled() {
         // The batch cap must apply even when --arc.expose-pending-txs disables