@temporalio/core-bridge 1.13.0 → 1.13.2

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

@@ -1,10 +1,10 @@
 use crate::{
     ActivityHeartbeat, Worker, advance_fut, job_assert, prost_dur,
     test_help::{
-        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, ResponseType, TEST_Q, WorkerExt,
-        WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, canned_histories,
-        gen_assert_and_reply, mock_manual_poller, mock_poller, mock_poller_from_resps,
-        mock_sdk_cfg, mock_worker, poll_and_reply, single_hist_mock_sg, test_worker_cfg,
+        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, TEST_Q, WorkerExt,
+        WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, fanout_tasks,
+        gen_assert_and_reply, mock_manual_poller, mock_poller, mock_worker, poll_and_reply,
+        single_hist_mock_sg, test_worker_cfg,
     },
     worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
 };
@@ -19,17 +19,13 @@ use std::{
         Arc,
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_api::{
-    Worker as WorkerTrait,
-    errors::{CompleteActivityError, PollError},
-    worker::PollerBehavior,
+    Worker as WorkerTrait, errors::CompleteActivityError, worker::PollerBehavior,
 };
 use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    TestHistoryBuilder, canned_histories,
     coresdk::{
         ActivityTaskCompletion,
         activity_result::{
@@ -46,20 +42,16 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes},
-        enums::v1::{CommandType, EventType},
-        history::v1::{
-            ActivityTaskScheduledEventAttributes, history_event::Attributes as EventAttributes,
-        },
-        sdk::v1::UserMetadata,
+        enums::v1::EventType,
         workflowservice::v1::{
             PollActivityTaskQueueResponse, RecordActivityTaskHeartbeatResponse,
             RespondActivityTaskCanceledResponse, RespondActivityTaskCompletedResponse,
             RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
+    test_utils::start_timer_cmd,
 };
-use temporal_sdk_core_test_utils::{TestWorker, fanout_tasks, start_timer_cmd};
-use tokio::{join, sync::Barrier, time::sleep};
+use tokio::{join, time::sleep};
 use tokio_util::sync::CancellationToken;
 
 fn three_tasks() -> VecDeque<PollActivityTaskQueueResponse> {
@@ -642,6 +634,47 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
     worker.poll_activity_task().await.unwrap();
 }
 
+#[tokio::test]
+async fn max_worker_acts_per_second_respected() {
+    let mut mock_client = mock_worker_client();
+    mock_client
+        .expect_poll_activity_task()
+        .returning(move |_, _| {
+            Ok(PollActivityTaskQueueResponse {
+                task_token: vec![1],
+                activity_id: "some-id".to_string(),
+                ..Default::default()
+            })
+        });
+    mock_client
+        .expect_complete_activity_task()
+        .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
+
+    let cfg = test_worker_cfg()
+        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
+        .max_outstanding_activities(10_usize)
+        .max_worker_activities_per_second(1.0)
+        .build()
+        .unwrap();
+    let worker = Worker::new_test(cfg, mock_client);
+    let start = Instant::now();
+    let mut received = 0;
+    while start.elapsed().as_millis() < 900 {
+        let at = worker.poll_activity_task().await.unwrap();
+        received += 1;
+        worker
+            .complete_activity_task(ActivityTaskCompletion {
+                task_token: at.task_token,
+                result: Some(ActivityExecutionResult::ok("hi".into())),
+            })
+            .await
+            .unwrap();
+    }
+    // Two will be allowed because of the initial request. Without ratelimit in effect, this number
+    // would be comically high due to the mocks responding very fast.
+    assert_eq!(received, 2);
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn no_eager_activities_requested_when_worker_options_disable_it(
@@ -781,9 +814,11 @@ async fn activity_tasks_from_completion_are_delivered() {
     mock.expect_complete_activity_task()
         .times(3)
         .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
-    let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
     let act_tasks: Vec<QueueResponse<PollActivityTaskQueueResponse>> = vec![];
-    mock.set_act_poller(mock_poller_from_resps(act_tasks));
+    let mut mh = MockPollCfg::from_resp_batches(wfid, t, [1], mock);
+    mh.enforce_correct_number_of_polls = true;
+    mh.activity_responses = Some(act_tasks);
+    let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
 
@@ -848,160 +883,6 @@ async fn activity_tasks_from_completion_are_delivered() {
     assert_eq!(num_eager_requested.load(Ordering::Relaxed), 3);
 }
 
-#[tokio::test]
-async fn activity_tasks_from_completion_reserve_slots() {
-    let wf_id = "fake_wf_id";
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let schedid = t.add(EventAttributes::ActivityTaskScheduledEventAttributes(
-        ActivityTaskScheduledEventAttributes {
-            activity_id: "1".to_string(),
-            activity_type: Some("act1".into()),
-            ..Default::default()
-        },
-    ));
-    let startid = t.add_activity_task_started(schedid);
-    t.add_activity_task_completed(schedid, startid, b"hi".into());
-    t.add_full_wf_task();
-    let schedid = t.add(EventAttributes::ActivityTaskScheduledEventAttributes(
-        ActivityTaskScheduledEventAttributes {
-            activity_id: "2".to_string(),
-            activity_type: Some("act2".into()),
-            ..Default::default()
-        },
-    ));
-    let startid = t.add_activity_task_started(schedid);
-    t.add_activity_task_completed(schedid, startid, b"hi".into());
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-
-    let mut mock = mock_worker_client();
-    // Set up two tasks to be returned via normal activity polling
-    let act_tasks = VecDeque::from(vec![
-        PollActivityTaskQueueResponse {
-            task_token: vec![1],
-            activity_id: "act1".to_string(),
-            ..Default::default()
-        }
-        .into(),
-        PollActivityTaskQueueResponse {
-            task_token: vec![2],
-            activity_id: "act2".to_string(),
-            ..Default::default()
-        }
-        .into(),
-    ]);
-    mock.expect_complete_activity_task()
-        .times(2)
-        .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
-    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
-    let mut mh = MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        [
-            ResponseType::ToTaskNum(1),
-            // We don't want the second task to be delivered until *after* the activity tasks
-            // have been completed, so that the second activity schedule will have slots available
-            ResponseType::UntilResolved(
-                async {
-                    barr.wait().await;
-                    barr.wait().await;
-                }
-                .boxed(),
-                2,
-            ),
-            ResponseType::AllHistory,
-        ],
-        mock,
-    );
-    mh.completion_mock_fn = Some(Box::new(|wftc| {
-        // Make sure when we see the completion with the schedule act command that it does
-        // not have the eager execution flag set the first time, and does the second.
-        if let Some(Attributes::ScheduleActivityTaskCommandAttributes(attrs)) = wftc
-            .commands
-            .first()
-            .and_then(|cmd| cmd.attributes.as_ref())
-        {
-            if attrs.activity_id == "1" {
-                assert!(!attrs.request_eager_execution);
-            } else {
-                assert!(attrs.request_eager_execution);
-            }
-        }
-        Ok(Default::default())
-    }));
-    let mut mock = build_mock_pollers(mh);
-    mock.worker_cfg(|cfg| {
-        cfg.max_cached_workflows = 2;
-        cfg.max_outstanding_activities = Some(2);
-    });
-    mock.set_act_poller(mock_poller_from_resps(act_tasks));
-    let core = Arc::new(mock_worker(mock));
-    let mut worker = TestWorker::new(core.clone(), TEST_Q.to_string());
-
-    // First poll for activities twice, occupying both slots
-    let at1 = core.poll_activity_task().await.unwrap();
-    let at2 = core.poll_activity_task().await.unwrap();
-    let workflow_complete_token = CancellationToken::new();
-    let workflow_complete_token_clone = workflow_complete_token.clone();
-
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| {
-        let complete_token = workflow_complete_token.clone();
-        async move {
-            ctx.activity(ActivityOptions {
-                activity_type: "act1".to_string(),
-                ..Default::default()
-            })
-            .await;
-            ctx.activity(ActivityOptions {
-                activity_type: "act2".to_string(),
-                ..Default::default()
-            })
-            .await;
-            complete_token.cancel();
-            Ok(().into())
-        }
-    });
-
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            DEFAULT_WORKFLOW_TYPE,
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let act_completer = async {
-        barr.wait().await;
-        core.complete_activity_task(ActivityTaskCompletion {
-            task_token: at1.task_token,
-            result: Some(ActivityExecutionResult::ok("hi".into())),
-        })
-        .await
-        .unwrap();
-        core.complete_activity_task(ActivityTaskCompletion {
-            task_token: at2.task_token,
-            result: Some(ActivityExecutionResult::ok("hi".into())),
-        })
-        .await
-        .unwrap();
-        barr.wait().await;
-        // Wait for workflow to complete in order for all eager activities to be requested before shutting down.
-        // After shutdown, no eager activities slots can be allocated.
-        workflow_complete_token_clone.cancelled().await;
-        core.initiate_shutdown();
-        // Even though this test requests eager activity tasks, none are returned in poll responses.
-        let err = core.poll_activity_task().await.unwrap_err();
-        assert_matches!(err, PollError::ShutDown);
-    };
-    // This wf poll should *not* set the flag that it wants tasks back since both slots are
-    // occupied
-    let run_fut = async { worker.run_until_done().await.unwrap() };
-    join!(run_fut, act_completer);
-}
-
 #[tokio::test]
 async fn retryable_net_error_exhaustion_is_nonfatal() {
     let mut mock_client = mock_worker_client();
@@ -1198,57 +1079,6 @@ async fn activities_must_be_flushed_to_server_on_shutdown(#[values(true, false)]
     join!(shutdown_task, complete_task);
 }
 
-#[tokio::test]
-async fn pass_activity_summary_to_metadata() {
-    let t = canned_histories::single_activity("1");
-    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-    let wf_id = mock_cfg.hists[0].wf_id.clone();
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let expected_user_metadata = Some(UserMetadata {
-        summary: Some(b"activity summary".into()),
-        details: None,
-    });
-    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-        asserts
-            .then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_eq!(
-                    wft.commands[0].command_type(),
-                    CommandType::ScheduleActivityTask
-                );
-                assert_eq!(wft.commands[0].user_metadata, expected_user_metadata)
-            })
-            .then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_eq!(
-                    wft.commands[0].command_type(),
-                    CommandType::CompleteWorkflowExecution
-                );
-            });
-    });
-
-    let mut worker = mock_sdk_cfg(mock_cfg, |_| {});
-    worker.register_wf(wf_type, |ctx: WfContext| async move {
-        ctx.activity(ActivityOptions {
-            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-            summary: Some("activity summary".to_string()),
-            ..Default::default()
-        })
-        .await;
-        Ok(().into())
-    });
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[tokio::test]
 async fn heartbeat_response_can_be_paused() {
     let mut mock_client = mock_worker_client();

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

@@ -1,7 +1,4 @@
 mod activity_tasks;
-mod child_workflows;
-mod determinism;
-mod local_activities;
 mod queries;
 mod replay_flag;
 mod updates;
@@ -13,8 +10,7 @@ use crate::{
     Worker,
     errors::PollError,
     test_help::{
-        MockPollCfg, build_mock_pollers, canned_histories, mock_worker, single_hist_mock_sg,
-        test_worker_cfg,
+        MockPollCfg, build_mock_pollers, mock_worker, single_hist_mock_sg, test_worker_cfg,
     },
     worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
 };
@@ -22,7 +18,7 @@ use futures_util::FutureExt;
 use std::{sync::LazyLock, time::Duration};
 use temporal_sdk_core_api::{Worker as WorkerTrait, worker::PollerBehavior};
 use temporal_sdk_core_protos::{
-    TestHistoryBuilder,
+    TestHistoryBuilder, canned_histories,
     coresdk::{
         workflow_activation::{WorkflowActivationJob, workflow_activation_job},
         workflow_completion::WorkflowActivationCompletion,
@@ -113,8 +109,6 @@ async fn shutdown_interrupts_both_polls() {
 
 #[tokio::test]
 async fn ignores_workflow_options_updated_event() {
-    temporal_sdk_core_test_utils::init_integ_telem();
-
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add(WorkflowExecutionOptionsUpdatedEventAttributes::default());

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

@@ -1,6 +1,6 @@
 use crate::{
     test_help::{
-        MockPollCfg, MocksHolder, ResponseType, WorkerExt, build_mock_pollers, canned_histories,
+        MockPollCfg, MocksHolder, ResponseType, WorkerExt, WorkerTestHelpers, build_mock_pollers,
         hist_to_poll_resp, mock_worker, single_hist_mock_sg,
     },
     worker::{
@@ -15,7 +15,7 @@ use std::{
 };
 use temporal_sdk_core_api::{Worker as WorkerTrait, worker::WorkerVersioningStrategy};
 use temporal_sdk_core_protos::{
-    TestHistoryBuilder,
+    TestHistoryBuilder, canned_histories,
     coresdk::{
         workflow_activation::{
             WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
@@ -36,9 +36,7 @@ use temporal_sdk_core_protos::{
             GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
-};
-use temporal_sdk_core_test_utils::{
-    WorkerTestHelpers, query_ok, schedule_activity_cmd, start_timer_cmd,
+    test_utils::{query_ok, schedule_activity_cmd, start_timer_cmd},
 };
 
 #[rstest::rstest]

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

@@ -1,77 +1,18 @@
 use crate::{
-    test_help::{
-        MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, canned_histories,
-        hist_to_poll_resp, mock_worker,
-    },
+    test_help::{MockPollCfg, ResponseType, build_mock_pollers, hist_to_poll_resp, mock_worker},
     worker::{LEGACY_QUERY_ID, client::mocks::mock_worker_client},
 };
-use rstest::{fixture, rstest};
 use std::{collections::VecDeque, time::Duration};
-use temporal_sdk::{WfContext, Worker, WorkflowFunction};
 use temporal_sdk_core_api::Worker as CoreWorker;
 use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    TestHistoryBuilder, canned_histories,
     coresdk::{
         workflow_activation::{WorkflowActivationJob, workflow_activation_job},
         workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery},
+    test_utils::{query_ok, start_timer_cmd},
 };
-use temporal_sdk_core_test_utils::{
-    interceptors::ActivationAssertionsInterceptor, query_ok, start_timer_cmd,
-};
-
-fn timers_wf(num_timers: u32) -> WorkflowFunction {
-    WorkflowFunction::new(move |command_sink: WfContext| async move {
-        for _ in 1..=num_timers {
-            command_sink.timer(Duration::from_secs(1)).await;
-        }
-        Ok(().into())
-    })
-}
-
-#[fixture(num_timers = 1)]
-fn fire_happy_hist(num_timers: u32) -> Worker {
-    let func = timers_wf(num_timers);
-    // Add 1 b/c history takes # wf tasks, not timers
-    let t = canned_histories::long_sequential_timers(num_timers as usize);
-    let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [ResponseType::AllHistory]));
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
-    worker
-}
-
-#[rstest]
-#[case::one_timer(fire_happy_hist(1), 1)]
-#[case::five_timers(fire_happy_hist(5), 5)]
-#[tokio::test]
-async fn replay_flag_is_correct(#[case] mut worker: Worker, #[case] num_timers: usize) {
-    // Verify replay flag is correct by constructing a workflow manager that already has a complete
-    // history fed into it. It should always be replaying, because history is complete.
-
-    let mut aai = ActivationAssertionsInterceptor::default();
-
-    for _ in 1..=num_timers + 1 {
-        aai.then(|a| assert!(a.is_replaying));
-    }
-
-    worker.set_worker_interceptor(aai);
-    worker.run().await.unwrap();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn replay_flag_is_correct_partial_history() {
-    let func = timers_wf(1);
-    // Add 1 b/c history takes # wf tasks, not timers
-    let t = canned_histories::long_sequential_timers(2);
-    let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [1]));
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
-
-    let mut aai = ActivationAssertionsInterceptor::default();
-    aai.then(|a| assert!(!a.is_replaying));
-
-    worker.set_worker_interceptor(aai);
-    worker.run().await.unwrap();
-}
 
 #[tokio::test]
 async fn replay_flag_correct_with_query() {

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

@@ -1,8 +1,8 @@
 use crate::{
     prost_dur,
     test_help::{
-        MockPollCfg, PollWFTRespExt, ResponseType, build_mock_pollers, hist_to_poll_resp,
-        mock_worker,
+        MockPollCfg, PollWFTRespExt, ResponseType, WorkerTestHelpers, build_mock_pollers,
+        hist_to_poll_resp, mock_worker,
     },
     worker::client::mocks::mock_worker_client,
 };
@@ -24,7 +24,6 @@ use temporal_sdk_core_protos::{
         workflowservice::v1::RespondWorkflowTaskCompletedResponse,
     },
 };
-use temporal_sdk_core_test_utils::WorkerTestHelpers;
 
 #[tokio::test]
 async fn replay_with_empty_first_task() {
@@ -115,10 +114,10 @@ async fn initial_request_sent_back(#[values(false, true)] reject: bool) {
         .returning(move |mut resp| {
             let msg = resp.messages.pop().unwrap();
             let orig_req = if reject {
-                let acceptance = msg.body.unwrap().unpack_as(Rejection::default()).unwrap();
+                let acceptance = msg.body.unwrap().to_msg::<Rejection>().unwrap();
                 acceptance.rejected_request.unwrap()
             } else {
-                let acceptance = msg.body.unwrap().unpack_as(Acceptance::default()).unwrap();
+                let acceptance = msg.body.unwrap().to_msg::<Acceptance>().unwrap();
                 acceptance.accepted_request.unwrap()
             };
             assert_eq!(orig_req, upd_req_body);

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

@@ -1,8 +1,8 @@
 use crate::{
     PollError, prost_dur,
     test_help::{
-        MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt, build_fake_worker,
-        build_mock_pollers, canned_histories, mock_worker, test_worker_cfg,
+        MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt, WorkerTestHelpers,
+        build_fake_worker, build_mock_pollers, mock_worker, test_worker_cfg,
     },
     worker::{
         self,
@@ -16,6 +16,7 @@ use futures_util::{stream, stream::StreamExt};
 use std::{cell::RefCell, time::Duration};
 use temporal_sdk_core_api::{Worker, worker::PollerBehavior};
 use temporal_sdk_core_protos::{
+    canned_histories,
     coresdk::{
         workflow_activation::workflow_activation_job,
         workflow_commands::{CompleteWorkflowExecution, StartTimer, workflow_command},
@@ -24,8 +25,8 @@ use temporal_sdk_core_protos::{
     temporal::api::workflowservice::v1::{
         PollWorkflowTaskQueueResponse, RespondWorkflowTaskCompletedResponse, ShutdownWorkerResponse,
     },
+    test_utils::start_timer_cmd,
 };
-use temporal_sdk_core_test_utils::{WorkerTestHelpers, start_timer_cmd};
 use tokio::sync::{Barrier, watch};
 
 #[tokio::test]

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

@@ -1,19 +1,22 @@
 use crate::{
     job_assert,
     test_help::{
-        ResponseType, WorkflowCachingPolicy::NonSticky, build_fake_worker, canned_histories,
-        gen_assert_and_reply, poll_and_reply,
+        ResponseType, WorkflowCachingPolicy::NonSticky, build_fake_worker, gen_assert_and_reply,
+        poll_and_reply,
     },
 };
 use rstest::rstest;
 use std::time::Duration;
-use temporal_sdk_core_protos::coresdk::{
-    workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-    workflow_commands::{
-        CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
+use temporal_sdk_core_protos::{
+    canned_histories,
+    coresdk::{
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        workflow_commands::{
+            CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
+        },
     },
+    test_utils::start_timer_cmd,
 };
-use temporal_sdk_core_test_utils::start_timer_cmd;
 
 enum CompletionType {
     Complete,