@temporalio/core-bridge 0.17.2 → 0.18.0

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

@@ -1,12 +1,12 @@
 use futures::StreamExt;
-use temporal_sdk_core::prototype_rust_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
-use test_utils::CoreWfStarter;
+use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
 const SIGNAME: &str = "signame";
 const RECEIVER_WFID: &str = "sends-signal-signal-receiver";
 
-async fn signal_sender(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
     let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
         .unwrap()
         .to_owned();
@@ -38,10 +38,9 @@ async fn sends_signal_to_missing_wf() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }
 
-async fn signal_receiver(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
     ctx.make_signal_channel(SIGNAME).next().await.unwrap();
     Ok(().into())
 }
@@ -66,24 +65,20 @@ async fn sends_signal_to_other_wf() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }
 
-async fn signals_child(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
     let started_child = ctx
         .child_workflow(ChildWorkflowOptions {
             workflow_id: "my_precious_child".to_string(),
             workflow_type: "child_receiver".to_string(),
             ..Default::default()
         })
-        .start(&mut ctx)
+        .start(&ctx)
         .await
         .into_started()
         .expect("Must start ok");
-    started_child
-        .signal(&mut ctx, SIGNAME, b"hiya!")
-        .await
-        .unwrap();
+    started_child.signal(&ctx, SIGNAME, b"hiya!").await.unwrap();
     started_child.result().await.status.unwrap();
     Ok(().into())
 }
@@ -101,5 +96,4 @@ async fn sends_signal_to_child() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }

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

@@ -3,8 +3,9 @@ use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WorkflowResult};
-use test_utils::CoreWfStarter;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use tokio::sync::Barrier;
 
 #[tokio::test]
 async fn timer_workflow_not_sticky() {
@@ -19,12 +20,11 @@ async fn timer_workflow_not_sticky() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }
 
 static TIMED_OUT_ONCE: AtomicBool = AtomicBool::new(false);
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
-async fn timer_timeout_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn timer_timeout_wf(ctx: WfContext) -> WorkflowResult<()> {
     RUN_CT.fetch_add(1, Ordering::SeqCst);
     let t = ctx.timer(Duration::from_secs(1));
     if !TIMED_OUT_ONCE.load(Ordering::SeqCst) {
@@ -50,7 +50,35 @@ async fn timer_workflow_timeout_on_sticky() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
     // If it didn't run twice it didn't time out
     assert_eq!(RUN_CT.load(Ordering::SeqCst), 2);
 }
+
+#[tokio::test]
+async fn cache_miss_ok() {
+    let wf_name = "cache_miss_ok";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_wft(1);
+    let mut worker = starter.worker().await;
+
+    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        barr.wait().await;
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+
+    let run_id = worker
+        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .await
+        .unwrap();
+    let core = starter.get_core().await;
+    let tq = starter.get_task_queue();
+    let (r1, _) = tokio::join!(worker.run_until_done(), async move {
+        barr.wait().await;
+        core.request_workflow_eviction(tq, &run_id);
+        // We need to signal the barrier again since the wf gets evicted and will hit it again
+        barr.wait().await;
+    });
+    r1.unwrap();
+}

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

@@ -1,12 +1,14 @@
 use std::time::Duration;
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WorkflowResult};
+use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
-    workflow_completion::WfActivationCompletion,
+    workflow_completion::WorkflowActivationCompletion,
+};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, start_timer_cmd, CoreTestHelpers, CoreWfStarter,
 };
-use test_utils::{init_core_and_create_wf, CoreTestHelpers, CoreWfStarter};
 
-pub async fn timer_wf(mut command_sink: WfContext) -> WorkflowResult<()> {
+pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
     command_sink.timer(Duration::from_secs(1)).await;
     Ok(().into())
 }
@@ -23,14 +25,13 @@ async fn timer_workflow_workflow_driver() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }
 
 #[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();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![StartTimer {
@@ -50,7 +51,7 @@ async fn timer_workflow_manual() {
 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();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![
@@ -69,7 +70,7 @@ async fn timer_cancel_workflow() {
     .await
     .unwrap();
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![
@@ -85,15 +86,11 @@ async fn timer_cancel_workflow() {
 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();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![
-            StartTimer {
-                seq: 0,
-                ..Default::default()
-            }
-            .into(),
+            start_timer_cmd(0, Duration::from_secs(1)),
             CancelTimer { seq: 0 }.into(),
             CompleteWorkflowExecution { result: None }.into(),
         ],
@@ -102,7 +99,7 @@ async fn timer_immediate_cancel_workflow() {
     .unwrap();
 }
 
-async fn parallel_timer_wf(mut command_sink: WfContext) -> WorkflowResult<()> {
+async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
     let t1 = command_sink.timer(Duration::from_secs(1));
     let t2 = command_sink.timer(Duration::from_secs(1));
     let _ = tokio::join!(t1, t2);
@@ -121,5 +118,4 @@ async fn parallel_timers() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }

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

@@ -4,7 +4,9 @@ mod cancel_wf;
 mod child_workflows;
 mod continue_as_new;
 mod determinism;
+mod local_activities;
 mod patches;
+mod replay;
 mod signals;
 mod stickyness;
 mod timers;
@@ -19,23 +21,21 @@ use std::{
     },
     time::Duration,
 };
-use temporal_sdk_core::{
-    errors::PollWfError,
-    prototype_rust_sdk::{WfContext, WorkflowResult},
-    Core,
-};
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_api::{errors::PollWfError, Core};
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::ActivityResult,
-        workflow_activation::{wf_activation_job, WfActivation, WfActivationJob},
+        activity_result::ActivityExecutionResult,
+        workflow_activation::{workflow_activation_job, WorkflowActivation, WorkflowActivationJob},
         workflow_commands::{ActivityCancellationType, FailWorkflowExecution, StartTimer},
-        workflow_completion::WfActivationCompletion,
+        workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, IntoCompletion,
     },
     temporal::api::failure::v1::Failure,
 };
-use test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, with_gw, CoreTestHelpers, CoreWfStarter, GwApi,
+use temporal_sdk_core_test_utils::{
+    history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
+    schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -59,13 +59,13 @@ async fn parallel_workflows_same_queue() {
     async fn wf_task(
         core: Arc<dyn Core>,
         task_q: String,
-        mut task_chan: UnboundedReceiver<WfActivation>,
+        mut task_chan: UnboundedReceiver<WorkflowActivation>,
     ) {
         let task = task_chan.next().await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::StartWorkflow(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
             }]
         );
         core.complete_timer(&task_q, &task.run_id, 1, Duration::from_secs(1))
@@ -99,7 +99,7 @@ async fn parallel_workflows_same_queue() {
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
-pub async fn cache_evictions_wf(mut command_sink: WfContext) -> WorkflowResult<()> {
+pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
     RUN_CT.fetch_add(1, Ordering::SeqCst);
     command_sink.timer(Duration::from_secs(1)).await;
     Ok(().into())
@@ -125,7 +125,6 @@ async fn workflow_lru_cache_evictions() {
             .unwrap();
     }
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
     // The wf must have started more than # workflows times, since all but one must experience
     // an eviction
     assert!(RUN_CT.load(Ordering::SeqCst) > n_workflows);
@@ -158,9 +157,19 @@ async fn shutdown_aborts_actively_blocked_poll() {
     );
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn fail_wf_task() {
-    let (core, task_q) = init_core_and_create_wf("fail_wf_task").await;
+async fn fail_wf_task(#[values(true, false)] replay: bool) {
+    let (core, task_q) = if replay {
+        init_core_replay_preloaded(
+            "fail_wf_task",
+            &history_from_proto_binary("histories/fail_wf_task.bin")
+                .await
+                .unwrap(),
+        )
+    } else {
+        init_core_and_create_wf("fail_wf_task").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))
@@ -168,7 +177,7 @@ async fn fail_wf_task() {
 
     // Then break for whatever reason
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::fail(
+    core.complete_workflow_activation(WorkflowActivationCompletion::fail(
         &task_q,
         task.run_id,
         Failure::application_failure("I did an oopsie".to_string(), false),
@@ -182,16 +191,16 @@ async fn fail_wf_task() {
     // The first poll response will tell us to evict
     assert_matches!(
         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(&task_q, task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(&task_q, task.run_id))
         .await
         .unwrap();
 
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![StartTimer {
@@ -213,7 +222,7 @@ async fn fail_workflow_execution() {
     core.complete_timer(&task_q, &task.run_id, 0, Duration::from_secs(1))
         .await;
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![FailWorkflowExecution {
@@ -227,14 +236,14 @@ async fn fail_workflow_execution() {
 
 #[tokio::test]
 async fn signal_workflow() {
-    let workflow_id = "signal_workflow";
-    let (core, task_q) = init_core_and_create_wf(workflow_id).await;
+    let (core, task_q) = init_core_and_create_wf("signal_workflow").await;
+    let workflow_id = task_q.clone();
 
     let signal_id_1 = "signal1";
     let signal_id_2 = "signal2";
     let res = core.poll_workflow_activation(&task_q).await.unwrap();
     // Task is completed with no commands
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         res.run_id.clone(),
         vec![],
@@ -243,8 +252,8 @@ async fn signal_workflow() {
     .unwrap();
 
     // Send the signals to the server
-    with_gw(core.as_ref(), |gw: GwApi| async move {
-        gw.signal_workflow_execution(
+    core.server_gateway()
+        .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
             signal_id_1.to_string(),
@@ -252,7 +261,8 @@ async fn signal_workflow() {
         )
         .await
         .unwrap();
-        gw.signal_workflow_execution(
+    core.server_gateway()
+        .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
             signal_id_2.to_string(),
@@ -260,8 +270,6 @@ async fn signal_workflow() {
         )
         .await
         .unwrap();
-    })
-    .await;
 
     let mut res = core.poll_workflow_activation(&task_q).await.unwrap();
     // Sometimes both signals are complete at once, sometimes only one, depending on server
@@ -270,22 +278,22 @@ async fn signal_workflow() {
         assert_matches!(
             res.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::SignalWorkflow(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
                 }
             ]
         );
     } else if res.jobs.len() == 1 {
         assert_matches!(
             res.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::SignalWorkflow(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
             },]
         );
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             &task_q,
             res.run_id,
             vec![],
@@ -295,8 +303,8 @@ async fn signal_workflow() {
         res = core.poll_workflow_activation(&task_q).await.unwrap();
         assert_matches!(
             res.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::SignalWorkflow(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
             },]
         );
     }
@@ -305,13 +313,14 @@ async fn signal_workflow() {
 
 #[tokio::test]
 async fn signal_workflow_signal_not_handled_on_workflow_completion() {
-    let workflow_id = "signal_workflow_signal_not_handled_on_workflow_completion";
-    let (core, task_q) = init_core_and_create_wf(workflow_id).await;
+    let (core, task_q) =
+        init_core_and_create_wf("signal_workflow_signal_not_handled_on_workflow_completion").await;
+    let workflow_id = task_q.as_str();
     let signal_id_1 = "signal1";
     for i in 1..=2 {
         let res = core.poll_workflow_activation(&task_q).await.unwrap();
         // Task is completed with a timer
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             &task_q,
             res.run_id,
             vec![StartTimer {
@@ -329,16 +338,16 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             // First attempt we should only see the timer being fired
             assert_matches!(
                 res.jobs.as_slice(),
-                [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::FireTimer(_)),
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
                 }]
             );
 
             let run_id = res.run_id.clone();
 
-            // Send the signals to the server
-            with_gw(core.as_ref(), |gw: GwApi| async move {
-                gw.signal_workflow_execution(
+            // Send the signal to the server
+            core.server_gateway()
+                .signal_workflow_execution(
                     workflow_id.to_string(),
                     res.run_id.to_string(),
                     signal_id_1.to_string(),
@@ -346,8 +355,6 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
                 )
                 .await
                 .unwrap();
-            })
-            .await;
 
             // 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)
@@ -357,11 +364,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             let res = core.poll_workflow_activation(&task_q).await.unwrap();
             assert_matches!(
                 res.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(
+            core.complete_workflow_activation(WorkflowActivationCompletion::empty(
                 task_q.clone(),
                 res.run_id,
             ))
@@ -375,11 +382,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
         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::SignalWorkflow(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
                 }
             ]
         );
@@ -425,14 +432,14 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         assert_matches!(
             wf_task.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(_)),
                 },
-                WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::SignalWorkflow(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
                 }
             ]
         );
@@ -449,36 +456,32 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     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;
-    with_gw(core.as_ref(), |gw: GwApi| async move {
-        gw.signal_workflow_execution(wf_id.to_string(), rid, signal_at_start.to_string(), None)
-            .await
-            .unwrap();
-    })
-    .await;
+    core.server_gateway()
+        .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(ActivityResult::ok(Default::default())),
+        result: Some(ActivityExecutionResult::ok(Default::default())),
     })
     .await
     .unwrap();
     let rid = wf_task.run_id.clone();
-    with_gw(core.as_ref(), |gw: GwApi| async move {
-        gw.signal_workflow_execution(wf_id.to_string(), rid, signal_at_complete.to_string(), None)
-            .await
-            .unwrap();
-    })
-    .await;
+    core.server_gateway()
+        .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();
     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(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
         .await
         .unwrap();
     // Start from the beginning
@@ -497,11 +500,11 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     );
     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(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
         .await
         .unwrap();
     // Do it all over again, without timing out this time

package/sdk-core/tests/load_tests.rs

@@ -1,12 +1,12 @@
 use assert_matches::assert_matches;
 use futures::future::join_all;
 use std::time::{Duration, Instant};
-use temporal_sdk_core::prototype_rust_sdk::{ActivityOptions, WfContext};
+use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_protos::coresdk::{
-    activity_result::ActivityResult, activity_task::activity_task as act_task,
+    activity_result::ActivityExecutionResult, activity_task::activity_task as act_task,
     workflow_commands::ActivityCancellationType, ActivityTaskCompletion,
 };
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 const CONCURRENCY: usize = 1000;
 
@@ -27,7 +27,7 @@ async fn activity_load() {
     let task_queue = starter.get_task_queue().to_owned();
 
     let pd = payload_dat.clone();
-    let wf_fn = move |mut ctx: WfContext| {
+    let wf_fn = move |ctx: WfContext| {
         let task_queue = task_queue.clone();
         let payload_dat = pd.clone();
 
@@ -35,6 +35,7 @@ async fn activity_load() {
             let activity = ActivityOptions {
                 activity_id: Some(activity_id.to_string()),
                 activity_type: "test_activity".to_string(),
+                input: Default::default(),
                 task_queue,
                 schedule_to_start_timeout: Some(activity_timeout),
                 start_to_close_timeout: Some(activity_timeout),
@@ -86,7 +87,7 @@ async fn activity_load() {
                 core.complete_activity_task(ActivityTaskCompletion {
                     task_token: task.task_token,
                     task_queue: task_q,
-                    result: Some(ActivityResult::ok(pd.into())),
+                    result: Some(ActivityExecutionResult::ok(pd.into())),
                 })
                 .await
                 .unwrap()
@@ -104,5 +105,4 @@ async fn activity_load() {
         all_acts
     };
     dbg!(running.elapsed());
-    core.shutdown().await;
 }

package/sdk-core/tests/main.rs

@@ -6,7 +6,7 @@ mod integ_tests {
     use temporal_sdk_core::{
         ClientTlsConfig, ServerGatewayApis, ServerGatewayOptionsBuilder, TlsConfig,
     };
-    use test_utils::NAMESPACE;
+    use temporal_sdk_core_test_utils::NAMESPACE;
     use url::Url;
 
     mod client_tests;
@@ -51,7 +51,7 @@ mod integ_tests {
             })
             .build()
             .unwrap();
-        let con = sgo.connect().await.unwrap();
+        let con = sgo.connect(None).await.unwrap();
         con.list_namespaces().await.unwrap();
     }
 }