test(rpc): cover the error path, cursor wiring and pbft reads

Three gaps the existing suite left open:

RpcApiServiceErrorPathTest drives every unary handler of WalletApi and
WalletSolidityApi with collaborators that throw, and asserts none of
them terminates the call more than once. Reverting the return fix makes
it fail on getDelegatedResourceV2, getPendingSize and getBlock, so it
also reaches the shared *Common helpers.

CursorInterceptorWiringTest runs the real addService of the solidity and
pbft services against a mock builder and asserts both shared read
services are registered as intercepted definitions. Dropping
ServerInterceptors.intercept left every existing test green while the
port silently served HEAD; this is the grpc counterpart of
CursorFilterInstallationTest.

RpcApiServicesTest now drives getPaginatedNowWitnessList and
getTransactionInfoByBlockNum on the pbft stub as well, pinning the one
intentional behaviour change of the merge.

Author: Little-Peony

framework/src/test/java/org/tron/core/services/RpcApiServiceErrorPathTest.java

@@ -0,0 +1,140 @@
+package org.tron.core.services;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+
+import com.google.protobuf.Message;
+import io.grpc.stub.StreamObserver;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.stubbing.Answer;
+import org.tron.core.Wallet;
+import org.tron.core.metrics.MetricsApiService;
+import org.tron.core.services.RpcApiService.WalletApi;
+import org.tron.core.services.RpcApiService.WalletSolidityApi;
+import org.tron.core.utils.TransactionUtil;
+
+/**
+ * Pins the one-terminal-event rule on the gRPC error path: a handler that reports a failure through
+ * {@code onError} must not fall through to {@code onCompleted}. gRPC rejects the second close with
+ * {@code IllegalStateException("call already closed")}, so a handler doing both costs a server-side
+ * exception on every failed call while the client sees nothing extra.
+ *
+ * <p>The rule is checked for every handler rather than for the ones that were fixed, because the
+ * shape is trivially reintroduced by copying a neighbouring handler.
+ */
+public class RpcApiServiceErrorPathTest {
+
+  /** Minimum handlers that must actually fail, so the sweep cannot silently cover nothing. */
+  private static final int MIN_EXERCISED = 20;
+
+  @Test
+  public void testWalletApiTerminatesTheCallOnce() throws Exception {
+    assertSingleTerminalEvent(WalletApi.class);
+  }
+
+  @Test
+  public void testWalletSolidityApiTerminatesTheCallOnce() throws Exception {
+    assertSingleTerminalEvent(WalletSolidityApi.class);
+  }
+
+  /**
+   * Drives every unary handler of the given service class with collaborators that throw, and
+   * asserts none of them terminates the call more than once.
+   */
+  private static void assertSingleTerminalEvent(Class<?> apiClass) throws Exception {
+    RpcApiService service = mock(RpcApiService.class,
+        withSettings().defaultAnswer(Answers.CALLS_REAL_METHODS));
+    injectThrowingCollaborators(service);
+    Object api = apiClass.getDeclaredConstructor(RpcApiService.class).newInstance(service);
+
+    int exercised = 0;
+    for (Method method : apiClass.getDeclaredMethods()) {
+      if (!isUnaryHandler(method)) {
+        continue;
+      }
+      Message request = (Message) method.getParameterTypes()[0]
+          .getMethod("getDefaultInstance").invoke(null);
+      TerminalRecorder recorder = new TerminalRecorder();
+      try {
+        method.invoke(api, request, recorder);
+      } catch (InvocationTargetException e) {
+        // a handler that lets the failure escape cannot have closed the call twice
+        continue;
+      }
+      Assert.assertTrue(
+          method.getName() + " terminated the call " + recorder.events.size() + " times "
+              + recorder.events + "; onError must be followed by return",
+          recorder.events.size() <= 1);
+      if (!recorder.events.isEmpty()) {
+        exercised++;
+      }
+    }
+    Assert.assertTrue(
+        apiClass.getSimpleName() + " exercised only " + exercised + " handlers, expected at least "
+            + MIN_EXERCISED + " — the sweep is no longer reaching the handler bodies",
+        exercised >= MIN_EXERCISED);
+  }
+
+  private static boolean isUnaryHandler(Method method) {
+    Class<?>[] params = method.getParameterTypes();
+    return Modifier.isPublic(method.getModifiers())
+        && method.getReturnType() == void.class
+        && params.length == 2
+        && Message.class.isAssignableFrom(params[0])
+        && params[1] == StreamObserver.class;
+  }
+
+  /**
+   * Replaces the service's collaborators with mocks that throw on every call, so each handler takes
+   * its own error path, and binds a real {@code WalletApi} for the solidity handlers to delegate
+   * to.
+   */
+  private static void injectThrowingCollaborators(RpcApiService service) throws Exception {
+    Answer<Object> throwing = invocation -> {
+      throw new RuntimeException("collaborator unavailable");
+    };
+    set(service, "wallet", mock(Wallet.class, withSettings().defaultAnswer(throwing)));
+    set(service, "transactionUtil",
+        mock(TransactionUtil.class, withSettings().defaultAnswer(throwing)));
+    set(service, "nodeInfoService",
+        mock(NodeInfoService.class, withSettings().defaultAnswer(throwing)));
+    set(service, "metricsApiService",
+        mock(MetricsApiService.class, withSettings().defaultAnswer(throwing)));
+    set(service, "walletApi",
+        WalletApi.class.getDeclaredConstructor(RpcApiService.class).newInstance(service));
+  }
+
+  private static void set(RpcApiService service, String name, Object value) throws Exception {
+    Field field = RpcApiService.class.getDeclaredField(name);
+    field.setAccessible(true);
+    field.set(service, value);
+  }
+
+  /** Counts terminal events instead of closing a real call. */
+  private static final class TerminalRecorder implements StreamObserver<Object> {
+
+    private final List<String> events = new ArrayList<>();
+
+    @Override
+    public void onNext(Object value) {
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      events.add("onError");
+    }
+
+    @Override
+    public void onCompleted() {
+      events.add("onCompleted");
+    }
+  }
+}

framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java

@@ -277,6 +277,7 @@ public void testGetPaginatedNowWitnessList() {
         .setOffset(0).setLimit(5).build();
     assertNotNull(blockingStubFull.getPaginatedNowWitnessList(paginatedMessage));
     assertNotNull(blockingStubSolidity.getPaginatedNowWitnessList(paginatedMessage));
+    assertNotNull(blockingStubPBFT.getPaginatedNowWitnessList(paginatedMessage));
   }
 
   @Test
@@ -673,6 +674,7 @@ public void testGetTransactionInfoByBlockNum() {
     NumberMessage message = NumberMessage.newBuilder().setNum(1).build();
     assertNotNull(blockingStubFull.getTransactionInfoByBlockNum(message));
     assertNotNull(blockingStubSolidity.getTransactionInfoByBlockNum(message));
+    assertNotNull(blockingStubPBFT.getTransactionInfoByBlockNum(message));
   }
 
   @Test

framework/src/test/java/org/tron/core/services/filter/CursorInterceptorWiringTest.java

@@ -0,0 +1,101 @@
+package org.tron.core.services.filter;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.withSettings;
+
+import io.grpc.BindableService;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.netty.NettyServerBuilder;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.ArgumentCaptor;
+import org.tron.api.DatabaseGrpc;
+import org.tron.api.WalletSolidityGrpc;
+import org.tron.core.services.RpcApiService;
+import org.tron.core.services.interfaceOnPBFT.RpcApiServiceOnPBFT;
+import org.tron.core.services.interfaceOnSolidity.RpcApiServiceOnSolidity;
+
+/**
+ * Guards that each cursor gRPC service registers the shared read services <em>through</em> its
+ * cursor interceptor. Nothing else catches a dropped interceptor: the services would still be
+ * served and every response would still look well-formed, only resolved against HEAD instead of the
+ * solidified or PBFT snapshot. This is the gRPC counterpart of CursorFilterInstallationTest.
+ *
+ * <p>Registering without the interceptor binds the {@code addService(BindableService)} overload
+ * rather than the {@code addService(ServerServiceDefinition)} one, so the two are distinguishable
+ * here. What the interceptor does once attached is pinned by CursorInterceptorScopeTest and
+ * GrpcInterceptorProbeTest.
+ */
+public class CursorInterceptorWiringTest {
+
+  private static final Set<String> SHARED_READ_SERVICES = new HashSet<>(
+      Arrays.asList(DatabaseGrpc.SERVICE_NAME, WalletSolidityGrpc.SERVICE_NAME));
+
+  @Test
+  public void testSolidityServiceRegistersBothReadServicesThroughTheCursor() throws Exception {
+    Assert.assertEquals(SHARED_READ_SERVICES,
+        interceptedServices(RpcApiServiceOnSolidity.class, new SolidityCursorInterceptor()));
+  }
+
+  @Test
+  public void testPbftServiceRegistersBothReadServicesThroughTheCursor() throws Exception {
+    Assert.assertEquals(SHARED_READ_SERVICES,
+        interceptedServices(RpcApiServiceOnPBFT.class, new PbftCursorInterceptor()));
+  }
+
+  /**
+   * Runs the service's real addService against a mock builder and returns the names of the services
+   * it registered as intercepted definitions, failing if any was registered unintercepted.
+   */
+  private static Set<String> interceptedServices(Class<?> serviceClass,
+      CursorServerInterceptor interceptor) throws Exception {
+    RpcApiService rpcApiService = mock(RpcApiService.class);
+    given(rpcApiService.getDatabaseApi()).willReturn(RpcApiService.DatabaseApi.class
+        .getDeclaredConstructor(RpcApiService.class).newInstance(rpcApiService));
+    given(rpcApiService.getWalletSolidityApi()).willReturn(RpcApiService.WalletSolidityApi.class
+        .getDeclaredConstructor(RpcApiService.class).newInstance(rpcApiService));
+
+    Object service = mock(serviceClass, withSettings().defaultAnswer(Answers.CALLS_REAL_METHODS));
+    inject(serviceClass, service, rpcApiService);
+    inject(serviceClass, service, interceptor);
+
+    NettyServerBuilder builder = mock(NettyServerBuilder.class);
+    Method addService = serviceClass.getDeclaredMethod("addService", NettyServerBuilder.class);
+    addService.setAccessible(true);
+    addService.invoke(service, builder);
+
+    verify(builder, never()).addService(any(BindableService.class));
+    ArgumentCaptor<ServerServiceDefinition> registered =
+        ArgumentCaptor.forClass(ServerServiceDefinition.class);
+    verify(builder, times(2)).addService(registered.capture());
+
+    Set<String> names = new HashSet<>();
+    for (ServerServiceDefinition definition : registered.getAllValues()) {
+      names.add(definition.getServiceDescriptor().getName());
+    }
+    return names;
+  }
+
+  /** Sets the one declared field the value fits; the two injected types are unrelated. */
+  private static void inject(Class<?> serviceClass, Object service, Object value) throws Exception {
+    for (Field field : serviceClass.getDeclaredFields()) {
+      if (field.getType().isInstance(value)) {
+        field.setAccessible(true);
+        field.set(service, value);
+        return;
+      }
+    }
+    Assert.fail(serviceClass.getSimpleName() + " has no field for " + value.getClass().getName());
+  }
+}