@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/core/src/core_tests/child_workflows.rs

@@ -1,18 +1,18 @@
 use crate::{
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{
-        build_mock_pollers, canned_histories, mock_core, MockPollCfg, ResponseType, TEST_Q,
+        build_mock_pollers, canned_histories, mock_worker, MockPollCfg, ResponseType, TEST_Q,
     },
+    worker::client::mocks::mock_workflow_client,
     workflow::managed_wf::ManagedWFFunc,
 };
 use std::sync::Arc;
-use temporal_client::mocks::mock_gateway;
-use temporal_sdk::{
-    ChildWorkflowOptions, TestRustWorker, WfContext, WorkflowFunction, WorkflowResult,
-};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{ChildWorkflowOptions, Signal, WfContext, WorkflowFunction, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::child_workflow::{
     child_workflow_result, ChildWorkflowCancellationType,
 };
+use temporal_sdk_core_test_utils::TestWorker;
 use tokio::join;
 
 const SIGNAME: &str = "SIGNAME";
@@ -25,11 +25,11 @@ async fn signal_child_workflow(#[case] serial: bool) {
     let wf_id = "fakeid";
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let t = canned_histories::single_child_workflow_signaled("child-id-1", SIGNAME);
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
     let mock = build_mock_pollers(mh);
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     let wf = move |ctx: WfContext| async move {
         let child = ctx.child_workflow(ChildWorkflowOptions {
@@ -44,11 +44,11 @@ async fn signal_child_workflow(#[case] serial: bool) {
             .into_started()
             .expect("Child should get started");
         let (sigres, res) = if serial {
-            let sigres = start_res.signal(&ctx, SIGNAME, b"Hi!").await;
+            let sigres = start_res.signal(&ctx, Signal::new(SIGNAME, [b"Hi!"])).await;
             let res = start_res.result().await;
             (sigres, res)
         } else {
-            let sigfut = start_res.signal(&ctx, SIGNAME, b"Hi!");
+            let sigfut = start_res.signal(&ctx, Signal::new(SIGNAME, [b"Hi!"]));
             let resfut = start_res.result();
             join!(sigfut, resfut)
         };
@@ -59,7 +59,12 @@ async fn signal_child_workflow(#[case] serial: bool) {
 
     worker.register_wf(wf_type.to_owned(), wf);
     worker
-        .submit_wf(wf_id.to_owned(), wf_type.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/core/src/core_tests/determinism.rs

@@ -1,8 +1,9 @@
 use crate::{
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{
-        build_mock_pollers, canned_histories, mock_core, MockPollCfg, ResponseType, TEST_Q,
+        build_mock_pollers, canned_histories, mock_worker, MockPollCfg, ResponseType, TEST_Q,
     },
+    worker::client::mocks::mock_workflow_client,
 };
 use std::{
     sync::{
@@ -11,9 +12,10 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::mocks::mock_gateway;
-use temporal_sdk::{TestRustWorker, WfContext, WorkflowResult};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowTaskFailedCause;
+use temporal_sdk_core_test_utils::TestWorker;
 
 static DID_FAIL: AtomicBool = AtomicBool::new(false);
 pub async fn timer_wf_fails_once(ctx: WfContext) -> WorkflowResult<()> {
@@ -34,7 +36,7 @@ async fn test_wf_task_rejected_properly() {
     let wf_id = "fakeid";
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let t = canned_histories::workflow_fails_with_failure_after_timer("1");
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 2], mock);
     // We should see one wft failure which has unspecified cause, since panics don't have a defined
     // type.
@@ -42,12 +44,17 @@ async fn test_wf_task_rejected_properly() {
     mh.expect_fail_wft_matcher =
         Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::Unspecified));
     let mock = build_mock_pollers(mh);
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     worker.register_wf(wf_type.to_owned(), timer_wf_fails_once);
     worker
-        .submit_wf(wf_id.to_owned(), wf_type.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -63,7 +70,7 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
     let wf_id = "fakeid";
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let t = canned_histories::single_timer_wf_completes("1");
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -77,12 +84,12 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
         Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::NonDeterministicError));
     let mut mock = build_mock_pollers(mh);
     if use_cache {
-        mock.worker_cfg(TEST_Q, |cfg| {
+        mock.worker_cfg(|cfg| {
             cfg.max_cached_workflows = 2;
         });
     }
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     let started_count: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
     worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
@@ -96,7 +103,12 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
     });
 
     worker
-        .submit_wf(wf_id.to_owned(), wf_type.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/core/src/core_tests/local_activities.rs

@@ -1,7 +1,7 @@
 use crate::{
     replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE},
-    test_help::{build_mock_pollers, mock_core, MockPollCfg, ResponseType, TEST_Q},
-    Core,
+    test_help::{build_mock_pollers, mock_worker, MockPollCfg, ResponseType, TEST_Q},
+    worker::client::mocks::mock_workflow_client,
 };
 use anyhow::anyhow;
 use futures::future::join_all;
@@ -12,12 +12,13 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::mocks::mock_gateway;
-use temporal_sdk::{LocalActivityOptions, TestRustWorker, WfContext, WorkflowResult};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{LocalActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::{
     coresdk::{common::RetryPolicy, AsJsonPayloadExt},
     temporal::api::{enums::v1::EventType, failure::v1::Failure},
 };
+use temporal_sdk_core_test_utils::TestWorker;
 use tokio::sync::Barrier;
 
 async fn echo(e: String) -> anyhow::Result<String> {
@@ -44,7 +45,7 @@ async fn local_act_two_wfts_before_marker(#[case] replay: bool, #[case] cached:
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let resps = if replay {
         vec![ResponseType::AllHistory]
     } else {
@@ -53,10 +54,10 @@ async fn local_act_two_wfts_before_marker(#[case] replay: bool, #[case] cached:
     let mh = MockPollCfg::from_resp_batches(wf_id, t, resps, mock);
     let mut mock = build_mock_pollers(mh);
     if cached {
-        mock.worker_cfg(TEST_Q, |cfg| cfg.max_cached_workflows = 1);
+        mock.worker_cfg(|cfg| cfg.max_cached_workflows = 1);
     }
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     worker.register_wf(
         DEFAULT_WORKFLOW_TYPE.to_owned(),
@@ -73,7 +74,12 @@ async fn local_act_two_wfts_before_marker(#[case] replay: bool, #[case] cached:
     );
     worker.register_activity("echo", echo);
     worker
-        .submit_wf(wf_id.to_owned(), DEFAULT_WORKFLOW_TYPE.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -111,16 +117,21 @@ async fn local_act_many_concurrent() {
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 3], mock);
     let mock = build_mock_pollers(mh);
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     worker.register_wf(DEFAULT_WORKFLOW_TYPE.to_owned(), local_act_fanout_wf);
     worker.register_activity("echo", |str: String| async move { Ok(str) });
     worker
-        .submit_wf(wf_id.to_owned(), DEFAULT_WORKFLOW_TYPE.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -151,15 +162,15 @@ async fn local_act_heartbeat(#[case] shutdown_middle: bool) {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     // Allow returning incomplete history more than once, as the wft timeout can be timing sensitive
     // and might poll an extra time
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 2, 2, 2], mock);
     mh.enforce_correct_number_of_polls = false;
     let mut mock = build_mock_pollers(mh);
-    mock.worker_cfg(TEST_Q, |wc| wc.max_cached_workflows = 1);
-    let core = Arc::new(mock_core(mock));
-    let mut worker = TestRustWorker::new(core.clone(), TEST_Q.to_string(), None);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = Arc::new(mock_worker(mock));
+    let mut worker = TestWorker::new(core.clone(), TEST_Q.to_string());
     let shutdown_barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
 
     worker.register_wf(
@@ -183,7 +194,12 @@ async fn local_act_heartbeat(#[case] shutdown_middle: bool) {
         Ok(str)
     });
     worker
-        .submit_wf(wf_id.to_owned(), DEFAULT_WORKFLOW_TYPE.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     let (_, runres) = tokio::join!(
@@ -208,11 +224,11 @@ async fn local_act_fail_and_retry(#[case] eventually_pass: bool) {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [1], mock);
     let mock = build_mock_pollers(mh);
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     worker.register_wf(
         DEFAULT_WORKFLOW_TYPE.to_owned(),
@@ -249,7 +265,12 @@ async fn local_act_fail_and_retry(#[case] eventually_pass: bool) {
         }
     });
     worker
-        .submit_wf(wf_id.to_owned(), DEFAULT_WORKFLOW_TYPE.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -281,7 +302,7 @@ async fn local_act_retry_long_backoff_uses_timer() {
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_gateway();
+    let mock = mock_workflow_client();
     let mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -289,9 +310,9 @@ async fn local_act_retry_long_backoff_uses_timer() {
         mock,
     );
     let mut mock = build_mock_pollers(mh);
-    mock.worker_cfg(TEST_Q, |w| w.max_cached_workflows = 1);
-    let core = mock_core(mock);
-    let mut worker = TestRustWorker::new(Arc::new(core), TEST_Q.to_string(), None);
+    mock.worker_cfg(|w| w.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+    let mut worker = TestWorker::new(Arc::new(core), TEST_Q.to_string());
 
     worker.register_wf(
         DEFAULT_WORKFLOW_TYPE.to_owned(),
@@ -321,7 +342,12 @@ async fn local_act_retry_long_backoff_uses_timer() {
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
     worker
-        .submit_wf(wf_id.to_owned(), DEFAULT_WORKFLOW_TYPE.to_owned(), vec![])
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/core/src/core_tests/mod.rs

@@ -10,32 +10,37 @@ mod workflow_tasks;
 
 use crate::{
     errors::{PollActivityError, PollWfError},
-    test_help::{build_fake_core, canned_histories, hist_to_poll_resp, ResponseType, TEST_Q},
-    Core, CoreInitOptionsBuilder, CoreSDK, WorkerConfigBuilder,
+    test_help::{build_mock_pollers, canned_histories, mock_worker, test_worker_cfg, MockPollCfg},
+    worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
+    Worker,
 };
 use futures::FutureExt;
 use std::time::Duration;
-use temporal_client::mocks::{fake_sg_opts, mock_manual_gateway};
-use temporal_sdk_core_protos::{
-    coresdk::workflow_completion::WorkflowActivationCompletion,
-    temporal::api::workflowservice::v1::PollActivityTaskQueueResponse,
-};
+use temporal_sdk_core_api::Worker as WorkerTrait;
+use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCompletion;
 use tokio::{sync::Barrier, time::sleep};
 
 #[tokio::test]
 async fn after_shutdown_server_is_not_polled() {
     let t = canned_histories::single_timer("fake_timer");
-    let core = build_fake_core("fake_wf_id", t, &[1]);
-    let res = core.poll_workflow_activation(TEST_Q).await.unwrap();
+    let mh = MockPollCfg::from_resp_batches("fake_wf_id", t, [1], mock_workflow_client());
+    let mut mock = build_mock_pollers(mh);
+    // Just so we don't have to deal w/ cache overflow
+    mock.worker_cfg(|cfg| cfg.max_cached_workflows = 1);
+    let worker = mock_worker(mock);
+
+    let res = worker.poll_workflow_activation().await.unwrap();
     assert_eq!(res.jobs.len(), 1);
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(TEST_Q, res.run_id))
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
         .await
         .unwrap();
-    core.shutdown().await;
+    worker.shutdown().await;
     assert_matches!(
-        core.poll_workflow_activation(TEST_Q).await.unwrap_err(),
+        worker.poll_workflow_activation().await.unwrap_err(),
         PollWfError::ShutDown
     );
+    worker.finalize_shutdown().await;
 }
 
 // Better than cloning a billion arcs...
@@ -44,70 +49,52 @@ lazy_static::lazy_static! {
 }
 #[tokio::test]
 async fn shutdown_interrupts_both_polls() {
-    let mut mock_gateway = mock_manual_gateway();
-    mock_gateway
+    let mut mock_client = mock_manual_workflow_client();
+    mock_client
         .expect_poll_activity_task()
         .times(1)
-        .returning(move |_| {
+        .returning(move |_, _| {
             async move {
                 BARR.wait().await;
                 sleep(Duration::from_secs(1)).await;
-                Ok(PollActivityTaskQueueResponse {
-                    task_token: vec![1],
-                    heartbeat_timeout: Some(Duration::from_secs(1).into()),
-                    ..Default::default()
-                })
+                Ok(Default::default())
             }
             .boxed()
         });
-    mock_gateway
+    mock_client
         .expect_poll_workflow_task()
         .times(1)
         .returning(move |_, _| {
             async move {
                 BARR.wait().await;
                 sleep(Duration::from_secs(1)).await;
-                let t = canned_histories::single_timer("hi");
-                Ok(hist_to_poll_resp(
-                    &t,
-                    "wf".to_string(),
-                    ResponseType::AllHistory,
-                    TEST_Q.to_string(),
-                ))
+                Ok(Default::default())
             }
             .boxed()
         });
 
-    let core = CoreSDK::new(
-        mock_gateway,
-        CoreInitOptionsBuilder::default()
-            .gateway_opts(fake_sg_opts())
-            .build()
-            .unwrap(),
-    );
-    core.register_worker(
-        WorkerConfigBuilder::default()
-            .task_queue(TEST_Q)
+    let worker = Worker::new_test(
+        test_worker_cfg()
             // Need only 1 concurrent pollers for mock expectations to work here
             .max_concurrent_wft_polls(1_usize)
             .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
-    )
-    .unwrap();
+        mock_client,
+    );
     tokio::join! {
         async {
-            assert_matches!(core.poll_activity_task(TEST_Q).await.unwrap_err(),
+            assert_matches!(worker.poll_activity_task().await.unwrap_err(),
                             PollActivityError::ShutDown);
         },
         async {
-            assert_matches!(core.poll_workflow_activation(TEST_Q).await.unwrap_err(),
+            assert_matches!(worker.poll_workflow_activation().await.unwrap_err(),
                             PollWfError::ShutDown);
         },
         async {
             // Give polling a bit to get stuck, then shutdown
             BARR.wait().await;
-            core.shutdown().await;
+            worker.shutdown().await;
         }
     };
 }