@temporalio/core-bridge 0.19.2 → 0.20.0

package/sdk-core/tests/integ_tests/workflow_tests/stickyness.rs

@@ -3,6 +3,7 @@ use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio::sync::Barrier;
@@ -16,7 +17,12 @@ async fn timer_workflow_not_sticky() {
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -46,7 +52,12 @@ async fn timer_workflow_timeout_on_sticky() {
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -69,14 +80,18 @@ async fn cache_miss_ok() {
     });
 
     let run_id = worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
-    let core = starter.get_core().await;
-    let tq = starter.get_task_queue();
+    let core = starter.get_worker().await;
     let (r1, _) = tokio::join!(worker.run_until_done(), async move {
         barr.wait().await;
-        core.request_workflow_eviction(tq, &run_id);
+        core.request_workflow_eviction(&run_id);
         // We need to signal the barrier again since the wf gets evicted and will hit it again
         barr.wait().await;
     });

package/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -1,11 +1,12 @@
 use std::time::Duration;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, start_timer_cmd, CoreTestHelpers, CoreWfStarter,
+    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -21,7 +22,12 @@ async fn timer_workflow_workflow_driver() {
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -29,10 +35,10 @@ async fn timer_workflow_workflow_driver() {
 
 #[tokio::test]
 async fn timer_workflow_manual() {
-    let (core, task_q) = init_core_and_create_wf("timer_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 0,
@@ -42,17 +48,17 @@ async fn timer_workflow_manual() {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
     core.shutdown().await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
-    let (core, task_q) = init_core_and_create_wf("timer_cancel_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             StartTimer {
@@ -69,9 +75,8 @@ async fn timer_cancel_workflow() {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             CancelTimer { seq: 1 }.into(),
@@ -84,10 +89,10 @@ async fn timer_cancel_workflow() {
 
 #[tokio::test]
 async fn timer_immediate_cancel_workflow() {
-    let (core, task_q) = init_core_and_create_wf("timer_immediate_cancel_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_immediate_cancel_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             start_timer_cmd(0, Duration::from_secs(1)),
@@ -114,7 +119,12 @@ async fn parallel_timers() {
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/tests/integ_tests/workflow_tests/upsert_search_attrs.rs

@@ -0,0 +1,66 @@
+use std::collections::HashMap;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+// These are initialized on the server as part of the autosetup container which we
+// use for integration tests.
+static TXT_ATTR: &str = "CustomTextField";
+static INT_ATTR: &str = "CustomIntField";
+
+async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.upsert_search_attributes([
+        (TXT_ATTR.to_string(), "goodbye".as_json_payload().unwrap()),
+        (INT_ATTR.to_string(), 98.as_json_payload().unwrap()),
+    ]);
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_upsert() {
+    let wf_name = "sends_upsert_search_attrs";
+    let wf_id = Uuid::new_v4();
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name, search_attr_updater);
+    let run_id = worker
+        .submit_wf(
+            wf_id.to_string(),
+            wf_name,
+            vec![],
+            WorkflowOptions {
+                search_attributes: Some(HashMap::from([
+                    (TXT_ATTR.to_string(), "hello".as_json_payload().unwrap()),
+                    (INT_ATTR.to_string(), 1.as_json_payload().unwrap()),
+                ])),
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let search_attrs = starter
+        .get_client()
+        .await
+        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+        .await
+        .unwrap()
+        .workflow_execution_info
+        .unwrap()
+        .search_attributes
+        .unwrap()
+        .indexed_fields;
+    let txt_attr_payload = search_attrs.get(TXT_ATTR).unwrap();
+    let int_attr_payload = search_attrs.get(INT_ATTR).unwrap();
+    for payload in [txt_attr_payload, int_attr_payload] {
+        assert_eq!(
+            &b"json/plain".to_vec(),
+            payload.metadata.get("encoding").unwrap()
+        );
+    }
+    assert_eq!("\"goodbye\"", txt_attr_payload.to_string());
+    assert_eq!("98", int_attr_payload.to_string());
+}

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -7,9 +7,11 @@ mod determinism;
 mod local_activities;
 mod patches;
 mod replay;
+mod resets;
 mod signals;
 mod stickyness;
 mod timers;
+mod upsert_search_attrs;
 
 use assert_matches::assert_matches;
 use futures::{channel::mpsc::UnboundedReceiver, future, SinkExt, StreamExt};
@@ -21,8 +23,9 @@ use std::{
     },
     time::Duration,
 };
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_api::{errors::PollWfError, Core};
+use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
@@ -35,7 +38,7 @@ use temporal_sdk_core_protos::{
 };
 use temporal_sdk_core_test_utils::{
     history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -46,19 +49,18 @@ use uuid::Uuid;
 #[tokio::test]
 async fn parallel_workflows_same_queue() {
     let mut starter = CoreWfStarter::new("parallel_workflows_same_queue");
-    let core = starter.get_core().await;
-    let task_q = starter.get_task_queue().to_string();
+    let core = starter.get_worker().await;
     let num_workflows = 25usize;
 
     let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{}", i))),
+        (0..num_workflows)
+            .map(|i| starter.start_wf_with_id(format!("wf-id-{}", i), WorkflowOptions::default())),
     )
     .await;
 
     let mut send_chans = HashMap::new();
     async fn wf_task(
-        core: Arc<dyn Core>,
-        task_q: String,
+        worker: Arc<dyn Worker>,
         mut task_chan: UnboundedReceiver<WorkflowActivation>,
     ) {
         let task = task_chan.next().await.unwrap();
@@ -68,10 +70,11 @@ async fn parallel_workflows_same_queue() {
                 variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
             }]
         );
-        core.complete_timer(&task_q, &task.run_id, 1, Duration::from_secs(1))
+        worker
+            .complete_timer(&task.run_id, 1, Duration::from_secs(1))
             .await;
         let task = task_chan.next().await.unwrap();
-        core.complete_execution(&task_q, &task.run_id).await;
+        worker.complete_execution(&task.run_id).await;
     }
 
     let handles: Vec<_> = run_ids
@@ -79,12 +82,12 @@ async fn parallel_workflows_same_queue() {
         .map(|run_id| {
             let (tx, rx) = futures::channel::mpsc::unbounded();
             send_chans.insert(run_id.clone(), tx);
-            tokio::spawn(wf_task(core.clone(), task_q.clone(), rx))
+            tokio::spawn(wf_task(core.clone(), rx))
         })
         .collect();
 
     for _ in 0..num_workflows * 2 {
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         send_chans
             .get(&task.run_id)
             .unwrap()
@@ -120,6 +123,7 @@ async fn workflow_lru_cache_evictions() {
                 format!("wce-{}", Uuid::new_v4()),
                 wf_type.to_string(),
                 vec![],
+                WorkflowOptions::default(),
             )
             .await
             .unwrap();
@@ -136,8 +140,7 @@ async fn workflow_lru_cache_evictions() {
 #[tokio::test]
 async fn shutdown_aborts_actively_blocked_poll() {
     let mut starter = CoreWfStarter::new("shutdown_aborts_actively_blocked_poll");
-    let core = starter.get_core().await;
-    let task_q = starter.get_task_queue();
+    let core = starter.get_worker().await;
     // Begin the poll, and request shutdown from another thread after a small period of time.
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
@@ -145,14 +148,14 @@ async fn shutdown_aborts_actively_blocked_poll() {
         tcore.shutdown().await;
     });
     assert_matches!(
-        core.poll_workflow_activation(task_q).await.unwrap_err(),
+        core.poll_workflow_activation().await.unwrap_err(),
         PollWfError::ShutDown
     );
     handle.await.unwrap();
     // Ensure double-shutdown doesn't explode
     core.shutdown().await;
     assert_matches!(
-        core.poll_workflow_activation(task_q).await.unwrap_err(),
+        core.poll_workflow_activation().await.unwrap_err(),
         PollWfError::ShutDown
     );
 }
@@ -160,25 +163,26 @@ async fn shutdown_aborts_actively_blocked_poll() {
 #[rstest::rstest]
 #[tokio::test]
 async fn fail_wf_task(#[values(true, false)] replay: bool) {
-    let (core, task_q) = if replay {
-        init_core_replay_preloaded(
+    let core = if replay {
+        let (core, _) = init_core_replay_preloaded(
             "fail_wf_task",
             &history_from_proto_binary("histories/fail_wf_task.bin")
                 .await
                 .unwrap(),
-        )
+        );
+        core
     } else {
-        init_core_and_create_wf("fail_wf_task").await
+        let mut starter = init_core_and_create_wf("fail_wf_task").await;
+        starter.get_worker().await
     };
     // Start with a timer
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_timer(&task_q, &task.run_id, 0, Duration::from_millis(200))
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_timer(&task.run_id, 0, Duration::from_millis(200))
         .await;
 
     // Then break for whatever reason
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-        &task_q,
         task.run_id,
         Failure::application_failure("I did an oopsie".to_string(), false),
     ))
@@ -187,7 +191,7 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
 
     // The server will want to retry the task. This time we finish the workflow -- but we need
     // to poll a couple of times as there will be more than one required workflow activation.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // The first poll response will tell us to evict
     assert_matches!(
         task.jobs.as_slice(),
@@ -195,13 +199,12 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(&task_q, task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
         .await
         .unwrap();
 
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 0,
@@ -211,19 +214,21 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn fail_workflow_execution() {
-    let (core, task_q) = init_core_and_create_wf("fail_workflow_execution").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_timer(&task_q, &task.run_id, 0, Duration::from_secs(1))
+    let core = init_core_and_create_wf("fail_workflow_execution")
+        .await
+        .get_worker()
+        .await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_timer(&task.run_id, 0, Duration::from_secs(1))
         .await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![FailWorkflowExecution {
             failure: Some(Failure::application_failure("I'm ded".to_string(), false)),
@@ -236,15 +241,16 @@ async fn fail_workflow_execution() {
 
 #[tokio::test]
 async fn signal_workflow() {
-    let (core, task_q) = init_core_and_create_wf("signal_workflow").await;
-    let workflow_id = task_q.clone();
+    let mut starter = init_core_and_create_wf("signal_workflow").await;
+    let core = starter.get_worker().await;
+    let client = starter.get_client().await;
+    let workflow_id = starter.get_task_queue().to_string();
 
     let signal_id_1 = "signal1";
     let signal_id_2 = "signal2";
-    let res = core.poll_workflow_activation(&task_q).await.unwrap();
+    let res = core.poll_workflow_activation().await.unwrap();
     // Task is completed with no commands
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         res.run_id.clone(),
         vec![],
     ))
@@ -252,7 +258,7 @@ async fn signal_workflow() {
     .unwrap();
 
     // Send the signals to the server
-    core.server_gateway()
+    client
         .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
@@ -261,7 +267,7 @@ async fn signal_workflow() {
         )
         .await
         .unwrap();
-    core.server_gateway()
+    client
         .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
@@ -271,7 +277,7 @@ async fn signal_workflow() {
         .await
         .unwrap();
 
-    let mut res = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut res = core.poll_workflow_activation().await.unwrap();
     // Sometimes both signals are complete at once, sometimes only one, depending on server
     // Converting test to wf function type would make this shorter
     if res.jobs.len() == 2 {
@@ -294,13 +300,12 @@ async fn signal_workflow() {
             },]
         );
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             res.run_id,
             vec![],
         ))
         .await
         .unwrap();
-        res = core.poll_workflow_activation(&task_q).await.unwrap();
+        res = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             res.jobs.as_slice(),
             [WorkflowActivationJob {
@@ -308,20 +313,20 @@ async fn signal_workflow() {
             },]
         );
     }
-    core.complete_execution(&task_q, &res.run_id).await;
+    core.complete_execution(&res.run_id).await;
 }
 
 #[tokio::test]
 async fn signal_workflow_signal_not_handled_on_workflow_completion() {
-    let (core, task_q) =
+    let mut starter =
         init_core_and_create_wf("signal_workflow_signal_not_handled_on_workflow_completion").await;
-    let workflow_id = task_q.as_str();
+    let core = starter.get_worker().await;
+    let workflow_id = starter.get_task_queue().to_string();
     let signal_id_1 = "signal1";
     for i in 1..=2 {
-        let res = core.poll_workflow_activation(&task_q).await.unwrap();
+        let res = core.poll_workflow_activation().await.unwrap();
         // Task is completed with a timer
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             res.run_id,
             vec![StartTimer {
                 seq: 0,
@@ -332,7 +337,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
         .await
         .unwrap();
 
-        let res = core.poll_workflow_activation(&task_q).await.unwrap();
+        let res = core.poll_workflow_activation().await.unwrap();
 
         if i == 1 {
             // First attempt we should only see the timer being fired
@@ -346,9 +351,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             let run_id = res.run_id.clone();
 
             // Send the signal to the server
-            core.server_gateway()
+            starter
+                .get_client()
+                .await
                 .signal_workflow_execution(
-                    workflow_id.to_string(),
+                    workflow_id.clone(),
                     res.run_id.to_string(),
                     signal_id_1.to_string(),
                     None,
@@ -358,22 +365,19 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
 
             // Send completion - not having seen a poll response with a signal in it yet (unhandled
             // command error will be logged as a warning and an eviction will be issued)
-            core.complete_execution(&task_q, &run_id).await;
+            core.complete_execution(&run_id).await;
 
             // We should be told to evict
-            let res = core.poll_workflow_activation(&task_q).await.unwrap();
+            let res = core.poll_workflow_activation().await.unwrap();
             assert_matches!(
                 res.jobs.as_slice(),
                 [WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }]
             );
-            core.complete_workflow_activation(WorkflowActivationCompletion::empty(
-                task_q.clone(),
-                res.run_id,
-            ))
-            .await
-            .unwrap();
+            core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
+                .await
+                .unwrap();
             // Loop to the top to handle wf from the beginning
             continue;
         }
@@ -390,7 +394,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
                 }
             ]
         );
-        core.complete_execution(&task_q, &res.run_id).await;
+        core.complete_execution(&res.run_id).await;
     }
 }
 
@@ -404,13 +408,14 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0usize)
         .wft_timeout(Duration::from_secs(1));
-    let core = wf_starter.get_core().await;
+    let core = wf_starter.get_worker().await;
+    let client = wf_starter.get_client().await;
     let task_q = wf_starter.get_task_queue();
     let wf_id = &wf_starter.get_wf_id().to_owned();
 
     // Set up some helpers for polling and completing
     let poll_sched_act = || async {
-        let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+        let wf_task = core.poll_workflow_activation().await.unwrap();
         core.complete_workflow_activation(
             schedule_activity_cmd(
                 0,
@@ -420,7 +425,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
                 Duration::from_secs(60),
                 Duration::from_secs(60),
             )
-            .into_completion(task_q.to_string(), wf_task.run_id.clone()),
+            .into_completion(wf_task.run_id.clone()),
         )
         .await
         .unwrap();
@@ -428,7 +433,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     };
     let poll_sched_act_poll = || async {
         poll_sched_act().await;
-        let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+        let wf_task = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             wf_task.jobs.as_slice(),
             [
@@ -452,36 +457,35 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let wf_task = poll_sched_act().await;
     // Before polling for a task again, we start and complete the activity and send the
     // corresponding signals.
-    let ac_task = core.poll_activity_task(task_q).await.unwrap();
+    let ac_task = core.poll_activity_task().await.unwrap();
     let rid = wf_task.run_id.clone();
     // Send the signals to the server & resolve activity -- sometimes this happens too fast
     sleep(Duration::from_millis(200)).await;
-    core.server_gateway()
+    client
         .signal_workflow_execution(wf_id.to_string(), rid, signal_at_start.to_string(), None)
         .await
         .unwrap();
     // Complete activity successfully.
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: ac_task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::ok(Default::default())),
     })
     .await
     .unwrap();
     let rid = wf_task.run_id.clone();
-    core.server_gateway()
+    client
         .signal_workflow_execution(wf_id.to_string(), rid, signal_at_complete.to_string(), None)
         .await
         .unwrap();
     // Now poll again, it will be an eviction b/c non-sticky mode.
-    let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+    let wf_task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         wf_task.jobs.as_slice(),
         [WorkflowActivationJob {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
         .await
         .unwrap();
     // Start from the beginning
@@ -491,11 +495,11 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     // Poll again, which should not have any work to do and spin, until the complete goes through.
     // Which will be rejected with not found, producing an eviction.
     let (wf_task, _) = tokio::join!(
-        async { core.poll_workflow_activation(task_q).await.unwrap() },
+        async { core.poll_workflow_activation().await.unwrap() },
         async {
             sleep(Duration::from_millis(500)).await;
             // Reply to the first one, finally
-            core.complete_execution(task_q, &wf_task.run_id).await;
+            core.complete_execution(&wf_task.run_id).await;
         }
     );
     assert_matches!(
@@ -504,10 +508,10 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
         .await
         .unwrap();
     // Do it all over again, without timing out this time
     let wf_task = poll_sched_act_poll().await;
-    core.complete_execution(task_q, &wf_task.run_id).await;
+    core.complete_execution(&wf_task.run_id).await;
 }