add pause + reset test

Author: THardy98

packages/client/src/async-completion-client.ts

@@ -252,13 +252,13 @@ export class AsyncCompletionClient extends BaseClient {
     } catch (err) {
       this.handleError(err);
     }
+    // Note that it is possible for a heartbeat response to have multiple fields
+    // set as true (i.e. cancelled and pause).
     if (cancelRequested) {
       throw new ActivityCancelledError('cancelled');
-    }
-    if (reset) {
+    } else if (reset) {
       throw new ActivityResetError('reset');
-    }
-    if (paused) {
+    } else if (paused) {
       throw new ActivityPausedError('paused');
     }
   }

packages/core-bridge/Cargo.lock

@@ -672,10 +672,8 @@ mod config {
                 self.local_activity_task_slot_supplier
                     .into_slot_supplier(&mut rbo),
             );
-            tuner_holder.nexus_slot_options(
-                self.nexus_task_slot_supplier
-                    .into_slot_supplier(&mut rbo)
-            );
+            tuner_holder
+                .nexus_slot_options(self.nexus_task_slot_supplier.into_slot_supplier(&mut rbo));
             if let Some(rbo) = rbo {
                 tuner_holder.resource_based_options(rbo);
             }

packages/core-bridge/sdk-core

@@ -299,7 +299,7 @@ export function configurableHelpers<T>(
 export async function setActivityState(
   handle: WorkflowHandle,
   activityId: string,
-  state: 'pause' | 'unpause' | 'reset'
+  state: 'pause' | 'unpause' | 'reset' | 'pause & reset'
 ): Promise<void> {
   const desc = await handle.describe();
   const req = {
@@ -314,9 +314,11 @@ export async function setActivityState(
     await handle.client.workflowService.pauseActivity(req);
   } else if (state === 'unpause') {
     await handle.client.workflowService.unpauseActivity(req);
+  } else if (state === 'reset') {
+    await handle.client.workflowService.resetActivity({ ...req, resetHeartbeat: true });
   } else {
-    const resetReq = { ...req, resetHeartbeat: true };
-    await handle.client.workflowService.resetActivity(resetReq);
+    await handle.client.workflowService.pauseActivity(req);
+    await handle.client.workflowService.resetActivity({ ...req, resetHeartbeat: true });
   }
   await waitUntil(async () => {
     const { raw } = await handle.describe();
@@ -325,17 +327,30 @@ export async function setActivityState(
     //  • paused flag is true  OR
     //  • the activity vanished (it completed / retried)
     if (state === 'pause') {
-      return activityInfo ? activityInfo.paused ?? false : true;
+      if (!activityInfo) {
+        return true; // Activity vanished (completed/retried)
+      }
+      return activityInfo.paused ?? false;
     } else if (state === 'unpause') {
       // If we are unpausing: success when either
       //  • paused flag is false  OR
       //  • the activity vanished (already completed)
       return activityInfo ? !activityInfo.paused : true;
-    } else {
+    } else if (state === 'reset') {
       // If we are resetting, success when either
       //  • heartbeat details have been reset OR
       //  • the activity vanished (completed / retried)
       return activityInfo ? activityInfo.heartbeatDetails === null : true;
+    } else {
+      // If we are pausing & resetting, success when either
+      //  • activity is paused AND heartbeat details have been reset OR
+      //  • the activity vanished (completed / retried)
+      if (!activityInfo) {
+        return true; // Activity vanished (completed/retried)
+      }
+      const isPaused = activityInfo.paused ?? false;
+      const isHeartbeatReset = activityInfo.heartbeatDetails === null;
+      return isPaused && isHeartbeatReset;
     }
   }, 15000);
 }

packages/core-bridge/src/worker.rs

@@ -1535,6 +1535,38 @@ test('Activity reset returns expected cancellation details', async (t) => {
   });
 });
 
+test('Activity set as both paused and reset returns expected cancellation details', async (t) => {
+  const { createWorker, startWorkflow } = helpers(t);
+  const worker = await createWorker({
+    activities: {
+      heartbeatCancellationDetailsActivity,
+    },
+  });
+
+  await worker.runUntil(async () => {
+    const testActivityId = randomUUID();
+    const handle = await startWorkflow(heartbeatPauseWorkflow, { args: [testActivityId, true, 1] });
+
+    // Wait for it to exist and heartbeat
+    await waitUntil(async () => {
+      const { raw } = await handle.describe();
+      const activityInfo = raw.pendingActivities?.find((act) => act.activityId === testActivityId);
+      return !!(activityInfo && (await hasActivityHeartbeat(handle, testActivityId, 'heartbeated')));
+    }, 10000);
+
+    await setActivityState(handle, testActivityId, 'pause & reset');
+    const result = await handle.result();
+    t.deepEqual(result, {
+      cancelRequested: false,
+      notFound: false,
+      paused: true,
+      timedOut: false,
+      workerShutdown: false,
+      reset: true,
+    });
+  });
+});
+
 const reservedNames = [TEMPORAL_RESERVED_PREFIX, STACK_TRACE_QUERY_NAME, ENHANCED_STACK_TRACE_QUERY_NAME];
 
 test('Cannot register activities using reserved prefixes', async (t) => {