@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/{src → core/src}/core_tests/workflow_tasks.rs

@@ -1,15 +1,15 @@
 use crate::{
     errors::PollWfError,
     job_assert,
-    pollers::MockServerGatewayApis,
+    replay::TestHistoryBuilder,
     test_help::{
         build_fake_core, build_mock_pollers, build_multihist_mock_sg, canned_histories,
         gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_core, poll_and_reply,
         poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg, FakeWfResponses,
-        MockPollCfg, MocksHolder, ResponseType, TestHistoryBuilder, NO_MORE_WORK_ERROR_MSG, TEST_Q,
+        MockPollCfg, MocksHolder, ResponseType, NO_MORE_WORK_ERROR_MSG, TEST_Q,
     },
     workflow::WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
-    Core, CoreSDK, WfActivationCompletion,
+    Core, CoreSDK, WorkflowActivationCompletion,
 };
 use rstest::{fixture, rstest};
 use std::{
@@ -17,16 +17,17 @@ use std::{
     sync::atomic::{AtomicU64, AtomicUsize, Ordering},
     time::Duration,
 };
+use temporal_client::mocks::mock_gateway;
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{self as ar, activity_result, ActivityResult},
+        activity_result::{self as ar, activity_resolution, ActivityResolution},
         workflow_activation::{
-            wf_activation_job, FireTimer, ResolveActivity, StartWorkflow, UpdateRandomSeed,
-            WfActivationJob,
+            workflow_activation_job, FireTimer, ResolveActivity, StartWorkflow, UpdateRandomSeed,
+            WorkflowActivationJob,
         },
         workflow_commands::{
             ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
-            FailWorkflowExecution, RequestCancelActivity, ScheduleActivity, StartTimer,
+            FailWorkflowExecution, RequestCancelActivity, ScheduleActivity,
         },
     },
     temporal::api::{
@@ -36,7 +37,7 @@ use temporal_sdk_core_protos::{
         workflowservice::v1::RespondWorkflowTaskCompletedResponse,
     },
 };
-use test_utils::fanout_tasks;
+use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd};
 
 #[fixture(hist_batches = &[])]
 fn single_timer_setup(hist_batches: &'static [usize]) -> CoreSDK {
@@ -74,15 +75,11 @@ async fn single_timer(#[case] core: CoreSDK, #[case] evict: WorkflowCachingPolic
         evict,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
-                vec![StartTimer {
-                    seq: 1,
-                    ..Default::default()
-                }
-                .into()],
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                vec![start_timer_cmd(1, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
         ],
@@ -103,7 +100,7 @@ async fn single_activity_completion(core: CoreSDK) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     activity_id: "fake_activity".to_string(),
                     ..Default::default()
@@ -111,7 +108,7 @@ async fn single_activity_completion(core: CoreSDK) {
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(_)),
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(_)),
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
         ],
@@ -137,18 +134,10 @@ async fn parallel_timer_test_across_wf_bridge(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![
-                    StartTimer {
-                        seq: timer_1_id,
-                        ..Default::default()
-                    }
-                    .into(),
-                    StartTimer {
-                        seq: timer_2_id,
-                        ..Default::default()
-                    }
-                    .into(),
+                    start_timer_cmd(timer_1_id, Duration::from_secs(1)),
+                    start_timer_cmd(timer_2_id, Duration::from_secs(1)),
                 ],
             ),
             gen_assert_and_reply(
@@ -156,13 +145,13 @@ async fn parallel_timer_test_across_wf_bridge(hist_batches: &'static [usize]) {
                     assert_matches!(
                         res.jobs.as_slice(),
                         [
-                            WfActivationJob {
-                                variant: Some(wf_activation_job::Variant::FireTimer(
+                            WorkflowActivationJob {
+                                variant: Some(workflow_activation_job::Variant::FireTimer(
                                     FireTimer { seq: t1_id }
                                 )),
                             },
-                            WfActivationJob {
-                                variant: Some(wf_activation_job::Variant::FireTimer(
+                            WorkflowActivationJob {
+                                variant: Some(workflow_activation_job::Variant::FireTimer(
                                     FireTimer { seq: t2_id }
                                 )),
                             }
@@ -197,22 +186,14 @@ async fn timer_cancel(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![
-                    StartTimer {
-                        seq: cancel_timer_id,
-                        ..Default::default()
-                    }
-                    .into(),
-                    StartTimer {
-                        seq: timer_id,
-                        ..Default::default()
-                    }
-                    .into(),
+                    start_timer_cmd(cancel_timer_id, Duration::from_secs(1)),
+                    start_timer_cmd(timer_id, Duration::from_secs(1)),
                 ],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![
                     CancelTimer {
                         seq: cancel_timer_id,
@@ -242,7 +223,7 @@ async fn scheduled_activity_cancellation_try_cancel(hist_batches: &'static [usiz
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -252,12 +233,12 @@ async fn scheduled_activity_cancellation_try_cancel(hist_batches: &'static [usiz
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![RequestCancelActivity { seq: activity_seq }.into()],
             ),
             // Activity is getting resolved right away as we are in the TryCancel mode.
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(_)),
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(_)),
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
         ],
@@ -279,7 +260,7 @@ async fn scheduled_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -293,12 +274,12 @@ async fn scheduled_activity_timeout(hist_batches: &'static [usize]) {
                     assert_matches!(
                     res.jobs.as_slice(),
                     [
-                        WfActivationJob {
-                            variant: Some(wf_activation_job::Variant::ResolveActivity(
+                        WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::ResolveActivity(
                                 ResolveActivity {
                                     seq,
-                                    result: Some(ActivityResult {
-                                        status: Some(activity_result::Status::Failed(ar::Failure {
+                                    result: Some(ActivityResolution {
+                                        status: Some(activity_resolution::Status::Failed(ar::Failure {
                                             failure: Some(failure)
                                         })),
                                     })
@@ -332,7 +313,7 @@ async fn started_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_seq.to_string(),
@@ -343,26 +324,26 @@ async fn started_activity_timeout(hist_batches: &'static [usize]) {
             // Activity is getting resolved right away as it has been timed out.
             gen_assert_and_reply(
                 &|res| {
-                    assert_matches!(
-                                res.jobs.as_slice(),
-                                [
-                                    WfActivationJob {
-                                        variant: Some(wf_activation_job::Variant::ResolveActivity(
-                                            ResolveActivity {
-                                                seq,
-                                                result: Some(ActivityResult {
-                                                    status: Some(activity_result::Status::Failed(ar::Failure {
-                                                        failure: Some(failure)
-                                                    })),
-                                                })
-                                            }
-                                        )),
-                                    }
-                                ] => {
-                                    assert_eq!(failure.message, "Activity task timed out".to_string());
-                                    assert_eq!(*seq, activity_seq);
+                assert_matches!(
+                    res.jobs.as_slice(),
+                    [
+                        WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                                ResolveActivity {
+                                    seq,
+                                    result: Some(ActivityResolution {
+                                        status: Some(activity_resolution::Status::Failed(ar::Failure {
+                                            failure: Some(failure)
+                                        })),
+                                    })
                                 }
-                            );
+                            )),
+                        }
+                    ] => {
+                        assert_eq!(failure.message, "Activity task timed out".to_string());
+                        assert_eq!(*seq, activity_seq);
+                    }
+                );
                 },
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
@@ -387,7 +368,7 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -396,16 +377,16 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) {
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![RequestCancelActivity { seq: activity_seq }.into()],
             ),
             // Activity is resolved right away as it has timed out.
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
                         seq: _,
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(..)),
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(..)),
                         })
                     }
                 )),
@@ -491,7 +472,7 @@ async fn verify_activity_cancellation(
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_seq.to_string(),
@@ -501,16 +482,16 @@ async fn verify_activity_cancellation(
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![RequestCancelActivity { seq: activity_seq }.into()],
             ),
             // Activity should be resolved right away
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
                         seq: _,
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(..)),
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(..)),
                         })
                     }
                 )),
@@ -559,7 +540,7 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, co
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: activity_id.to_string(),
@@ -569,21 +550,21 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, co
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![RequestCancelActivity { seq: activity_id }.into()],
             ),
             // Making sure that activity is not resolved until it's cancelled.
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![],
             ),
             // Now ActivityTaskCanceled has been processed and activity can be resolved.
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
                         seq: _,
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(..)),
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(..)),
                         })
                     }
                 )),
@@ -615,8 +596,8 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                 &|res| {
                     assert_matches!(
                         res.jobs.as_slice(),
-                        [WfActivationJob {
-                            variant: Some(wf_activation_job::Variant::StartWorkflow(
+                        [WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::StartWorkflow(
                             StartWorkflow{randomness_seed, ..}
                             )),
                         }] => {
@@ -624,21 +605,17 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                         }
                     );
                 },
-                vec![StartTimer {
-                    seq: timer_1_id,
-                    ..Default::default()
-                }
-                .into()],
+                vec![start_timer_cmd(timer_1_id, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
                 &|res| {
                     assert_matches!(
                         res.jobs.as_slice(),
-                        [WfActivationJob {
-                            variant: Some(wf_activation_job::Variant::FireTimer(_),),
+                        [WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::FireTimer(_),),
                         },
-                        WfActivationJob {
-                            variant: Some(wf_activation_job::Variant::UpdateRandomSeed(
+                        WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::UpdateRandomSeed(
                                 UpdateRandomSeed{randomness_seed})),
                         }] => {
                             assert_ne!(randomness_seed_from_start.load(Ordering::SeqCst),
@@ -669,13 +646,9 @@ async fn cancel_timer_before_sent_wf_bridge() {
         &core,
         NonSticky,
         &[gen_assert_and_reply(
-            &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+            &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
             vec![
-                StartTimer {
-                    seq: cancel_timer_id,
-                    ..Default::default()
-                }
-                .into(),
+                start_timer_cmd(cancel_timer_id, Duration::from_secs(1)),
                 CancelTimer {
                     seq: cancel_timer_id,
                 }
@@ -718,15 +691,11 @@ async fn complete_activation_with_failure(
         &[
             gen_assert_and_reply(
                 &|_| {},
-                vec![StartTimer {
-                    seq: timer_id,
-                    ..Default::default()
-                }
-                .into()],
+                vec![start_timer_cmd(timer_id, Duration::from_secs(1))],
             ),
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
         ],
@@ -749,15 +718,11 @@ async fn simple_timer_fail_wf_execution(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
-                vec![StartTimer {
-                    seq: timer_id,
-                    ..Default::default()
-                }
-                .into()],
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                vec![start_timer_cmd(timer_id, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![FailWorkflowExecution {
                     failure: Some(Failure {
                         message: "I'm ded".to_string(),
@@ -784,14 +749,14 @@ async fn two_signals(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 // Task is completed with no commands
                 vec![],
             ),
             gen_assert_and_reply(
                 &job_assert!(
-                    wf_activation_job::Variant::SignalWorkflow(_),
-                    wf_activation_job::Variant::SignalWorkflow(_)
+                    workflow_activation_job::Variant::SignalWorkflow(_),
+                    workflow_activation_job::Variant::SignalWorkflow(_)
                 ),
                 vec![],
             ),
@@ -837,29 +802,21 @@ async fn workflow_failures_only_reported_once() {
         &[
             gen_assert_and_reply(
                 &|_| {},
-                vec![StartTimer {
-                    seq: timer_1,
-                    ..Default::default()
-                }
-                .into()],
+                vec![start_timer_cmd(timer_1, Duration::from_secs(1))],
             ),
             // Fail a few times in a row (only one of which should be reported)
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
-                vec![StartTimer {
-                    seq: timer_2,
-                    ..Default::default()
-                }
-                .into()],
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
+                vec![start_timer_cmd(timer_2, Duration::from_secs(1))],
             ),
             // Again (a new fail should be reported here)
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_fail(&|_| {}),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
         ],
@@ -908,14 +865,10 @@ async fn max_concurrent_wft_respected() {
     let last_finisher = AtomicUsize::new(0);
     let (_, mut r1) = tokio::join! {
         async {
-            core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
                 TEST_Q,
                 r1.run_id,
-                StartTimer {
-                    seq: 1,
-                    ..Default::default()
-                }
-                .into())
+                start_timer_cmd(1, Duration::from_secs(1)))
             ).await.unwrap();
             last_finisher.store(1, Ordering::SeqCst);
         },
@@ -930,14 +883,10 @@ async fn max_concurrent_wft_respected() {
 
     // Since we never did anything with r2, all subsequent activations should be for wf1
     for i in 2..=20 {
-        core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             TEST_Q,
             r1.run_id,
-            StartTimer {
-                seq: i,
-                ..Default::default()
-            }
-            .into(),
+            start_timer_cmd(i, Duration::from_secs(1)),
         ))
         .await
         .unwrap();
@@ -945,7 +894,7 @@ async fn max_concurrent_wft_respected() {
         assert_eq!(r1.run_id, r1_run_id);
     }
     // Finish the tasks so we can shut down
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         r1.run_id,
         CompleteWorkflowExecution { result: None }.into(),
@@ -957,20 +906,16 @@ async fn max_concurrent_wft_respected() {
     // We have to properly complete the outstanding task (or the mock will be confused why a task
     // failure was reported)
     let _ = core
-        .complete_workflow_activation(WfActivationCompletion::from_cmd(
+        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             TEST_Q,
             r2.run_id,
-            StartTimer {
-                seq: 1,
-                ..Default::default()
-            }
-            .into(),
+            start_timer_cmd(1, Duration::from_secs(1)),
         ))
         .await;
     // Get and complete eviction
     let r2 = core.poll_workflow_activation(TEST_Q).await.unwrap();
     let _ = core
-        .complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, r2.run_id))
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, r2.run_id))
         .await;
     core.shutdown().await;
 }
@@ -988,7 +933,7 @@ async fn activity_not_canceled_on_replay_repro(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 // Start timer and activity
                 vec![
                     ScheduleActivity {
@@ -998,31 +943,23 @@ async fn activity_not_canceled_on_replay_repro(hist_batches: &'static [usize]) {
                         ..Default::default()
                     }
                     .into(),
-                    StartTimer {
-                        seq: 1,
-                        ..Default::default()
-                    }
-                    .into(),
+                    start_timer_cmd(1, Duration::from_secs(1)),
                 ],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::FireTimer(_)),
+                &job_assert!(workflow_activation_job::Variant::FireTimer(_)),
                 vec![RequestCancelActivity { seq: activity_id }.into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(..)),
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(..)),
                         }),
                         ..
                     }
                 )),
-                vec![StartTimer {
-                    seq: 2,
-                    ..Default::default()
-                }
-                .into()],
+                vec![start_timer_cmd(2, Duration::from_secs(1))],
             ),
         ],
     )
@@ -1042,7 +979,7 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: activity_id.to_string(),
@@ -1052,21 +989,17 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static
                 .into()],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::SignalWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::SignalWorkflow(_)),
                 vec![
                     RequestCancelActivity { seq: activity_id }.into(),
-                    StartTimer {
-                        seq: 2,
-                        ..Default::default()
-                    }
-                    .into(),
+                    start_timer_cmd(2, Duration::from_secs(1)),
                 ],
             ),
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::ResolveActivity(
+                &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Cancelled(..)),
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Cancelled(..)),
                         }),
                         ..
                     }
@@ -1097,13 +1030,11 @@ async fn lots_of_workflows() {
         while let Ok(wft) = core.poll_workflow_activation(TEST_Q).await {
             let job = &wft.jobs[0];
             let reply = match job.variant {
-                Some(wf_activation_job::Variant::StartWorkflow(_)) => StartTimer {
-                    seq: 1,
-                    ..Default::default()
+                Some(workflow_activation_job::Variant::StartWorkflow(_)) => {
+                    start_timer_cmd(1, Duration::from_secs(1))
                 }
-                .into(),
-                Some(wf_activation_job::Variant::RemoveFromCache(_)) => {
-                    core.complete_workflow_activation(WfActivationCompletion::empty(
+                Some(workflow_activation_job::Variant::RemoveFromCache(_)) => {
+                    core.complete_workflow_activation(WorkflowActivationCompletion::empty(
                         TEST_Q, wft.run_id,
                     ))
                     .await
@@ -1112,7 +1043,7 @@ async fn lots_of_workflows() {
                 }
                 _ => CompleteWorkflowExecution { result: None }.into(),
             };
-            core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
                 TEST_Q, wft.run_id, reply,
             ))
             .await
@@ -1143,7 +1074,7 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(wf_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: activity_id.to_string(),
@@ -1154,11 +1085,11 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) {
             ),
             gen_assert_and_reply(
                 &job_assert!(
-                    wf_activation_job::Variant::SignalWorkflow(_),
-                    wf_activation_job::Variant::SignalWorkflow(_),
-                    wf_activation_job::Variant::ResolveActivity(ResolveActivity {
-                        result: Some(ActivityResult {
-                            status: Some(activity_result::Status::Completed(..)),
+                    workflow_activation_job::Variant::SignalWorkflow(_),
+                    workflow_activation_job::Variant::SignalWorkflow(_),
+                    workflow_activation_job::Variant::ResolveActivity(ResolveActivity {
+                        result: Some(ActivityResolution {
+                            status: Some(activity_resolution::Status::Completed(..)),
                         }),
                         ..
                     })
@@ -1174,7 +1105,7 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) {
 async fn complete_after_eviction() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let mut mock = MockServerGatewayApis::new();
+    let mut mock = mock_gateway();
     mock.expect_complete_workflow_task().times(0);
     let mock = single_hist_mock_sg(wfid, t, &[2], mock, true);
     let core = mock_core(mock);
@@ -1183,14 +1114,10 @@ async fn complete_after_eviction() {
     // We just got start workflow, immediately evict
     core.request_workflow_eviction(TEST_Q, &activation.run_id);
     // Original task must be completed before we get the eviction
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
-        StartTimer {
-            seq: 1,
-            ..Default::default()
-        }
-        .into(),
+        start_timer_cmd(1, Duration::from_secs(1)),
     ))
     .await
     .unwrap();
@@ -1198,16 +1125,16 @@ async fn complete_after_eviction() {
     assert_matches!(
         eviction_activation.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(_)),
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
             },
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
             }
         ]
     );
     // Complete the activation containing the eviction, the way we normally would have
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         eviction_activation.run_id,
         vec![CompleteWorkflowExecution { result: None }.into()],
@@ -1223,7 +1150,7 @@ async fn sends_appropriate_sticky_task_queue_responses() {
     // include the information that tells the server to enqueue the next task on a sticky queue.
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let mut mock = MockServerGatewayApis::new();
+    let mut mock = mock_gateway();
     mock.expect_complete_workflow_task()
         .withf(|comp| comp.sticky_attributes.is_some())
         .times(1)
@@ -1234,14 +1161,10 @@ async fn sends_appropriate_sticky_task_queue_responses() {
     let core = mock_core(mock);
 
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
-        StartTimer {
-            seq: 1,
-            ..Default::default()
-        }
-        .into(),
+        start_timer_cmd(1, Duration::from_secs(1)),
     ))
     .await
     .unwrap();
@@ -1249,37 +1172,33 @@ async fn sends_appropriate_sticky_task_queue_responses() {
 }
 
 #[tokio::test]
-#[should_panic(expected = "called more than 2 times")]
 async fn new_server_work_while_eviction_outstanding_doesnt_overwrite_activation() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let mock = MockServerGatewayApis::new();
-    let mock = single_hist_mock_sg(wfid, t, &[1, 2], mock, true);
+    let mock = single_hist_mock_sg(wfid, t, &[1, 2], mock_gateway(), false);
     let core = mock_core(mock);
 
     // Poll for and complete first workflow task
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
-        StartTimer {
-            seq: 1,
-            ..Default::default()
-        }
-        .into(),
+        start_timer_cmd(1, Duration::from_secs(1)),
     ))
     .await
     .unwrap();
     let eviction_activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_matches!(
         eviction_activation.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
     // Poll again. We should not overwrite the eviction with the new work from the server to fire
-    // the timer. IE: We will panic here because the mock has no more responses.
-    core.poll_workflow_activation(TEST_Q).await.unwrap();
+    // the timer, so polling will try again, and run into the mock being out of responses.
+    let act = core.poll_workflow_activation(TEST_Q).await;
+    assert_matches!(act, Err(PollWfError::TonicError(err))
+                    if err.message() == NO_MORE_WORK_ERROR_MSG);
     core.shutdown().await;
 }
 
@@ -1318,7 +1237,7 @@ async fn buffered_work_drained_on_shutdown() {
         ))
         .take(50),
     );
-    let mut mock = MockServerGatewayApis::new();
+    let mut mock = mock_gateway();
     mock.expect_complete_workflow_task()
         .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
     let mut mock = MocksHolder::from_gateway_with_responses(mock, tasks, []);
@@ -1332,7 +1251,7 @@ async fn buffered_work_drained_on_shutdown() {
         // Now poll again, which will start spinning, and buffer the next WFT with timer fired in it
         // - it won't stop spinning until the first task is complete
         let t = core.poll_workflow_activation(TEST_Q).await.unwrap();
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             TEST_Q,
             t.run_id,
             vec![CompleteWorkflowExecution { result: None }.into()],
@@ -1341,14 +1260,10 @@ async fn buffered_work_drained_on_shutdown() {
         .unwrap();
     };
     let complete_first = async move {
-        core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             TEST_Q,
             act1.run_id,
-            StartTimer {
-                seq: 1,
-                ..Default::default()
-            }
-            .into(),
+            start_timer_cmd(1, Duration::from_secs(1)),
         ))
         .await
         .unwrap();
@@ -1364,7 +1279,7 @@ async fn buffered_work_drained_on_shutdown() {
 async fn buffering_tasks_doesnt_count_toward_outstanding_max() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let mock = MockServerGatewayApis::new();
+    let mock = mock_gateway();
     let mut tasks = VecDeque::new();
     // A way bigger task list than allowed outstanding tasks
     tasks.extend(
@@ -1400,7 +1315,7 @@ async fn fail_wft_then_recover() {
         t,
         // We need to deliver all of history twice because of eviction
         [ResponseType::AllHistory, ResponseType::AllHistory],
-        MockServerGatewayApis::new(),
+        mock_gateway(),
     );
     mh.num_expected_fails = Some(1);
     mh.expect_fail_wft_matcher =
@@ -1413,7 +1328,7 @@ async fn fail_wft_then_recover() {
 
     let act = core.poll_workflow_activation(TEST_Q).await.unwrap();
     // Start an activity instead of a timer, triggering nondeterminism error
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         act.run_id.clone(),
         vec![ScheduleActivity {
@@ -1429,35 +1344,34 @@ async fn fail_wft_then_recover() {
     assert_eq!(evict_act.run_id, act.run_id);
     assert_matches!(
         evict_act.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, evict_act.run_id))
-        .await
-        .unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+        TEST_Q,
+        evict_act.run_id,
+    ))
+    .await
+    .unwrap();
 
     // Workflow starting over, this time issue the right command
     let act = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         act.run_id,
-        vec![StartTimer {
-            seq: 1,
-            ..Default::default()
-        }
-        .into()],
+        vec![start_timer_cmd(1, Duration::from_secs(1))],
     ))
     .await
     .unwrap();
     let act = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_matches!(
         act.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::FireTimer(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::FireTimer(_)),
         },]
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         act.run_id,
         vec![CompleteWorkflowExecution { result: None }.into()],
@@ -1476,12 +1390,8 @@ async fn poll_response_triggers_wf_error() {
     t.add_full_wf_task();
     t.add_workflow_execution_completed();
 
-    let mut mh = MockPollCfg::from_resp_batches(
-        "fake_wf_id",
-        t,
-        [ResponseType::AllHistory],
-        MockServerGatewayApis::new(),
-    );
+    let mut mh =
+        MockPollCfg::from_resp_batches("fake_wf_id", t, [ResponseType::AllHistory], mock_gateway());
     // Since applying the poll response immediately generates an error core will start polling again
     // Rather than panic on bad expectation we want to return the magic "no more work" error
     mh.enforce_correct_number_of_polls = false;
@@ -1509,7 +1419,7 @@ async fn lang_slower_than_wft_timeouts() {
         hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()),
         hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()),
     ];
-    let mut mock = MockServerGatewayApis::new();
+    let mut mock = mock_gateway();
     mock.expect_complete_workflow_task()
         .times(1)
         .returning(|_| Err(tonic::Status::not_found("Workflow task not found.")));
@@ -1528,27 +1438,27 @@ async fn lang_slower_than_wft_timeouts() {
                     if err.message() == NO_MORE_WORK_ERROR_MSG);
     // This completion runs into a workflow task not found error, since it's completing a stale
     // task.
-    core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, wf_task.run_id))
         .await
         .unwrap();
     // Now we should get an eviction
     let wf_task = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_matches!(
         wf_task.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, wf_task.run_id))
         .await
         .unwrap();
     // The last WFT buffered should be applied now
     let start_again = core.poll_workflow_activation(TEST_Q).await.unwrap();
     assert_matches!(
         start_again.jobs[0].variant,
-        Some(wf_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::StartWorkflow(_))
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         start_again.run_id,
         vec![CompleteWorkflowExecution { result: None }.into()],
@@ -1569,13 +1479,13 @@ async fn tries_cancel_of_completed_activity() {
     t.add_activity_task_completed(scheduled_event_id, started_event_id, Default::default());
     t.add_workflow_task_scheduled_and_started();
 
-    let mock = MockServerGatewayApis::new();
+    let mock = mock_gateway();
     let mut mock = single_hist_mock_sg("fake_wf_id", t, &[1, 2], mock, true);
     mock.worker_cfg(TEST_Q, |cfg| cfg.max_cached_workflows = 1);
     let core = mock_core(mock);
 
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
         ScheduleActivity {
@@ -1591,15 +1501,15 @@ async fn tries_cancel_of_completed_activity() {
     assert_matches!(
         activation.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::SignalWorkflow(_)),
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
             },
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(_)),
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
             }
         ]
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         TEST_Q,
         activation.run_id,
         vec![
@@ -1619,22 +1529,22 @@ async fn failing_wft_doesnt_eat_permit_forever() {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_workflow_task_scheduled_and_started();
 
-    let failures = 5;
-    // One extra response for when we stop failing
-    let resps = (1..=(failures + 1)).map(|_| 1);
-    let mock = MockServerGatewayApis::new();
-    let mut mock = single_hist_mock_sg("fake_wf_id", t, resps, mock, true);
+    let mock = mock_gateway();
+    let mut mock = single_hist_mock_sg("fake_wf_id", t, [1, 1, 1], mock, true);
     mock.worker_cfg(TEST_Q, |cfg| {
         cfg.max_cached_workflows = 2;
         cfg.max_outstanding_workflow_tasks = 2;
     });
+    let outstanding_mock_tasks = mock.outstanding_task_map.clone();
     let core = mock_core(mock);
 
-    // Spin failing the WFT to verify that we don't get stuck
-    for _ in 1..=failures {
+    let mut run_id = "".to_string();
+    // Fail twice, verifying a permit is eaten. We cannot fail the same run more than twice in a row
+    // because we purposefully time out rather than spamming.
+    for _ in 1..=2 {
         let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
         // Issue a nonsense completion that will trigger a WFT failure
-        core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             TEST_Q,
             activation.run_id,
             RequestCancelActivity { seq: 1 }.into(),
@@ -1644,18 +1554,31 @@ async fn failing_wft_doesnt_eat_permit_forever() {
         let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
         assert_matches!(
             activation.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
             },]
         );
-        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
-            .await
-            .unwrap();
+        run_id = activation.run_id.clone();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+            TEST_Q,
+            activation.run_id,
+        ))
+        .await
+        .unwrap();
         assert_eq!(core.outstanding_wfts(TEST_Q), 0);
         assert_eq!(core.available_wft_permits(TEST_Q), 2);
     }
+    // We should be "out of work" because the mock service thinks we didn't complete the last task,
+    // which we didn't, because we don't spam failures. The real server would eventually time out
+    // the task. Mock doesn't understand that, so the WFT permit is released because eventually a
+    // new one will be generated. We manually clear the mock's outstanding task list so the next
+    // poll will work.
+    outstanding_mock_tasks
+        .unwrap()
+        .write()
+        .remove_by_left(&run_id);
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
         CompleteWorkflowExecution { result: None }.into(),
@@ -1688,7 +1611,7 @@ async fn cache_miss_doesnt_eat_permit_forever() {
             // Last one to complete successfully
             ResponseType::ToTaskNum(1),
         ],
-        MockServerGatewayApis::new(),
+        mock_gateway(),
     );
     mh.num_expected_fails = Some(3);
     mh.expect_fail_wft_matcher =
@@ -1703,20 +1626,26 @@ async fn cache_miss_doesnt_eat_permit_forever() {
     for _ in 1..=3 {
         // Start
         let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
-            .await
-            .unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+            TEST_Q,
+            activation.run_id,
+        ))
+        .await
+        .unwrap();
         // Evict
         let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
         assert_matches!(
             activation.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
             },]
         );
-        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
-            .await
-            .unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(
+            TEST_Q,
+            activation.run_id,
+        ))
+        .await
+        .unwrap();
         assert_eq!(core.outstanding_wfts(TEST_Q), 0);
         assert_eq!(core.available_wft_permits(TEST_Q), 2);
         // When we loop back up, the poll will trigger a cache miss, which we should immediately
@@ -1724,7 +1653,7 @@ async fn cache_miss_doesnt_eat_permit_forever() {
         // history
     }
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         TEST_Q,
         activation.run_id,
         CompleteWorkflowExecution { result: None }.into(),
@@ -1734,3 +1663,62 @@ async fn cache_miss_doesnt_eat_permit_forever() {
 
     core.shutdown().await;
 }
+
+/// This test verifies that WFTs which come as replies to completing a WFT are properly delivered
+/// via activation polling.
+#[tokio::test]
+async fn tasks_from_completion_are_delivered() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_we_signaled("sig", vec![]);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let tasks = [hist_to_poll_resp(
+        &t,
+        wfid.to_owned(),
+        1.into(),
+        TEST_Q.to_string(),
+    )];
+    let mut mock = mock_gateway();
+    mock.expect_complete_workflow_task()
+        .times(1)
+        .returning(move |_| {
+            Ok(RespondWorkflowTaskCompletedResponse {
+                workflow_task: Some(hist_to_poll_resp(
+                    &t,
+                    wfid.to_owned(),
+                    2.into(),
+                    TEST_Q.to_string(),
+                )),
+            })
+        });
+    mock.expect_complete_workflow_task()
+        .times(1)
+        .returning(|_| Ok(Default::default()));
+    let mut mock = MocksHolder::from_gateway_with_responses(mock, tasks, []);
+    mock.worker_cfg(TEST_Q, |wc| wc.max_cached_workflows = 2);
+    let core = mock_core(mock);
+
+    let wf_task = core.poll_workflow_activation(TEST_Q).await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, wf_task.run_id))
+        .await
+        .unwrap();
+    let wf_task = core.poll_workflow_activation(TEST_Q).await.unwrap();
+    assert_matches!(
+        wf_task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
+        },]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        TEST_Q,
+        wf_task.run_id,
+        vec![CompleteWorkflowExecution { result: None }.into()],
+    ))
+    .await
+    .unwrap();
+    core.shutdown().await;
+}