@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -1,5 +1,10 @@
 use assert_matches::assert_matches;
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk_core::{
+    ephemeral_server::TemporalDevServerConfigBuilder, init_worker, ClientOptionsBuilder,
+};
+use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
     workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
@@ -8,9 +13,12 @@ use temporal_sdk_core_protos::coresdk::{
     IntoCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, WorkerTestHelpers,
+    default_cached_download, drain_pollers_and_shutdown, init_core_and_create_wf, init_integ_telem,
+    integ_worker_config, schedule_activity_cmd, WorkerTestHelpers,
 };
 use tokio::time::timeout;
+use tracing::info;
+use url::Url;
 
 #[tokio::test]
 async fn out_of_order_completion_doesnt_hang() {
@@ -88,3 +96,111 @@ async fn out_of_order_completion_doesnt_hang() {
 
     jh.await.unwrap();
 }
+
+#[tokio::test]
+async fn switching_worker_client_changes_poll() {
+    // Start two servers
+    info!("Starting servers");
+    let server_config = TemporalDevServerConfigBuilder::default()
+        .exe(default_cached_download())
+        // We need to lower the poll timeout so the poll call rolls over
+        .extra_args(vec![
+            "--dynamic-config-value".to_string(),
+            "matching.longPollExpirationInterval=\"1s\"".to_string(),
+        ])
+        .build()
+        .unwrap();
+    let mut server1 = server_config.start_server().await.unwrap();
+    let mut server2 = server_config.start_server().await.unwrap();
+
+    // Connect clients to both servers
+    info!("Connecting clients");
+    let mut client_common_config = ClientOptionsBuilder::default();
+    client_common_config
+        .identity("integ_tester".to_owned())
+        .client_name("temporal-core".to_owned())
+        .client_version("0.1.0".to_owned());
+    let client1 = client_common_config
+        .clone()
+        .target_url(Url::parse(&format!("http://{}", server1.target)).unwrap())
+        .build()
+        .unwrap()
+        .connect("default", None)
+        .await
+        .unwrap();
+    let client2 = client_common_config
+        .clone()
+        .target_url(Url::parse(&format!("http://{}", server2.target)).unwrap())
+        .build()
+        .unwrap()
+        .connect("default", None)
+        .await
+        .unwrap();
+
+    // Start a workflow on both servers
+    info!("Starting workflows");
+    let wf1 = client1
+        .start_workflow(
+            vec![],
+            "my-task-queue".to_owned(),
+            "my-workflow-1".to_owned(),
+            "my-workflow-type".to_owned(),
+            None,
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    let wf2 = client2
+        .start_workflow(
+            vec![],
+            "my-task-queue".to_owned(),
+            "my-workflow-2".to_owned(),
+            "my-workflow-type".to_owned(),
+            None,
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    // Create a worker only on the first server
+    let worker = init_worker(
+        init_integ_telem(),
+        integ_worker_config("my-task-queue")
+            // We want a cache so we don't get extra remove-job activations
+            .max_cached_workflows(100_usize)
+            .build()
+            .unwrap(),
+        client1.clone(),
+    )
+    .unwrap();
+
+    // Poll for first task, confirm it's first wf, complete, and wait for complete
+    info!("Doing initial poll");
+    let act1 = worker.poll_workflow_activation().await.unwrap();
+    assert_eq!(wf1.run_id, act1.run_id);
+    worker.complete_execution(&act1.run_id).await;
+    info!("Waiting on first workflow complete");
+    client1
+        .get_untyped_workflow_handle("my-workflow-1", wf1.run_id)
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+
+    // Swap client, poll for next task, confirm it's second wf, and respond w/ empty
+    info!("Replacing client and polling again");
+    worker.replace_client(client2.get_client().inner().clone());
+    let act2 = worker.poll_workflow_activation().await.unwrap();
+    assert_eq!(wf2.run_id, act2.run_id);
+    worker.complete_execution(&act2.run_id).await;
+    info!("Waiting on second workflow complete");
+    client2
+        .get_untyped_workflow_handle("my-workflow-2", wf2.run_id)
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+
+    // Shutdown workers and servers
+    drain_pollers_and_shutdown(&(Arc::new(worker) as Arc<dyn Worker>)).await;
+    server1.shutdown().await.unwrap();
+    server2.shutdown().await.unwrap();
+}

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

@@ -1,7 +1,7 @@
 use anyhow::{anyhow, bail};
 use assert_matches::assert_matches;
 use futures_util::{future, future::join_all, StreamExt};
-use lazy_static::lazy_static;
+use once_cell::sync::Lazy;
 use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
@@ -664,7 +664,7 @@ async fn update_timer_sequence() {
                 Ok("done")
             },
         );
-        ctx.timer(Duration::from_secs(1)).await;
+        ctx.timer(Duration::from_secs(2)).await;
         Ok(().into())
     });
 
@@ -817,9 +817,7 @@ async fn worker_restarted_in_middle_of_update() {
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
 
-    lazy_static! {
-        static ref BARR: Barrier = Barrier::new(2);
-    }
+    static BARR: Lazy<Barrier> = Lazy::new(|| Barrier::new(2));
     static ACT_RAN: AtomicBool = AtomicBool::new(false);
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         ctx.update_handler(

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

@@ -91,13 +91,13 @@ async fn client_list_open_closed_workflow_executions() {
 async fn client_create_namespace() {
     let client = Arc::new(
         get_integ_server_options()
-            .connect(NAMESPACE.to_owned(), None, None)
+            .connect(NAMESPACE.to_owned(), None)
             .await
             .expect("Must connect"),
     );
 
     let register_options = RegisterNamespaceOptions::builder()
-        .namespace("test-create-namespace")
+        .namespace(uuid::Uuid::new_v4().to_string())
         .description("it's alive")
         .build()
         .unwrap();
@@ -138,7 +138,7 @@ async fn client_create_namespace() {
 async fn client_describe_namespace() {
     let client = Arc::new(
         get_integ_server_options()
-            .connect(NAMESPACE.to_owned(), None, None)
+            .connect(NAMESPACE.to_owned(), None)
             .await
             .expect("Must connect"),
     );

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

@@ -40,7 +40,7 @@ use temporal_sdk_core_test_utils::{
 };
 use tokio::{join, sync::Semaphore, time::sleep};
 
-pub async fn one_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn one_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
     ctx.activity(ActivityOptions {
         activity_type: "echo_activity".to_string(),
         start_to_close_timeout: Some(Duration::from_secs(5)),

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

@@ -11,7 +11,7 @@ struct Data {
     message: String,
 }
 
-pub async fn appdata_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn appdata_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
     ctx.activity(ActivityOptions {
         activity_type: "echo_activity".to_string(),
         start_to_close_timeout: Some(Duration::from_secs(5)),

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

@@ -33,7 +33,7 @@ async fn cancel_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_cancel_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_cancel_to_other_wf");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf("sender", cancel_sender);
     worker.register_wf("receiver", cancel_receiver);

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

@@ -21,7 +21,7 @@ async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn cancel_during_timer() {
     let wf_name = "cancel_during_timer";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_string(), cancelled_wf);

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

@@ -37,7 +37,7 @@ async fn parent_wf(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn child_workflow_happy_path() {
     let mut starter = CoreWfStarter::new("child-workflows");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
 
     worker.register_wf(PARENT_WF_TYPE.to_string(), parent_wf);
@@ -58,7 +58,7 @@ async fn child_workflow_happy_path() {
 #[tokio::test]
 async fn abandoned_child_bug_repro() {
     let mut starter = CoreWfStarter::new("child-workflow-abandon-bug");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
 
@@ -129,7 +129,7 @@ async fn abandoned_child_bug_repro() {
 #[tokio::test]
 async fn abandoned_child_resolves_post_cancel() {
     let mut starter = CoreWfStarter::new("child-workflow-resolves-post-cancel");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
 

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

@@ -21,7 +21,7 @@ async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn continue_as_new_happy_path() {
     let wf_name = "continue_as_new_happy_path";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
@@ -42,9 +42,10 @@ async fn continue_as_new_multiple_concurrent() {
     let wf_name = "continue_as_new_multiple_concurrent";
     let mut starter = CoreWfStarter::new(wf_name);
     starter
-        .no_remote_activities()
-        .max_cached_workflows(5)
-        .max_wft(5);
+        .worker_config
+        .no_remote_activities(true)
+        .max_cached_workflows(5_usize)
+        .max_outstanding_workflow_tasks(5_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 

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

@@ -6,7 +6,8 @@ use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(1);
-pub async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<()> {
+
+pub(crate) async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<()> {
     let run_ct = RUN_CT.fetch_add(1, Ordering::Relaxed);
 
     match run_ct {
@@ -35,7 +36,7 @@ pub async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<()> {
 async fn test_determinism_error_then_recovers() {
     let wf_name = "test_determinism_error_then_recovers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
 
     worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);

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

@@ -1,9 +1,9 @@
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo};
+use temporal_client::WorkflowClientTrait;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
 
-pub async fn eager_wf(_context: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn eager_wf(_context: WfContext) -> WorkflowResult<()> {
     Ok(().into())
 }
 
@@ -14,7 +14,7 @@ async fn eager_wf_start() {
     starter.workflow_options.enable_eager_workflow_start = true;
     // hang the test if eager task dispatch failed
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), eager_wf);
     starter.eager_start_with_worker(wf_name, &mut worker).await;
@@ -28,12 +28,12 @@ async fn eager_wf_start_different_clients() {
     starter.workflow_options.enable_eager_workflow_start = true;
     // hang the test if wf task needs retry
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), eager_wf);
 
     let client = get_integ_server_options()
-        .connect(NAMESPACE.to_string(), None, None)
+        .connect(NAMESPACE.to_string(), None)
         .await
         .expect("Should connect");
     let w = starter.get_worker().await;
@@ -52,10 +52,6 @@ async fn eager_wf_start_different_clients() {
     assert!(res.eager_workflow_task.is_none());
 
     //wf task delivered through default path
-    worker.started_workflows.lock().push(WorkflowExecutionInfo {
-        namespace: NAMESPACE.to_string(),
-        workflow_id: wf_name.to_string(),
-        run_id: Some(res.run_id.clone()),
-    });
+    worker.expect_workflow_completion(wf_name, Some(res.run_id));
     worker.run_until_done().await.unwrap();
 }

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

@@ -26,7 +26,7 @@ use temporal_sdk_core_test_utils::{
 };
 use tokio_util::sync::CancellationToken;
 
-pub async fn one_local_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn one_local_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
     let initial_workflow_time = ctx.workflow_time().expect("Workflow time should be set");
     ctx.local_activity(LocalActivityOptions {
         activity_type: "echo_activity".to_string(),
@@ -51,7 +51,7 @@ async fn one_local_activity() {
     worker.run_until_done().await.unwrap();
 }
 
-pub async fn local_act_concurrent_with_timer_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn local_act_concurrent_with_timer_wf(ctx: WfContext) -> WorkflowResult<()> {
     let la = ctx.local_activity(LocalActivityOptions {
         activity_type: "echo_activity".to_string(),
         input: "hi!".as_json_payload().expect("serializes fine"),
@@ -74,7 +74,7 @@ async fn local_act_concurrent_with_timer() {
     worker.run_until_done().await.unwrap();
 }
 
-pub async fn local_act_then_timer_then_wait(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn local_act_then_timer_then_wait(ctx: WfContext) -> WorkflowResult<()> {
     let la = ctx.local_activity(LocalActivityOptions {
         activity_type: "echo_activity".to_string(),
         input: "hi!".as_json_payload().expect("serializes fine"),
@@ -114,7 +114,7 @@ async fn long_running_local_act_with_timer() {
     worker.run_until_done().await.unwrap();
 }
 
-pub async fn local_act_fanout_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn local_act_fanout_wf(ctx: WfContext) -> WorkflowResult<()> {
     let las: Vec<_> = (1..=50)
         .map(|i| {
             ctx.local_activity(LocalActivityOptions {
@@ -135,7 +135,9 @@ pub async fn local_act_fanout_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn local_act_fanout() {
     let wf_name = "local_act_fanout";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_local_at(1);
+    starter
+        .worker_config
+        .max_outstanding_local_activities(1_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_fanout_wf);
     worker.register_activity("echo_activity", echo);
@@ -424,7 +426,7 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
     );
     let mut starter = CoreWfStarter::new(&wf_name);
     if !cached {
-        starter.max_cached_workflows(0);
+        starter.worker_config.max_cached_workflows(0_usize);
     }
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
@@ -465,7 +467,7 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
 async fn eviction_wont_make_local_act_get_dropped(#[values(true, false)] short_wft_timeout: bool) {
     let wf_name = format!("eviction_wont_make_local_act_get_dropped_{short_wft_timeout}");
     let mut starter = CoreWfStarter::new(&wf_name);
-    starter.max_cached_workflows(0);
+    starter.worker_config.max_cached_workflows(0_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
     worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {

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

@@ -20,7 +20,7 @@ async fn sends_modify_wf_props() {
     let wf_name = "can_upsert_memo";
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
 
     worker.register_wf(wf_name, memo_upserter);

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

@@ -14,7 +14,7 @@ use temporal_sdk_core_test_utils::CoreWfStarter;
 
 const MY_PATCH_ID: &str = "integ_test_change_name";
 
-pub async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
     if ctx.patched(MY_PATCH_ID) {
         ctx.timer(Duration::from_millis(100)).await;
     } else {
@@ -33,7 +33,7 @@ pub async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn writes_change_markers() {
     let wf_name = "writes_change_markers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), changes_wf);
 
@@ -44,7 +44,8 @@ async fn writes_change_markers() {
 /// This one simulates a run as if the worker had the "old" code, then it fails at the end as
 /// a cheapo way of being re-run, at which point it runs with change checks and the "new" code.
 static DID_DIE: AtomicBool = AtomicBool::new(false);
-pub async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
+
+pub(crate) async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
     if DID_DIE.load(Ordering::Acquire) {
         assert!(!ctx.patched(MY_PATCH_ID));
     }
@@ -66,7 +67,7 @@ pub async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn can_add_change_markers() {
     let wf_name = "can_add_change_markers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), no_change_then_change_wf);
 
@@ -75,7 +76,8 @@ async fn can_add_change_markers() {
 }
 
 static DID_DIE_2: AtomicBool = AtomicBool::new(false);
-pub async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()> {
+
+pub(crate) async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()> {
     assert!(ctx.patched(MY_PATCH_ID));
     ctx.timer(Duration::from_millis(200)).await;
     if !DID_DIE_2.load(Ordering::Acquire) {
@@ -89,7 +91,7 @@ pub async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()>
 async fn replaying_with_patch_marker() {
     let wf_name = "replaying_with_patch_marker";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), replay_with_change_marker_wf);
 
@@ -105,7 +107,10 @@ async fn patched_on_second_workflow_task_is_deterministic() {
     let wf_name = "timer_patched_timer";
     let mut starter = CoreWfStarter::new(wf_name);
     // Disable caching to force replay from beginning
-    starter.max_cached_workflows(0).no_remote_activities();
+    starter
+        .worker_config
+        .max_cached_workflows(0_usize)
+        .no_remote_activities(true);
     let mut worker = starter.worker().await;
     // Include a task failure as well to make sure that works
     static FAIL_ONCE: AtomicBool = AtomicBool::new(true);
@@ -128,7 +133,7 @@ async fn patched_on_second_workflow_task_is_deterministic() {
 async fn can_remove_deprecated_patch_near_other_patch() {
     let wf_name = "can_add_change_markers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     let did_die = Arc::new(AtomicBool::new(false));
     worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
@@ -159,7 +164,7 @@ async fn can_remove_deprecated_patch_near_other_patch() {
 async fn deprecated_patch_removal() {
     let wf_name = "deprecated_patch_removal";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     let wf_id = starter.get_task_queue().to_string();

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

@@ -14,7 +14,7 @@ const POST_RESET_SIG: &str = "post-reset";
 async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());

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

@@ -1,9 +1,7 @@
 use std::collections::HashMap;
 
 use futures::StreamExt;
-use temporal_client::{
-    SignalWithStartOptions, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
-};
+use temporal_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
 };
@@ -34,7 +32,7 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
 async fn sends_signal_to_missing_wf() {
     let wf_name = "sends_signal_to_missing_wf";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), signal_sender);
 
@@ -73,7 +71,7 @@ async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf("sender", signal_sender);
     worker.register_wf("receiver", signal_receiver);
@@ -102,7 +100,7 @@ async fn sends_signal_to_other_wf() {
 #[tokio::test]
 async fn sends_signal_with_create_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf("receiver_signal", signal_with_create_wf_receiver);
 
@@ -123,12 +121,7 @@ async fn sends_signal_with_create_wf() {
         .await
         .expect("request succeeds.qed");
 
-    worker.started_workflows.lock().push(WorkflowExecutionInfo {
-        namespace: client.namespace().to_string(),
-        workflow_id: "sends_signal_with_create_wf".to_owned(),
-        run_id: Some(res.run_id.clone()),
-    });
-
+    worker.expect_workflow_completion("sends_signal_with_create_wf", Some(res.run_id));
     worker.run_until_done().await.unwrap();
 }
 
@@ -153,7 +146,7 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_child() {
     let mut starter = CoreWfStarter::new("sends_signal_to_child");
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);

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

@@ -12,8 +12,10 @@ use tokio::sync::Barrier;
 async fn timer_workflow_not_sticky() {
     let wf_name = "timer_wf_not_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
-    starter.max_cached_workflows(0);
+    starter
+        .worker_config
+        .no_remote_activities(true)
+        .max_cached_workflows(0_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
@@ -40,7 +42,7 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     starter.workflow_options.task_timeout = Some(Duration::from_secs(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
@@ -56,9 +58,10 @@ async fn cache_miss_ok() {
     let wf_name = "cache_miss_ok";
     let mut starter = CoreWfStarter::new(wf_name);
     starter
-        .no_remote_activities()
-        .max_wft(2)
-        .max_cached_workflows(0);
+        .worker_config
+        .no_remote_activities(true)
+        .max_outstanding_workflow_tasks(2_usize)
+        .max_cached_workflows(0_usize);
     starter.worker_config.max_concurrent_wft_polls(1_usize);
     let mut worker = starter.worker().await;
 

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

@@ -10,7 +10,7 @@ use temporal_sdk_core_test_utils::{
     WorkerTestHelpers,
 };
 
-pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
     command_sink.timer(Duration::from_secs(1)).await;
     Ok(().into())
 }
@@ -19,7 +19,7 @@ pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
@@ -31,7 +31,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -52,7 +52,7 @@ async fn timer_workflow_manual() {
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -111,7 +111,7 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);