Fixed workflowId options and annotation (#119)

Author: mfateev

src/main/java/com/uber/cadence/client/UntypedWorkflowStub.java

@@ -28,6 +28,8 @@ public interface UntypedWorkflowStub {
 
     WorkflowExecution start(Object... args);
 
+    WorkflowExecution getExecution();
+
     /**
      * Returns workflow result potentially waiting for workflow to complete.
      * Behind the scene this call performs long poll on Cadence service waiting for workflow completion notification.

src/main/java/com/uber/cadence/internal/sync/UntypedWorkflowStubImpl.java

@@ -98,6 +98,7 @@ WorkflowExecution startWithOptions(WorkflowOptions o, Object... args) {
         try {
             execution.set(genericClient.startWorkflow(p));
         } catch (WorkflowExecutionAlreadyStartedError e) {
+            execution.set(new WorkflowExecution().setWorkflowId(p.getWorkflowId()).setRunId(e.getRunId()));
             WorkflowExecution execution = new WorkflowExecution()
                     .setWorkflowId(p.getWorkflowId())
                     .setRunId(e.getRunId());
@@ -111,6 +112,11 @@ public WorkflowExecution start(Object... args) {
         return startWithOptions(WorkflowOptions.merge(null, options), args);
     }
 
+    @Override
+    public WorkflowExecution getExecution() {
+        return execution.get();
+    }
+
     @Override
     public <R> R getResult(Class<R> returnType) {
         try {

src/main/java/com/uber/cadence/internal/sync/WorkflowExternalInvocationHandler.java

@@ -38,7 +38,6 @@ class WorkflowExternalInvocationHandler implements InvocationHandler {
     private final AtomicReference<UntypedWorkflowStubImpl> untyped = new AtomicReference<>();
     private final WorkflowOptions options;
     private final DataConverter dataConverter;
-    private final AtomicReference<WorkflowExecution> execution = new AtomicReference<>();
     private final GenericWorkflowClientExternal genericClient;
     private String workflowType;
 
@@ -79,7 +78,6 @@ public static void closeAsyncInvocation() {
         }
         this.genericClient = genericClient;
         this.untyped.set(new UntypedWorkflowStubImpl(genericClient, dataConverter, execution));
-        this.execution.set(execution);
         this.options = null;
         this.dataConverter = dataConverter;
     }
@@ -104,18 +102,16 @@ public Object invoke(Object proxy, Method method, Object[] args) {
         if (workflowMethod != null) {
             WorkflowOptions mergedOptions = WorkflowOptions.merge(workflowMethod, options);
             // We do allow duplicated calls if policy is not AllowDuplicate. Semantic is to wait for result.
-            if (execution.get() != null) { // stub is reused
+            UntypedWorkflowStubImpl workflowStub = untyped.get();
+            if (workflowStub != null) { // stub is reused
                 if (mergedOptions.getWorkflowIdReusePolicy() == WorkflowIdReusePolicy.AllowDuplicate) {
                     throw new DuplicateWorkflowException(
-                            execution.get(), workflowType, "Cannot call @WorkflowMethod more than once per stub instance");
+                            workflowStub.getExecution(), workflowType, "Cannot call @WorkflowMethod more than once per stub instance");
                 }
-                return getUntyped().getResult(method.getReturnType());
+                return workflowStub.getResult(method.getReturnType());
             }
             return startWorkflow(method, workflowMethod, mergedOptions, args);
         }
-        if (execution.get() == null) {
-            throw new IllegalStateException("Workflow not started yet");
-        }
         if (queryMethod != null) {
             return queryWorkflow(method, queryMethod, args);
         }
@@ -172,20 +168,20 @@ private Object startWorkflow(Method method, WorkflowMethod workflowMethod,
         if (untyped.get() == null) {
             untyped.set(new UntypedWorkflowStubImpl(genericClient, dataConverter, workflowType, mergedOptions));
         }
+        UntypedWorkflowStubImpl workflowStub = getUntyped();
         try {
-            execution.set(getUntyped().startWithOptions(mergedOptions, args));
+            workflowStub.startWithOptions(mergedOptions, args);
         } catch (DuplicateWorkflowException e) {
-            execution.set(e.getExecution());
             // We do allow duplicated calls if policy is not AllowDuplicate. Semantic is to wait for result.
             if (mergedOptions.getWorkflowIdReusePolicy() == WorkflowIdReusePolicy.AllowDuplicate) {
                 throw e;
             }
         }
         AtomicReference<WorkflowExecution> async = asyncResult.get();
         if (async != null) {
-            async.set(execution.get());
+            async.set(workflowStub.getExecution());
             return null;
         }
-        return getUntyped().getResult(method.getReturnType());
+        return workflowStub.getResult(method.getReturnType());
     }
 }

src/test/java/com/uber/cadence/workflow/WorkflowTest.java

@@ -759,9 +759,13 @@ public void mySignal(String value) {
     @Test
     public void testSignal() throws Exception {
         startWorkerFor(TestSignalWorkflowImpl.class);
-        QueryableWorkflow client = workflowClient.newWorkflowStub(QueryableWorkflow.class, newWorkflowOptionsBuilder().build());
+        WorkflowOptions.Builder optionsBuilder = newWorkflowOptionsBuilder();
+        String workflowId = UUID.randomUUID().toString();
+        optionsBuilder.setWorkflowId(workflowId);
+        QueryableWorkflow client = workflowClient.newWorkflowStub(QueryableWorkflow.class, optionsBuilder.build());
         // To execute workflow client.execute() would do. But we want to start workflow and immediately return.
         WorkflowExecution execution = WorkflowClient.asyncStart(client::execute);
+        assertEquals(workflowId, execution.getWorkflowId());
         assertEquals("initial", client.getState());
         client.mySignal("Hello ");
         Thread.sleep(200);