temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/tests/integ_tests/queries_tests.rs

@@ -10,7 +10,9 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
 };
-use temporal_sdk_core_test_utils::{init_core_and_create_wf, CoreWfStarter, WorkerTestHelpers};
+use temporal_sdk_core_test_utils::{
+    drain_pollers_and_shutdown, init_core_and_create_wf, WorkerTestHelpers,
+};
 
 #[tokio::test]
 async fn simple_query_legacy() {
@@ -112,7 +114,7 @@ async fn simple_query_legacy() {
 async fn query_after_execution_complete(#[case] do_evict: bool) {
     let query_resp = b"response";
     let mut starter =
-        init_core_and_create_wf(&format!("query_after_execution_complete-{}", do_evict)).await;
+        init_core_and_create_wf(&format!("query_after_execution_complete-{do_evict}")).await;
     let core = &starter.get_worker().await;
     let workflow_id = &starter.get_task_queue().to_string();
 
@@ -205,132 +207,7 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
         query_futs.push(do_workflow(true).map(|_| ()).boxed());
     }
     while query_futs.next().await.is_some() {}
-    core.shutdown().await;
-}
-
-#[ignore]
-#[tokio::test]
-async fn repros_query_dropped_on_floor() {
-    // This test reliably repros the server dropping one of the two simultaneously issued queries.
-    let q1_resp = b"query_1_resp";
-    let q2_resp = b"query_2_resp";
-    let mut wf_starter = CoreWfStarter::new("repros_query_dropped_on_floor");
-    // Easiest way I discovered to reliably trigger new query path is with a WFT timeout
-    wf_starter.wft_timeout(Duration::from_secs(1));
-    let core = wf_starter.get_worker().await;
-    let task_q = wf_starter.get_task_queue().to_string();
-    wf_starter.start_wf().await;
-    let client = wf_starter.get_client().await;
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
-        .await;
-
-    // Poll for a task we will time out
-    let task = core.poll_workflow_activation().await.unwrap();
-    tokio::time::sleep(Duration::from_secs(2)).await;
-    // Complete now-timed-out task (add a new timer)
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id.clone(),
-        vec![],
-    ))
-    .await
-    .unwrap();
-
-    let run_id = task.run_id.to_string();
-    let q1_fut = async {
-        client
-            .query_workflow_execution(
-                task_q.clone(),
-                run_id,
-                WorkflowQuery {
-                    query_type: "query_1".to_string(),
-                    query_args: Some(b"hi 1".into()),
-                    header: None,
-                },
-            )
-            .await
-            .unwrap()
-    };
-    let run_id = task.run_id.to_string();
-    let q2_fut = async {
-        client
-            .query_workflow_execution(
-                task_q.clone(),
-                run_id,
-                WorkflowQuery {
-                    query_type: "query_2".to_string(),
-                    query_args: Some(b"hi 2".into()),
-                    header: None,
-                },
-            )
-            .await
-            .unwrap()
-    };
-    let workflow_completions_future = async {
-        let mut seen_q1 = false;
-        let mut seen_q2 = false;
-        while !seen_q1 || !seen_q2 {
-            let task = core.poll_workflow_activation().await.unwrap();
-
-            if matches!(
-                task.jobs[0],
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-                }
-            ) {
-                let task = core.poll_workflow_activation().await.unwrap();
-                core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
-                    .await;
-                continue;
-            }
-
-            if matches!(
-                task.jobs[0],
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-                }
-            ) {
-                // If we get the timer firing after replay, be done.
-                core.complete_execution(&task.run_id).await;
-            }
-
-            // There should be a query job (really, there should be both... server only sends one?)
-            let query = assert_matches!(
-                task.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-                }] => q
-            );
-            let resp = if query.query_type == "query_1" {
-                seen_q1 = true;
-                q1_resp
-            } else {
-                seen_q2 = true;
-                q2_resp
-            };
-            // Complete the query
-            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-                task.run_id,
-                vec![QueryResult {
-                    query_id: query.query_id.clone(),
-                    variant: Some(
-                        QuerySuccess {
-                            response: Some(resp.into()),
-                        }
-                        .into(),
-                    ),
-                }
-                .into()],
-            ))
-            .await
-            .unwrap();
-        }
-    };
-    let (q1_res, q2_res, _) = tokio::join!(q1_fut, q2_fut, workflow_completions_future);
-    // Ensure query responses are as expected
-    assert_eq!(&q1_res.unwrap()[0].data, q1_resp);
-    assert_eq!(&q2_res.unwrap()[0].data, q2_resp);
+    drain_pollers_and_shutdown(core).await;
 }
 
 #[tokio::test]

data/bridge/sdk-core/tests/integ_tests/visibility_tests.rs

@@ -1,15 +1,17 @@
 use assert_matches::assert_matches;
 use std::{sync::Arc, time::Duration};
 use temporal_client::{
-    ListClosedFilters, ListOpenFilters, Namespace, StartTimeFilter, WorkflowClientTrait,
-    WorkflowExecutionFilter, WorkflowOptions,
+    ListClosedFilters, ListOpenFilters, Namespace, RegisterNamespaceOptions, StartTimeFilter,
+    WorkflowClientTrait, WorkflowExecutionFilter,
 };
 use temporal_sdk_core_protos::coresdk::workflow_activation::{
     workflow_activation_job, WorkflowActivationJob,
 };
 use temporal_sdk_core_test_utils::{
-    get_integ_server_options, CoreWfStarter, WorkerTestHelpers, NAMESPACE,
+    drain_pollers_and_shutdown, get_integ_server_options, CoreWfStarter, WorkerTestHelpers,
+    NAMESPACE,
 };
+use tokio::time::sleep;
 
 #[tokio::test]
 async fn client_list_open_closed_workflow_executions() {
@@ -22,9 +24,7 @@ async fn client_list_open_closed_workflow_executions() {
     let latest = earliest + Duration::from_secs(60);
 
     // start workflow
-    let run_id = starter
-        .start_wf_with_id(wf_name.to_owned(), WorkflowOptions::default())
-        .await;
+    let run_id = starter.start_wf_with_id(wf_name.to_owned()).await;
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
@@ -52,28 +52,86 @@ async fn client_list_open_closed_workflow_executions() {
 
     // Complete workflow
     core.complete_execution(&task.run_id).await;
+    drain_pollers_and_shutdown(&core).await;
 
-    // List above CLOSED workflow
-    let start_time_filter = StartTimeFilter {
-        earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-        latest_time: Some(latest).and_then(|t| t.try_into().ok()),
-    };
-    let filter = ListClosedFilters::ExecutionFilter(WorkflowExecutionFilter {
-        workflow_id: wf_name.clone(),
-        run_id,
-    });
-    let closed_workflows = client
-        .list_closed_workflow_executions(
-            1,
-            Default::default(),
-            Some(start_time_filter),
-            Some(filter),
-        )
+    // List above CLOSED workflow. Visibility doesn't always update immediately so we give this a
+    // few tries.
+    let mut passed = false;
+    for _ in 1..=5 {
+        let closed_workflows = client
+            .list_closed_workflow_executions(
+                1,
+                Default::default(),
+                Some(StartTimeFilter {
+                    earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
+                    latest_time: Some(latest).and_then(|t| t.try_into().ok()),
+                }),
+                Some(ListClosedFilters::ExecutionFilter(
+                    WorkflowExecutionFilter {
+                        workflow_id: wf_name.clone(),
+                        run_id: run_id.clone(),
+                    },
+                )),
+            )
+            .await
+            .unwrap();
+        if closed_workflows.executions.len() == 1 {
+            let workflow = &closed_workflows.executions[0];
+            if workflow.execution.as_ref().unwrap().workflow_id == wf_name {
+                passed = true;
+                break;
+            }
+        }
+        sleep(Duration::from_millis(100)).await;
+    }
+    assert!(passed);
+}
+
+#[tokio::test]
+async fn client_create_namespace() {
+    let client = Arc::new(
+        get_integ_server_options()
+            .connect(NAMESPACE.to_owned(), None, None)
+            .await
+            .expect("Must connect"),
+    );
+
+    let register_options = RegisterNamespaceOptions::builder()
+        .namespace("test-create-namespace")
+        .description("it's alive")
+        .build()
+        .unwrap();
+
+    client
+        .register_namespace(register_options.clone())
         .await
         .unwrap();
-    assert_eq!(closed_workflows.executions.len(), 1);
-    let workflow = closed_workflows.executions[0].clone();
-    assert_eq!(workflow.execution.as_ref().unwrap().workflow_id, wf_name);
+
+    //#Hack, not sure how else to wait for a proper response.  RegisterNamespace isn't safe to read
+    //after write
+    let mut attempts = 0;
+    let wait_time = Duration::from_secs(1);
+    loop {
+        attempts += 1;
+        let resp = client
+            .describe_namespace(Namespace::Name(register_options.namespace.clone()))
+            .await;
+
+        match resp {
+            Ok(n) => {
+                let namespace_info = n.namespace_info.unwrap();
+                assert_eq!(namespace_info.name, register_options.namespace);
+                assert_eq!(namespace_info.description, register_options.description);
+                return;
+            }
+            _ => {
+                if attempts == 12 {
+                    panic!("failed to query registered namespace");
+                }
+                sleep(wait_time).await
+            }
+        }
+    }
 }
 
 #[tokio::test]

data/bridge/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -1,3 +1,4 @@
+use anyhow::anyhow;
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
@@ -23,10 +24,11 @@ use temporal_sdk_core_protos::{
         enums::v1::RetryState,
         failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure},
     },
-    TaskToken,
+    TaskToken, DEFAULT_ACTIVITY_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 use tokio::time::sleep;
 
@@ -97,7 +99,7 @@ async fn activity_workflow() {
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string())
         }
     );
     let response_payload = Payload {
@@ -154,16 +156,78 @@ async fn activity_non_retryable_failure() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
+    // Fail activity with non-retryable error
+    let failure = Failure::application_failure("activity failed".to_string(), true);
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: task.task_token,
+        result: Some(ActivityExecutionResult::fail(failure.clone())),
+    })
+    .await
+    .unwrap();
+    // Poll workflow task and verify that activity has failed.
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+        task.jobs.as_slice(),
+        [
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution{
+                    status: Some(act_res::Status::Failed(activity_result::Failure{
+                        failure: Some(f),
+                    }))})}
+                )),
+            },
+        ] => {
+            assert_eq!(*seq, 0);
+            assert_eq!(f, &Failure{
+                message: "Activity task failed".to_owned(),
+                cause: Some(Box::new(failure)),
+                failure_info: Some(FailureInfo::ActivityFailureInfo(ActivityFailureInfo{
+                    activity_id: "act-1".to_owned(),
+                    activity_type: Some(ActivityType {
+                        name: DEFAULT_ACTIVITY_TYPE.to_owned(),
+                    }),
+                    scheduled_event_id: 5,
+                    started_event_id: 6,
+                    identity: "integ_tester".to_owned(),
+                    retry_state: RetryState::NonRetryableFailure as i32,
+                })),
+                ..Default::default()
+            });
         }
     );
+    core.complete_execution(&task.run_id).await;
+}
+
+#[tokio::test]
+async fn activity_non_retryable_failure_with_error() {
+    let mut starter = init_core_and_create_wf("activity_non_retryable_failure").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation().await.unwrap();
+    // Complete workflow task and schedule activity
+    core.complete_workflow_activation(
+        schedule_activity_cmd(
+            0,
+            task_q,
+            activity_id,
+            ActivityCancellationType::TryCancel,
+            Duration::from_secs(60),
+            Duration::from_secs(60),
+        )
+        .into_completion(task.run_id),
+    )
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled
+    let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Fail activity with non-retryable error
-    let failure = Failure::application_failure("activity failed".to_string(), true);
+    let failure = Failure::application_failure_from_error(anyhow!("activity failed"), true);
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         result: Some(ActivityExecutionResult::fail(failure.clone())),
@@ -191,7 +255,7 @@ async fn activity_non_retryable_failure() {
                 failure_info: Some(FailureInfo::ActivityFailureInfo(ActivityFailureInfo{
                     activity_id: "act-1".to_owned(),
                     activity_type: Some(ActivityType {
-                        name: "test_activity".to_owned(),
+                        name: DEFAULT_ACTIVITY_TYPE.to_owned(),
                     }),
                     scheduled_event_id: 5,
                     started_event_id: 6,
@@ -228,12 +292,7 @@ async fn activity_retry() {
     .unwrap();
     // Poll activity 1st time
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Fail activity with retryable error
     let failure = Failure::application_failure("activity failed".to_string(), false);
     core.complete_activity_task(ActivityTaskCompletion {
@@ -244,12 +303,7 @@ async fn activity_retry() {
     .unwrap();
     // Poll 2nd time
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Complete activity successfully
     let response_payload = Payload {
         data: b"hello ".to_vec(),
@@ -308,15 +362,10 @@ async fn activity_cancellation_try_cancel() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
-    // complete it in this test as activity is try-cancelled.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is try-cancelled.
     let activity_task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        activity_task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -453,15 +502,10 @@ async fn started_activity_timeout() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
-    // complete it in this test as activity is timed out after 1 second.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is timed out after 1 second.
     let activity_task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        activity_task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
@@ -517,15 +561,10 @@ async fn activity_cancellation_wait_cancellation_completed() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
-    // complete it in this test as activity is wait-cancelled.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is wait-cancelled.
     let activity_task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        activity_task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -584,15 +623,10 @@ async fn activity_cancellation_abandon() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
-    // complete it in this test as activity is abandoned.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is abandoned.
     let activity_task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        activity_task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -640,14 +674,9 @@ async fn async_activity_completion_workflow() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     let response_payload = Payload {
         data: b"hello ".to_vec(),
         metadata: Default::default(),
@@ -712,14 +741,9 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Delay the heartbeat
     sleep(Duration::from_secs(2)).await;
     core.record_activity_heartbeat(ActivityHeartbeat {
@@ -741,7 +765,7 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     .unwrap();
 
     // Verify shutdown completes
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
     // Cleanup just in case
     starter
         .get_client()
@@ -822,7 +846,7 @@ async fn it_can_complete_async() {
             Some(act_res::Status::Completed(activity_result::Success { result })) => result
                 .map(|p| String::from_json_payload(&p).unwrap())
                 .unwrap(),
-            _ => panic!("activity task failed {:?}", activity_resolution),
+            _ => panic!("activity task failed {activity_resolution:?}"),
         };
 
         assert_eq!(&res, async_response);

data/bridge/sdk-core/tests/integ_tests/workflow_tests/cancel_external.rs

@@ -33,6 +33,7 @@ async fn cancel_receiver(mut 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();
     let mut worker = starter.worker().await;
     worker.register_wf("sender", cancel_sender);
     worker.register_wf("receiver", cancel_receiver);

data/bridge/sdk-core/tests/integ_tests/workflow_tests/cancel_wf.rs

@@ -1,5 +1,5 @@
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_client::WorkflowClientTrait;
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -21,25 +21,18 @@ async fn cancelled_wf(mut 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();
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_string(), cancelled_wf);
-
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
+    let wf_id = starter.get_task_queue().to_string();
 
     let canceller = async {
         tokio::time::sleep(Duration::from_millis(500)).await;
         // Cancel the workflow externally
         client
-            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string(), None)
+            .cancel_workflow_execution(wf_id.clone(), None, "Dieee".to_string(), None)
             .await
             .unwrap();
     };
@@ -47,7 +40,7 @@ async fn cancel_during_timer() {
     let (_, res) = tokio::join!(canceller, worker.run_until_done());
     res.unwrap();
     let desc = client
-        .describe_workflow_execution(wf_name.to_string(), None)
+        .describe_workflow_execution(wf_id, None)
         .await
         .unwrap();
 

data/bridge/sdk-core/tests/integ_tests/workflow_tests/child_workflows.rs

@@ -32,6 +32,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();
     let mut worker = starter.worker().await;
 
     worker.register_wf(PARENT_WF_TYPE.to_string(), parent_wf);

data/bridge/sdk-core/tests/integ_tests/workflow_tests/continue_as_new.rs

@@ -21,6 +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();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
@@ -40,11 +41,14 @@ async fn continue_as_new_happy_path() {
 async fn continue_as_new_multiple_concurrent() {
     let wf_name = "continue_as_new_multiple_concurrent";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_cached_workflows(3).max_wft(3);
+    starter
+        .no_remote_activities()
+        .max_cached_workflows(3)
+        .max_wft(3);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
-    let wf_names = (1..=20).map(|i| format!("{}-{}", wf_name, i));
+    let wf_names = (1..=20).map(|i| format!("{wf_name}-{i}"));
     for name in wf_names.clone() {
         worker
             .submit_wf(

data/bridge/sdk-core/tests/integ_tests/workflow_tests/determinism.rs

@@ -2,7 +2,7 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
+
 use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
@@ -36,18 +36,11 @@ 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();
     let mut worker = starter.worker().await;
 
     worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
     // 4 because we still add on the 3rd and final attempt
     assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);