@temporalio/core-bridge 1.12.0 → 1.12.2

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

@@ -4,7 +4,7 @@ use crate::{
         MockPollCfg, ResponseType, build_fake_sdk, canned_histories, mock_sdk, mock_sdk_cfg,
         mock_worker, single_hist_mock_sg,
     },
-    worker::client::mocks::mock_workflow_client,
+    worker::client::mocks::mock_worker_client,
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{ChildWorkflowOptions, Signal, WfContext, WorkflowResult};
@@ -32,7 +32,7 @@ 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_workflow_client();
+    let mock = mock_worker_client();
     let mut worker = mock_sdk(MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -130,7 +130,7 @@ async fn cancel_child_workflow_lang_thinks_not_started_but_is(
         }
         _ => canned_histories::single_child_workflow_cancelled("child-id-1"),
     };
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
     let core = mock_worker(mock);
     let act = core.poll_workflow_activation().await.unwrap();
@@ -179,7 +179,7 @@ async fn cancel_child_workflow_lang_thinks_not_started_but_is(
 #[tokio::test]
 async fn cancel_already_complete_child_ignored() {
     let t = canned_histories::single_child_workflow("child-id-1");
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
     let core = mock_worker(mock);
     let act = core.poll_workflow_activation().await.unwrap();

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

@@ -2,7 +2,7 @@ use crate::{
     internal_flags::CoreInternalFlags,
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{MockPollCfg, ResponseType, canned_histories, mock_sdk, mock_sdk_cfg},
-    worker::client::mocks::mock_workflow_client,
+    worker::client::mocks::mock_worker_client,
 };
 use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
@@ -40,7 +40,7 @@ async fn test_panic_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_workflow_client();
+    let mock = mock_worker_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.
@@ -72,7 +72,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_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -131,7 +131,7 @@ async fn activity_id_or_type_change_is_nondeterministic(
         canned_histories::single_activity("1")
     };
     t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -214,7 +214,7 @@ async fn child_wf_id_or_type_change_is_nondeterministic(
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let mut t = canned_histories::single_child_workflow("1");
     t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -289,7 +289,7 @@ async fn repro_channel_missing_because_nondeterminism() {
         let _ts = t.add_by_type(EventType::TimerStarted);
         t.add_workflow_task_scheduled_and_started();
 
-        let mock = mock_workflow_client();
+        let mock = mock_worker_client();
         let mut mh =
             MockPollCfg::from_resp_batches(wf_id, t, [1.into(), ResponseType::AllHistory], mock);
         mh.num_expected_fails = 1;

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

@@ -5,7 +5,7 @@ use crate::{
         MockPollCfg, ResponseType, WorkerExt, build_mock_pollers, hist_to_poll_resp, mock_sdk,
         mock_sdk_cfg, mock_worker, single_hist_mock_sg,
     },
-    worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client},
+    worker::{LEGACY_QUERY_ID, client::mocks::mock_worker_client},
 };
 use anyhow::anyhow;
 use crossbeam_queue::SegQueue;
@@ -69,7 +69,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_workflow_client();
+    let mock = mock_worker_client();
     let resps = if replay {
         vec![ResponseType::AllHistory]
     } else {
@@ -140,7 +140,7 @@ async fn local_act_many_concurrent() {
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 3], mock);
     let mut worker = mock_sdk(mh);
 
@@ -178,7 +178,7 @@ async fn local_act_heartbeat(#[case] shutdown_middle: bool) {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 2, 2], mock);
     mh.enforce_correct_number_of_polls = false;
     let mut worker = mock_sdk_cfg(mh, |wc| {
@@ -240,7 +240,7 @@ 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_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [1], mock);
     let mut worker = mock_sdk(mh);
 
@@ -316,7 +316,7 @@ async fn local_act_retry_long_backoff_uses_timer() {
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -376,7 +376,7 @@ async fn local_act_null_result() {
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
 
@@ -418,7 +418,7 @@ async fn local_act_command_immediately_follows_la_marker() {
     t.add_full_wf_task();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     // Bug only repros when seeing history up to third wft
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [3], mock);
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 0);
@@ -489,7 +489,7 @@ async fn query_during_wft_heartbeat_doesnt_accidentally_fail_to_continue_heartbe
             ),
         ),
     ];
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mock = single_hist_mock_sg(wfid, t, tasks, mock, true);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
     let core = mock_worker(mock);
@@ -605,7 +605,7 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
             pr
         },
     ];
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     if impossible_query_in_task {
         mock.expect_respond_legacy_query()
             .times(1)
@@ -712,7 +712,7 @@ async fn test_schedule_to_start_timeout() {
     t.add_full_wf_task();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::ToTaskNum(1)], mock);
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
 
@@ -791,7 +791,7 @@ async fn test_schedule_to_start_timeout_not_based_on_original_time(
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::AllHistory], mock);
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
 
@@ -868,7 +868,7 @@ async fn start_to_close_timeout_allows_retries(#[values(true, false)] la_complet
     t.add_workflow_execution_completed();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -947,7 +947,7 @@ async fn wft_failure_cancels_running_las() {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2], mock);
     mh.num_expected_fails = 1;
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
@@ -1007,7 +1007,7 @@ async fn resolved_las_not_recorded_if_wft_fails_many_times() {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
@@ -1058,7 +1058,7 @@ async fn local_act_records_nonfirst_attempts_ok() {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 3], mock);
     let nonfirst_counts = Arc::new(SegQueue::new());
     let nfc_c = nonfirst_counts.clone();
@@ -1125,7 +1125,7 @@ async fn local_activities_can_be_delivered_during_shutdown() {
     t.add_timer_fired(timer_started_event_id, "1".to_string());
     t.add_workflow_task_scheduled_and_started();
 
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mock = single_hist_mock_sg(
         wfid,
         t,
@@ -1214,7 +1214,7 @@ async fn queries_can_be_received_while_heartbeating() {
             pr
         },
     ];
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_respond_legacy_query()
         .times(1)
         .returning(move |_, _| Ok(Default::default()));
@@ -1291,7 +1291,7 @@ async fn local_activity_after_wf_complete_is_discarded() {
     t.add_full_wf_task();
     t.add_workflow_task_scheduled_and_started();
 
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mut mock_cfg = MockPollCfg::from_resp_batches(
         wfid,
         t,
@@ -1385,7 +1385,7 @@ async fn local_act_retry_explicit_delay() {
     t.add_workflow_task_scheduled_and_started();
 
     let wf_id = "fakeid";
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches(wf_id, t, [1], mock);
     let mut worker = mock_sdk(mh);
 

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

@@ -12,19 +12,31 @@ mod workflow_tasks;
 use crate::{
     Worker,
     errors::PollError,
-    test_help::{MockPollCfg, build_mock_pollers, canned_histories, mock_worker, test_worker_cfg},
-    worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
+    test_help::{
+        MockPollCfg, build_mock_pollers, canned_histories, mock_worker, single_hist_mock_sg,
+        test_worker_cfg,
+    },
+    worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
 };
 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::coresdk::workflow_completion::WorkflowActivationCompletion;
+use temporal_sdk_core_protos::{
+    TestHistoryBuilder,
+    coresdk::{
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{
+        enums::v1::EventType, history::v1::WorkflowExecutionOptionsUpdatedEventAttributes,
+    },
+};
 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 mh = MockPollCfg::from_resp_batches("fake_wf_id", t, [1], mock_workflow_client());
+    let mh = MockPollCfg::from_resp_batches("fake_wf_id", t, [1], mock_worker_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);
@@ -49,7 +61,7 @@ static BARR: LazyLock<Barrier> = LazyLock::new(|| Barrier::new(3));
 
 #[tokio::test]
 async fn shutdown_interrupts_both_polls() {
-    let mut mock_client = mock_manual_workflow_client();
+    let mut mock_client = mock_manual_worker_client();
     mock_client
         .expect_poll_activity_task()
         .times(1)
@@ -98,3 +110,26 @@ 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());
+    t.last_event().unwrap().worker_may_ignore = true;
+    t.add_full_wf_task();
+
+    let mock = mock_worker_client();
+    let mut mock = single_hist_mock_sg("whatever", t, [1], mock, true);
+    mock.worker_cfg(|w| w.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+    let act = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        act.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
+        }]
+    );
+}

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

@@ -3,7 +3,10 @@ use crate::{
         MockPollCfg, MocksHolder, ResponseType, WorkerExt, build_mock_pollers, canned_histories,
         hist_to_poll_resp, mock_worker, single_hist_mock_sg,
     },
-    worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client},
+    worker::{
+        LEGACY_QUERY_ID,
+        client::{LegacyQueryResult, mocks::mock_worker_client},
+    },
 };
 use futures_util::stream;
 use std::{
@@ -25,7 +28,7 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         common::v1::Payload,
-        enums::v1::{CommandType, EventType},
+        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
         history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event},
         query::v1::WorkflowQuery,
@@ -64,7 +67,7 @@ async fn legacy_query(#[case] include_history: bool) {
         },
         hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
     ];
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     mock.num_expected_legacy_query_resps = 1;
     let mut mock = build_mock_pollers(mock);
     if !include_history {
@@ -156,9 +159,9 @@ async fn new_queries(#[values(1, 3)] num_queries: usize) {
         }
         pr
     }]);
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client.expect_respond_legacy_query().times(0);
-    let mut mh = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mh = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     mh.completion_mock_fn = Some(Box::new(move |c| {
         // If the completion is the one ending the workflow, make sure it includes the query resps
         if c.commands[0].command_type() == CommandType::CompleteWorkflowExecution {
@@ -235,7 +238,7 @@ async fn legacy_query_failure_on_wft_failure() {
         pr.history = Some(History { events: vec![] });
         pr
     }]);
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     mock.num_expected_legacy_query_resps = 1;
     let mut mock = build_mock_pollers(mock);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
@@ -298,8 +301,14 @@ async fn query_failure_because_nondeterminism(#[values(true, false)] legacy: boo
         }
         pr
     }];
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     if legacy {
+        mock.expect_legacy_query_matcher = Box::new(|_, f| match f {
+            LegacyQueryResult::Failed(f) => {
+                f.force_cause() == WorkflowTaskFailedCause::NonDeterministicError
+            }
+            _ => false,
+        });
         mock.num_expected_legacy_query_resps = 1;
     } else {
         mock.num_expected_fails = 1;
@@ -350,7 +359,7 @@ async fn legacy_query_after_complete(#[values(false, true)] full_history: bool)
     };
     tasks.extend([query_with_hist_task.clone(), query_with_hist_task]);
 
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     mock.num_expected_legacy_query_resps = 2;
     let mut mock = build_mock_pollers(mock);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
@@ -443,7 +452,7 @@ async fn query_cache_miss_causes_page_fetch_dont_reply_wft_too_early(
         );
         pr
     }]);
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     if !matches!(hist_type, QueryHists::Full) {
         mock_client
             .expect_get_workflow_execution_history()
@@ -534,7 +543,7 @@ async fn query_replay_with_continue_as_new_doesnt_reply_empty_command() {
         pr
     };
     let tasks = VecDeque::from(vec![query_with_hist_task]);
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_complete_workflow_task()
         .times(1)
@@ -618,7 +627,7 @@ async fn legacy_query_response_gets_not_found_not_fatal() {
         });
         pr
     }];
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_respond_legacy_query()
         .times(1)
         .returning(move |_, _| Err(tonic::Status::not_found("Query gone boi")));
@@ -671,7 +680,7 @@ async fn new_query_fail() {
         );
         pr
     }]);
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_complete_workflow_task()
         .times(1)
@@ -774,7 +783,7 @@ async fn legacy_query_combined_with_timer_fire_repro() {
             pr
         },
     ];
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_respond_legacy_query()
         .times(1)
         .returning(move |_, _| Ok(Default::default()));
@@ -875,9 +884,9 @@ async fn build_id_set_properly_on_query_on_first_task() {
         );
         pr
     }]);
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client.expect_respond_legacy_query().times(0);
-    let mh = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mh = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| {
         wc.max_cached_workflows = 10;
@@ -962,7 +971,7 @@ async fn queries_arent_lost_in_buffer_void(#[values(false, true)] buffered_becau
         hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
     ]);
 
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_complete_workflow_task()
         .returning(|_| Ok(Default::default()));
     mock.expect_respond_legacy_query()

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

@@ -3,7 +3,7 @@ use crate::{
         MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, canned_histories,
         hist_to_poll_resp, mock_worker,
     },
-    worker::{LEGACY_QUERY_ID, client::mocks::mock_workflow_client},
+    worker::{LEGACY_QUERY_ID, client::mocks::mock_worker_client},
 };
 use rstest::{fixture, rstest};
 use std::{collections::VecDeque, time::Duration};
@@ -94,7 +94,7 @@ async fn replay_flag_correct_with_query() {
         },
         hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
     ]);
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_worker_client());
     mock.num_expected_legacy_query_resps = 1;
     let mut mock = build_mock_pollers(mock);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
@@ -139,7 +139,7 @@ async fn replay_flag_correct_signal_before_query_ending_on_wft_completed() {
         pr
     };
 
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, [task], mock_workflow_client());
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, [task], mock_worker_client());
     mock.num_expected_legacy_query_resps = 1;
     let mut mock = build_mock_pollers(mock);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 10);

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

@@ -4,7 +4,7 @@ use crate::{
         MockPollCfg, PollWFTRespExt, ResponseType, build_mock_pollers, hist_to_poll_resp,
         mock_worker,
     },
-    worker::client::mocks::mock_workflow_client,
+    worker::client::mocks::mock_worker_client,
 };
 use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::{
@@ -108,7 +108,7 @@ async fn initial_request_sent_back(#[values(false, true)] reject: bool) {
     let mut poll_resp = hist_to_poll_resp(&t, wfid, ResponseType::AllHistory);
     let upd_req_body = poll_resp.add_update_request(update_id, 1);
 
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_complete_workflow_task()
         .times(1)
@@ -171,7 +171,7 @@ async fn speculative_wft_with_command_event() {
         EventType::ActivityTaskScheduled as i32
     );
 
-    let mock_client = mock_workflow_client();
+    let mock_client = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wfid,
         real_hist,

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

@@ -8,7 +8,7 @@ use crate::{
         self,
         client::{
             MockWorkerClient,
-            mocks::{DEFAULT_TEST_CAPABILITIES, DEFAULT_WORKERS_REGISTRY, mock_workflow_client},
+            mocks::{DEFAULT_TEST_CAPABILITIES, DEFAULT_WORKERS_REGISTRY, mock_worker_client},
         },
     },
 };
@@ -106,7 +106,7 @@ async fn worker_shutdown_during_poll_doesnt_deadlock() {
         ))
     });
     let mw = MockWorkerInputs::new(stream.boxed());
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
@@ -126,7 +126,7 @@ async fn worker_shutdown_during_poll_doesnt_deadlock() {
 #[tokio::test]
 async fn can_shutdown_local_act_only_worker_when_act_polling() {
     let t = canned_histories::single_timer("1");
-    let mock = mock_workflow_client();
+    let mock = mock_worker_client();
     let mh = MockPollCfg::from_resp_batches("fakeid", t, [1], mock);
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|w| {
@@ -166,7 +166,7 @@ async fn can_shutdown_local_act_only_worker_when_act_polling() {
 #[tokio::test]
 async fn complete_with_task_not_found_during_shutdown() {
     let t = canned_histories::single_timer("1");
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_complete_workflow_task()
         .times(1)
         .returning(|_| Err(tonic::Status::not_found("Workflow task not found.")));
@@ -209,7 +209,7 @@ async fn complete_eviction_after_shutdown_doesnt_panic() {
         "fakeid",
         t,
         [1],
-        mock_workflow_client(),
+        mock_worker_client(),
     ));
     mh.make_wft_stream_interminable();
     let core = mock_worker(mh);
@@ -236,7 +236,7 @@ async fn complete_eviction_after_shutdown_doesnt_panic() {
 #[tokio::test]
 async fn worker_does_not_panic_on_retry_exhaustion_of_nonfatal_net_err() {
     let t = canned_histories::single_timer("1");
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     // Return a failure that counts as retryable, and hence we want to be swallowed
     mock.expect_complete_workflow_task()
         .times(1)
@@ -264,7 +264,7 @@ async fn worker_does_not_panic_on_retry_exhaustion_of_nonfatal_net_err() {
 #[rstest::rstest]
 #[tokio::test]
 async fn worker_can_shutdown_after_never_polling_ok(#[values(true, false)] poll_workflow: bool) {
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_poll_activity_task()
         .returning(|_, _| Err(tonic::Status::permission_denied("you shall not pass")));
     if poll_workflow {
@@ -314,6 +314,8 @@ async fn worker_shutdown_api(#[case] use_cache: bool, #[case] api_success: bool)
     mock.expect_is_mock().returning(|| true);
     mock.expect_sdk_name_and_version()
         .returning(|| ("test-core".to_string(), "0.0.0".to_string()));
+    mock.expect_get_identity()
+        .returning(|| "test-identity".to_string());
     if use_cache {
         if api_success {
             mock.expect_shutdown_worker()