re-use UpdateOptions merge code

Author: stephanos

temporal-sdk/src/main/java/io/temporal/client/WorkflowClient.java

@@ -1348,7 +1348,7 @@ static <R, A1, A2, A3, A4, A5, A6> R executeUpdateWithStart(
    * Executes zero argument workflow.
    *
    * @param updateMethod The only supported value is method reference to a proxy created through
-   *  {@link #newWorkflowStub(Class, WorkflowOptions)}.
+   *     {@link #newWorkflowStub(Class, WorkflowOptions)}.
    * @param withStartOperation start workflow operation
    * @return update result
    */
@@ -1358,7 +1358,7 @@ static <R> R executeUpdateWithStart(
       @Nonnull UpdateOptions<R> options,
       @Nonnull WithStartWorkflowOperation<?> withStartOperation) {
     return WorkflowClientInternalImpl.executeUpdateWithStart(
-            updateMethod::apply, options, withStartOperation);
+        updateMethod::apply, options, withStartOperation);
   }
 
   /**

temporal-sdk/src/main/java/io/temporal/client/WorkflowInvocationHandler.java

@@ -474,8 +474,20 @@ public void invoke(
         throw new IllegalArgumentException(
             "Only a method annotated with @UpdateMethod can be used to start an Update.");
       }
+      result = untyped.startUpdate(mergeUpdateOptions(options, workflowMetadata, method), args);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <R> R getResult(Class<R> resultClass) {
+      return (R) result;
+    }
+
+    static UpdateOptions<?> mergeUpdateOptions(
+        UpdateOptions<?> options, POJOWorkflowInterfaceMetadata workflowMetadata, Method method) {
       POJOWorkflowMethodMetadata methodMetadata = workflowMetadata.getMethodMetadata(method);
       UpdateOptions.Builder builder = UpdateOptions.newBuilder(options);
+
       if (Strings.isNullOrEmpty(options.getUpdateName())) {
         builder.setUpdateName(methodMetadata.getName());
       } else if (!options.getUpdateName().equals(methodMetadata.getName())) {
@@ -491,14 +503,7 @@ public void invoke(
       if (options.getResultClass() == null) {
         builder.setResultClass(method.getReturnType());
       }
-
-      result = untyped.startUpdate(builder.build(), args);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <R> R getResult(Class<R> resultClass) {
-      return (R) result;
+      return builder.build();
     }
   }
 
@@ -510,7 +515,7 @@ enum State {
       UPDATE_RECEIVED,
     }
 
-    private final UpdateOptions<?> baseUpdateOptions;
+    private final UpdateOptions<?> userProvidedUpdateOptions;
     private Object[] updateArgs;
     private UpdateOptions updateOptions;
     private final WithStartWorkflowOperation<?> startOp;
@@ -519,8 +524,10 @@ enum State {
     private WorkflowStub stub;
 
     public UpdateWithStartInvocationHandler(
-        UpdateOptions<?> baseUpdateOptions, WithStartWorkflowOperation<?> startOp) {
-      this.baseUpdateOptions = baseUpdateOptions;
+        UpdateOptions<?> options, WithStartWorkflowOperation<?> startOp) {
+      Preconditions.checkNotNull(options, "options");
+      Preconditions.checkNotNull(startOp, "startOp");
+      this.userProvidedUpdateOptions = options;
       this.startOp = startOp;
     }
 
@@ -542,22 +549,19 @@ public void invoke(
         UpdateMethod updateMethod = method.getAnnotation(UpdateMethod.class);
         if (updateMethod == null) {
           throw new IllegalArgumentException(
-              "Method '" + method.getName() + "' is not an UpdateMethod");
+              "Method '" + method.getName() + "' is not an @UpdateMethod");
         }
         this.setStub(untyped);
         this.updateArgs = args;
         this.updateOptions =
-            this.baseUpdateOptions.toBuilder()
-                .setUpdateName(methodMetadata.getName())
-                .setResultClass(method.getReturnType())
-                .setResultType(method.getGenericReturnType())
-                .build();
+            UpdateInvocationHandler.mergeUpdateOptions(
+                userProvidedUpdateOptions, workflowMetadata, method);
         state = State.UPDATE_RECEIVED;
       } else if (state == State.UPDATE_RECEIVED) {
         WorkflowMethod workflowMethod = method.getAnnotation(WorkflowMethod.class);
         if (workflowMethod == null) {
           throw new IllegalArgumentException(
-              "Method '" + method.getName() + "' is not a WorkflowMethod");
+              "Method '" + method.getName() + "' is not a @WorkflowMethod");
         }
         this.setStub(untyped);
         this.startOp.setStub(untyped);

temporal-sdk/src/test/java/io/temporal/workflow/updateTest/UpdateWithStartTest.java

@@ -627,6 +627,34 @@ public void failWhenStartOperationUsedAgain() {
     }
   }
 
+  @Test
+  public void failWhenUpdateNamesDoNotMatch() {
+    WorkflowClient workflowClient = testWorkflowRule.getWorkflowClient();
+
+    WorkflowOptions options = createWorkflowOptions();
+    TestWorkflows.TestUpdatedWorkflow workflow =
+        workflowClient.newWorkflowStub(TestWorkflows.TestUpdatedWorkflow.class, options);
+
+    WithStartWorkflowOperation<String> startOp =
+        new WithStartWorkflowOperation<>(workflow::execute);
+
+    try {
+      WorkflowUpdateHandle<String> updHandle =
+          WorkflowClient.startUpdateWithStart(
+              workflow::update,
+              "Hello Update",
+              createUpdateOptions().toBuilder()
+                  .setUpdateName("custom_update_name") // custom name!
+                  .build(),
+              startOp);
+      fail("unreachable");
+    } catch (IllegalArgumentException e) {
+      assertEquals(
+          e.getMessage(),
+          "Update name in the options doesn't match the method name: custom_update_name != testUpdate");
+    }
+  }
+
   @Test
   public void failServerSideWhenStartIsInvalid() {
     WorkflowClient workflowClient = testWorkflowRule.getWorkflowClient();