test: Test ABNADONED child timer can be fast-forwarded (#772)

Author: bergundy

packages/test/src/test-testenvironment.ts

@@ -3,8 +3,10 @@ import { v4 as uuid4 } from 'uuid';
 import { WorkflowFailedError } from '@temporalio/client';
 import { TestWorkflowEnvironment, workflowInterceptorModules } from '@temporalio/testing';
 import { Connection } from '@temporalio/testing/lib/connection';
+import { bundleWorkflowCode, WorkflowBundleWithSourceMap } from '@temporalio/worker';
 import {
   assertFromWorkflow,
+  asyncChildStarter,
   raceActivityAndTimer,
   sleep,
   unblockSignal,
@@ -14,13 +16,18 @@ import { Worker } from './helpers';
 
 interface Context {
   testEnv: TestWorkflowEnvironment;
+  bundle: WorkflowBundleWithSourceMap;
 }
 
 const test = anyTest as TestFn<Context>;
 
 test.before(async (t) => {
   t.context = {
     testEnv: await TestWorkflowEnvironment.createTimeSkipping(),
+    bundle: await bundleWorkflowCode({
+      workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
+      workflowInterceptorModules,
+    }),
   };
 });
 
@@ -33,7 +40,7 @@ test.serial('TestEnvironment sets up test server and is able to run a Workflow w
   const worker = await Worker.create({
     connection: nativeConnection,
     taskQueue: 'test',
-    workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
+    workflowBundle: t.context.bundle,
   });
   await worker.runUntil(
     client.workflow.execute(sleep, {
@@ -51,7 +58,7 @@ test.serial('TestEnvironment can toggle between normal and skipped time', async
   const worker = await Worker.create({
     connection: nativeConnection,
     taskQueue: 'test',
-    workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
+    workflowBundle: t.context.bundle,
   });
 
   await worker.runUntil(async () => {
@@ -87,7 +94,7 @@ test.serial('TestEnvironment sleep can be used to delay activity completion', as
         await sleep(duration);
       },
     },
-    workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
+    workflowBundle: t.context.bundle,
   });
 
   const run = async (expectedWinner: 'timer' | 'activity') => {
@@ -123,7 +130,7 @@ test.serial('TestEnvironment sleep can be used to delay sending a signal', async
   const worker = await Worker.create({
     connection: nativeConnection,
     taskQueue: 'test',
-    workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
+    workflowBundle: t.context.bundle,
   });
 
   await worker.runUntil(async () => {
@@ -144,10 +151,7 @@ test.serial('Workflow code can run assertions', async (t) => {
   const worker = await Worker.create({
     connection: nativeConnection,
     taskQueue: 'test',
-    workflowsPath: require.resolve('./workflows/testenv-test-workflows'),
-    interceptors: {
-      workflowModules: workflowInterceptorModules,
-    },
+    workflowBundle: t.context.bundle,
   });
 
   const err: WorkflowFailedError | undefined = await t.throwsAsync(
@@ -162,3 +166,25 @@ test.serial('Workflow code can run assertions', async (t) => {
   );
   t.is(err?.cause?.message, 'Expected values to be strictly equal:\n\n6 !== 7\n');
 });
+
+test.serial('ABNADONED child timer can be fast-forwarded', async (t) => {
+  const { client, nativeConnection } = t.context.testEnv;
+
+  const worker = await Worker.create({
+    connection: nativeConnection,
+    taskQueue: 'test',
+    workflowBundle: t.context.bundle,
+  });
+
+  const childWorkflowId = uuid4();
+  await worker.runUntil(async () => {
+    await client.workflow.execute(asyncChildStarter, {
+      workflowId: uuid4(),
+      taskQueue: 'test',
+      args: [childWorkflowId],
+    });
+    await client.workflow.getHandle(childWorkflowId).result();
+  });
+
+  t.pass();
+});

packages/test/src/workflows/testenv-test-workflows.ts

@@ -4,7 +4,7 @@
  */
 
 import assert from 'assert';
-import { sleep, proxyActivities, defineSignal, setHandler } from '@temporalio/workflow';
+import { sleep, proxyActivities, defineSignal, setHandler, startChild, ParentClosePolicy } from '@temporalio/workflow';
 
 // Export sleep to be invoked as a workflow
 export { sleep };
@@ -32,3 +32,11 @@ export async function waitOnSignalWithTimeout(): Promise<void> {
 export async function assertFromWorkflow(x: number): Promise<void> {
   assert.strictEqual(x, 7);
 }
+
+export async function asyncChildStarter(childWorkflowId: string): Promise<void> {
+  await startChild(sleep, {
+    args: ['1 day'],
+    workflowId: childWorkflowId,
+    parentClosePolicy: ParentClosePolicy.PARENT_CLOSE_POLICY_ABANDON,
+  });
+}

packages/testing/src/index.ts

@@ -24,7 +24,7 @@ import {
 } from '@temporalio/client';
 import { ActivityFunction, CancelledFailure } from '@temporalio/common';
 import { msToTs, tsToMs } from '@temporalio/common/lib/time';
-import { NativeConnection, Runtime } from '@temporalio/worker';
+import { NativeConnection, Runtime, appendDefaultInterceptors } from '@temporalio/worker';
 import {
   EphemeralServer,
   EphemeralServerConfig,