Fix CI failure

Author: Quinn-With-Two-Ns

temporal-sdk/src/main/java/io/temporal/nexus/TemporalOperationHandler.java

@@ -136,7 +136,7 @@ protected void cancelWorkflowRun(
   }
 
   /**
-   * Called when a cancel request is received for an activity-execution token (type=4). Override to
+   * Called when a cancel request is received for an activity-execution token (type=2). Override to
    * customize cancel behavior.
    *
    * <p>Default behavior: requests cancellation of the underlying standalone activity execution.

temporal-sdk/src/test/java/io/temporal/workflow/nexus/AsyncActivityOperationTest.java

@@ -2,16 +2,12 @@
 
 import static org.junit.Assume.assumeTrue;
 
-import io.nexusrpc.handler.HandlerException;
 import io.nexusrpc.handler.OperationHandler;
 import io.nexusrpc.handler.OperationImpl;
 import io.nexusrpc.handler.ServiceImpl;
 import io.temporal.activity.ActivityInterface;
 import io.temporal.activity.ActivityMethod;
 import io.temporal.client.StartActivityOptions;
-import io.temporal.client.WorkflowFailedException;
-import io.temporal.failure.ApplicationFailure;
-import io.temporal.failure.NexusOperationFailure;
 import io.temporal.internal.nexus.OperationToken;
 import io.temporal.internal.nexus.OperationTokenType;
 import io.temporal.internal.nexus.OperationTokenUtil;
@@ -25,61 +21,29 @@
 import org.junit.Rule;
 import org.junit.Test;
 
-public class AsyncActivityOperationTest extends BaseNexusTest {
+public class AsyncActivityOperationTest {
 
   @Rule
   public SDKTestWorkflowRule testWorkflowRule =
       SDKTestWorkflowRule.newBuilder()
-          .setWorkflowTypes(TestNexus.class, DoubleStartNexus.class)
+          .setWorkflowTypes(TestNexus.class)
           .setActivityImplementations(new TestActivityImpl())
-          .setNexusServiceImplementation(
-              new TestNexusServiceImpl(), new DoubleStartNexusServiceImpl())
+          .setNexusServiceImplementation(new TestNexusServiceImpl())
           .build();
 
-  @Override
-  protected SDKTestWorkflowRule getTestWorkflowRule() {
-    return testWorkflowRule;
-  }
-
   @Test
   public void testActivityOperationEndToEnd() {
     // The in-process test-server does not implement the StartActivityExecution RPC; the
     // standalone-activity Nexus path requires a real server. Unit-only token assertions stay
     // active in OperationTokenTest.
     assumeTrue(SDKTestWorkflowRule.useExternalService);
-    // Combined (a) caller workflow receives "hello " + input
-    //          (b) opToken loads as ACTIVITY_EXECUTION with aid="act-" + requestId
+    // The caller workflow receives the activity result and an ACTIVITY_EXECUTION operation token.
     TestWorkflows.TestWorkflow1 workflowStub =
         testWorkflowRule.newWorkflowStubTimeoutOptions(TestWorkflows.TestWorkflow1.class);
     String result = workflowStub.execute("world");
     Assert.assertEquals("hello world", result);
   }
 
-  @Test
-  public void testDoubleStartActivityThrows() {
-    // The first start RPC requires StartActivityExecution which is not implemented by the
-    // in-process test server; gate this on a real server so the guard at the second call can be
-    // observed.
-    assumeTrue(SDKTestWorkflowRule.useExternalService);
-    // (c) Calling startActivity twice in one handler invocation throws
-    //     HandlerException(BAD_REQUEST).
-    TestDoubleStartWorkflow workflowStub =
-        testWorkflowRule.newWorkflowStubTimeoutOptions(TestDoubleStartWorkflow.class);
-    WorkflowFailedException e =
-        Assert.assertThrows(WorkflowFailedException.class, () -> workflowStub.execute("anything"));
-    Assert.assertTrue(e.getCause() instanceof NexusOperationFailure);
-    NexusOperationFailure nexusFailure = (NexusOperationFailure) e.getCause();
-    Assert.assertTrue(nexusFailure.getCause() instanceof HandlerException);
-    HandlerException handlerException = (HandlerException) nexusFailure.getCause();
-    Assert.assertTrue(handlerException.getCause() instanceof ApplicationFailure);
-    ApplicationFailure appFailure = (ApplicationFailure) handlerException.getCause();
-    Assert.assertEquals("java.lang.IllegalStateException", appFailure.getType());
-    Assert.assertTrue(
-        appFailure
-            .getOriginalMessage()
-            .startsWith("Only one async operation can be started per operation handler"));
-  }
-
   @ActivityInterface
   public interface TestActivity {
     @ActivityMethod
@@ -101,14 +65,10 @@ public String execute(String input) {
               .setScheduleToCloseTimeout(Duration.ofSeconds(20))
               .build();
       NexusServiceOptions serviceOptions =
-          NexusServiceOptions.newBuilder()
-              .setEndpoint(getEndpointName())
-              .setOperationOptions(options)
-              .build();
+          NexusServiceOptions.newBuilder().setOperationOptions(options).build();
       TestNexusServices.TestNexusService1 serviceStub =
           Workflow.newNexusServiceStub(TestNexusServices.TestNexusService1.class, serviceOptions);
 
-      // Drive a handle so we can inspect the operation token for assertion (b).
       NexusOperationHandle<String> handle =
           Workflow.startNexusOperation(serviceStub::operation, input);
       NexusOperationExecution exec = handle.getExecution().get();
@@ -140,66 +100,4 @@ public OperationHandler<String, String> operation() {
                       .build()));
     }
   }
-
-  // ---------- Double-start test scaffolding ----------
-
-  public static class DoubleStartNexus implements TestDoubleStartWorkflow {
-    @Override
-    public String execute(String input) {
-      NexusOperationOptions options =
-          NexusOperationOptions.newBuilder()
-              .setScheduleToCloseTimeout(Duration.ofSeconds(10))
-              .build();
-      NexusServiceOptions serviceOptions =
-          NexusServiceOptions.newBuilder()
-              .setEndpoint(getEndpointName())
-              .setOperationOptions(options)
-              .build();
-      DoubleStartNexusService stub =
-          Workflow.newNexusServiceStub(DoubleStartNexusService.class, serviceOptions);
-      return stub.operation(input);
-    }
-  }
-
-  @WorkflowInterface
-  public interface TestDoubleStartWorkflow {
-    @WorkflowMethod
-    String execute(String input);
-  }
-
-  @io.nexusrpc.Service
-  public interface DoubleStartNexusService {
-    @io.nexusrpc.Operation
-    String operation(String input);
-  }
-
-  @ServiceImpl(service = DoubleStartNexusService.class)
-  public class DoubleStartNexusServiceImpl {
-    @OperationImpl
-    public OperationHandler<String, String> operation() {
-      return TemporalOperationHandler.create(
-          (context, client, input) -> {
-            // First start should succeed.
-            client.startActivity(
-                TestActivity.class,
-                TestActivity::process,
-                input,
-                StartActivityOptions.newBuilder()
-                    .setId("act-first-" + context.getRequestId())
-                    .setTaskQueue(testWorkflowRule.getTaskQueue())
-                    .setStartToCloseTimeout(Duration.ofSeconds(10))
-                    .build());
-            // Second start must throw HandlerException(BAD_REQUEST).
-            return client.startActivity(
-                TestActivity.class,
-                TestActivity::process,
-                input,
-                StartActivityOptions.newBuilder()
-                    .setId("act-second-" + context.getRequestId())
-                    .setTaskQueue(testWorkflowRule.getTaskQueue())
-                    .setStartToCloseTimeout(Duration.ofSeconds(10))
-                    .build());
-          });
-    }
-  }
 }