remove started check in ChildWorkflowStubImpl and add unit test

Author: Liang Mei

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

@@ -36,7 +36,6 @@ class ChildWorkflowStubImpl implements ChildWorkflowStub {
   private final ChildWorkflowOptions options;
   private final WorkflowInterceptor decisionContext;
   private final CompletablePromise<WorkflowExecution> execution;
-  private boolean executionStarted;
 
   ChildWorkflowStubImpl(
       String workflowType, ChildWorkflowOptions options, WorkflowInterceptor decisionContext) {
@@ -83,19 +82,11 @@ public <R> Promise<R> executeAsync(Class<R> returnType, Object... args) {
     WorkflowResult<R> result =
         decisionContext.executeChildWorkflow(workflowType, returnType, args, options);
     execution.completeFrom(result.getWorkflowExecution());
-    executionStarted = true;
     return result.getResult();
   }
 
   @Override
   public void signal(String signalName, Object... args) {
-    if (!executionStarted) {
-      throw new IllegalStateException(
-          "This stub cannot be used to signal a workflow"
-              + " without starting it first. "
-              + "To signal a workflow execution that was started elsewhere "
-              + "use a stub created through Workflow.newExternalWorkflowStub");
-    }
     Promise<Void> signaled =
         decisionContext.signalExternalWorkflow(execution.get(), signalName, args);
     if (AsyncInternal.isAsync()) {

src/main/java/com/uber/cadence/internal/testservice/TestWorkflowMutableStateImpl.java

@@ -545,6 +545,7 @@ public void childWorkflowStarted(ChildWorkflowExecutionStartedEventAttributes a)
           String childId = a.getWorkflowExecution().getWorkflowId();
           StateMachine<ChildWorkflowData> child = getChildWorkflow(childId);
           child.action(StateMachines.Action.START, ctx, a, 0);
+          scheduleDecision(ctx);
           // No need to lock until completion as child workflow might skip
           // time as well
           ctx.unlockTimer();

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

@@ -19,6 +19,8 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -1011,6 +1013,73 @@ public void testChildAsyncWorkflow() {
     assertEquals(null, client.execute(taskList));
   }
 
+  // This workflow is designed specifically for testing some internal logic in Async.procedure
+  // and ChildWorkflowStubImpl. See comments on testChildAsyncLambdaWorkflow for more details.
+  public interface WaitOnSignalWorkflow {
+
+    @WorkflowMethod()
+    void execute();
+
+    @SignalMethod
+    void signal(String value);
+  }
+
+  public static class TestWaitOnSignalWorkflowImpl implements WaitOnSignalWorkflow {
+    private final CompletablePromise<String> signal = Workflow.newPromise();
+
+    @Override
+    public void execute() {
+      signal.get();
+    }
+
+    @Override
+    public void signal(String value) {
+      signal.complete(value);
+    }
+  }
+
+  public static class TestChildAsyncLambdaWorkflow implements TestWorkflow1 {
+
+    @Override
+    public String execute(String taskList) {
+      ChildWorkflowOptions workflowOptions =
+          new ChildWorkflowOptions.Builder()
+              .setExecutionStartToCloseTimeout(Duration.ofSeconds(100))
+              .setTaskStartToCloseTimeout(Duration.ofSeconds(60))
+              .setTaskList(taskList)
+              .build();
+
+      WaitOnSignalWorkflow child =
+          Workflow.newChildWorkflowStub(WaitOnSignalWorkflow.class, workflowOptions);
+      Promise<Void> promise = Async.procedure(() -> child.execute());
+      Promise<WorkflowExecution> executionPromise = Workflow.getWorkflowExecution(child);
+      assertNotNull(executionPromise);
+      WorkflowExecution execution = executionPromise.get();
+      assertNotEquals("", execution.getWorkflowId());
+      assertNotEquals("", execution.getRunId());
+      child.signal("test");
+
+      promise.get();
+      return null;
+    }
+  }
+
+  // The purpose of this test is to exercise the lambda execution logic inside Async.procedure(),
+  // which executes on a different thread than workflow-main. This is different than executing
+  // classes that implements the workflow method interface, which executes on the workflow main
+  // thread.
+  @Test
+  public void testChildAsyncLambdaWorkflow() {
+    startWorkerFor(TestChildAsyncLambdaWorkflow.class, TestWaitOnSignalWorkflowImpl.class);
+
+    WorkflowOptions.Builder options = new WorkflowOptions.Builder();
+    options.setExecutionStartToCloseTimeout(Duration.ofSeconds(200));
+    options.setTaskStartToCloseTimeout(Duration.ofSeconds(60));
+    options.setTaskList(taskList);
+    TestWorkflow1 client = workflowClient.newWorkflowStub(TestWorkflow1.class, options.build());
+    assertEquals(null, client.execute(taskList));
+  }
+
   public static class TestUntypedChildStubWorkflow implements TestWorkflow1 {
 
     @Override