@temporalio/core-bridge 1.4.4 → 1.5.1

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

@@ -1,7 +1,7 @@
 use crate::{
     test_help::{
         build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, single_hist_mock_sg,
-        MockPollCfg, ResponseType, TEST_Q,
+        MockPollCfg, ResponseType,
     },
     worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
 };
@@ -16,22 +16,24 @@ use temporal_sdk_core_protos::{
             remove_from_cache::EvictionReason, workflow_activation_job, WorkflowActivationJob,
         },
         workflow_commands::{
-            ActivityCancellationType, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution,
-            QueryResult, QuerySuccess, RequestCancelActivity,
+            query_result, ActivityCancellationType, CompleteWorkflowExecution,
+            ContinueAsNewWorkflowExecution, QueryResult, QuerySuccess, RequestCancelActivity,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::{
         common::v1::Payload,
+        enums::v1::EventType,
         failure::v1::Failure,
-        history::v1::History,
+        history::v1::{history_event, ActivityTaskCancelRequestedEventAttributes, History},
         query::v1::WorkflowQuery,
         workflowservice::v1::{
             GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
+    TestHistoryBuilder,
 };
-use temporal_sdk_core_test_utils::{schedule_activity_cmd, start_timer_cmd};
+use temporal_sdk_core_test_utils::{schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers};
 
 #[rstest::rstest]
 #[case::with_history(true)]
@@ -44,9 +46,9 @@ async fn legacy_query(#[case] include_history: bool) {
     let mut header = HashMap::new();
     header.insert("head".to_string(), Payload::from(b"er"));
     let tasks = [
-        hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()),
+        hist_to_poll_resp(&t, wfid.to_owned(), 1.into()),
         {
-            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string());
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
             pr.query = Some(WorkflowQuery {
                 query_type: "query-type".to_string(),
                 query_args: Some(b"hi".into()),
@@ -57,7 +59,7 @@ async fn legacy_query(#[case] include_history: bool) {
             }
             pr
         },
-        hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()),
+        hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
     ];
     let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
     mock.num_expected_legacy_query_resps = 1;
@@ -155,29 +157,21 @@ async fn new_queries(#[case] num_queries: usize) {
     let t = canned_histories::single_timer("1");
     let mut header = HashMap::new();
     header.insert("head".to_string(), Payload::from(b"er"));
-    let tasks = VecDeque::from(vec![
-        hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()),
-        {
-            let mut pr = hist_to_poll_resp(
-                &t,
-                wfid.to_owned(),
-                ResponseType::OneTask(2),
-                TEST_Q.to_string(),
+    let tasks = VecDeque::from(vec![hist_to_poll_resp(&t, wfid.to_owned(), 1.into()), {
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(2));
+        pr.queries = HashMap::new();
+        for i in 1..=num_queries {
+            pr.queries.insert(
+                format!("q{}", i),
+                WorkflowQuery {
+                    query_type: "query-type".to_string(),
+                    query_args: Some(b"hi".into()),
+                    header: Some(header.clone().into()),
+                },
             );
-            pr.queries = HashMap::new();
-            for i in 1..=num_queries {
-                pr.queries.insert(
-                    format!("q{}", i),
-                    WorkflowQuery {
-                        query_type: "query-type".to_string(),
-                        query_args: Some(b"hi".into()),
-                        header: Some(header.clone().into()),
-                    },
-                );
-            }
-            pr
-        },
-    ]);
+        }
+        pr
+    }]);
     let mut mock_client = mock_workflow_client();
     mock_client.expect_respond_legacy_query().times(0);
     let mut mock = single_hist_mock_sg(wfid, t, tasks, mock_client, true);
@@ -237,19 +231,16 @@ async fn new_queries(#[case] num_queries: usize) {
 async fn legacy_query_failure_on_wft_failure() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let tasks = VecDeque::from(vec![
-        hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()),
-        {
-            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string());
-            pr.query = Some(WorkflowQuery {
-                query_type: "query-type".to_string(),
-                query_args: Some(b"hi".into()),
-                header: None,
-            });
-            pr.history = Some(History { events: vec![] });
-            pr
-        },
-    ]);
+    let tasks = VecDeque::from(vec![hist_to_poll_resp(&t, wfid.to_owned(), 1.into()), {
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
+        pr.query = Some(WorkflowQuery {
+            query_type: "query-type".to_string(),
+            query_args: Some(b"hi".into()),
+            header: None,
+        });
+        pr.history = Some(History { events: vec![] });
+        pr
+    }]);
     let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
     mock.num_expected_legacy_query_resps = 1;
     let mut mock = build_mock_pollers(mock);
@@ -292,12 +283,7 @@ async fn query_failure_because_nondeterminism(#[values(true, false)] legacy: boo
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
     let tasks = [{
-        let mut pr = hist_to_poll_resp(
-            &t,
-            wfid.to_owned(),
-            ResponseType::AllHistory,
-            TEST_Q.to_string(),
-        );
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory);
         if legacy {
             pr.query = Some(WorkflowQuery {
                 query_type: "query-type".to_string(),
@@ -356,12 +342,7 @@ async fn legacy_query_after_complete(#[values(false, true)] full_history: bool)
         t
     };
     let query_with_hist_task = {
-        let mut pr = hist_to_poll_resp(
-            &t,
-            wfid.to_owned(),
-            ResponseType::AllHistory,
-            TEST_Q.to_string(),
-        );
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory);
         pr.query = Some(WorkflowQuery {
             query_type: "query-type".to_string(),
             query_args: Some(b"hi".into()),
@@ -375,15 +356,7 @@ async fn legacy_query_after_complete(#[values(false, true)] full_history: bool)
     let mut tasks = if full_history {
         vec![]
     } else {
-        vec![
-            hist_to_poll_resp(
-                &t,
-                wfid.to_owned(),
-                ResponseType::AllHistory,
-                TEST_Q.to_string(),
-            )
-            .resp,
-        ]
+        vec![hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory).resp]
     };
     tasks.extend([query_with_hist_task.clone(), query_with_hist_task]);
 
@@ -456,29 +429,14 @@ async fn query_cache_miss_causes_page_fetch_dont_reply_wft_too_early(
             QueryHists::Empty => {
                 // Create a no-history poll response. This happens to be easiest to do by just ripping
                 // out the history after making a normal one.
-                let mut pr = hist_to_poll_resp(
-                    &t,
-                    wfid.to_owned(),
-                    ResponseType::AllHistory,
-                    TEST_Q.to_string(),
-                );
+                let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory);
                 pr.history = Some(Default::default());
                 pr
             }
-            QueryHists::Full => hist_to_poll_resp(
-                &t,
-                wfid.to_owned(),
-                ResponseType::AllHistory,
-                TEST_Q.to_string(),
-            ),
+            QueryHists::Full => hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory),
             QueryHists::Partial => {
                 // Create a partial task
-                hist_to_poll_resp(
-                    &t,
-                    wfid.to_owned(),
-                    ResponseType::OneTask(2),
-                    TEST_Q.to_string(),
-                )
+                hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(2))
             }
         };
         pr.queries = HashMap::new();
@@ -579,12 +537,7 @@ async fn query_replay_with_continue_as_new_doesnt_reply_empty_command() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
     let query_with_hist_task = {
-        let mut pr = hist_to_poll_resp(
-            &t,
-            wfid.to_owned(),
-            ResponseType::ToTaskNum(1),
-            TEST_Q.to_string(),
-        );
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::ToTaskNum(1));
         pr.queries = HashMap::new();
         pr.queries.insert(
             "the-query".to_string(),
@@ -682,7 +635,7 @@ async fn legacy_query_response_gets_not_found_not_fatal() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
     let tasks = [{
-        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string());
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
         pr.query = Some(WorkflowQuery {
             query_type: "query-type".to_string(),
             query_args: Some(b"hi".into()),
@@ -734,3 +687,208 @@ async fn legacy_query_response_gets_not_found_not_fatal() {
 
     core.shutdown().await;
 }
+
+#[tokio::test]
+async fn new_query_fail() {
+    let wfid = "fake_wf_id";
+    let t = canned_histories::single_timer("1");
+    let tasks = VecDeque::from(vec![{
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
+        pr.queries = HashMap::new();
+        pr.queries.insert(
+            "q1".to_string(),
+            WorkflowQuery {
+                query_type: "query-type".to_string(),
+                query_args: Some(b"hi".into()),
+                header: Default::default(),
+            },
+        );
+        pr
+    }]);
+    let mut mock_client = mock_workflow_client();
+    mock_client
+        .expect_complete_workflow_task()
+        .times(1)
+        .returning(|resp| {
+            // Verify there is a failed query response along w/ start timer cmd
+            assert_eq!(resp.commands.len(), 1);
+            assert_matches!(
+                resp.query_responses.as_slice(),
+                &[QueryResult {
+                    variant: Some(query_result::Variant::Failed(_)),
+                    ..
+                }]
+            );
+            Ok(RespondWorkflowTaskCompletedResponse::default())
+        });
+
+    let mut mock = single_hist_mock_sg(wfid, t, tasks, mock_client, true);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
+    let core = mock_worker(mock);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs[0],
+        WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+        }
+    );
+
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        start_timer_cmd(1, Duration::from_secs(1)),
+    ))
+    .await
+    .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs[0],
+        WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(_)),
+        }
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        QueryResult {
+            query_id: "q1".to_string(),
+            variant: Some(query_result::Variant::Failed("ahhh".into())),
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+}
+
+/// This test verifies that if we get a task with a legacy query in it while in the middle of
+/// processing some local-only work (in this case, resolving an activity as soon as it was
+/// cancelled) that we do not combine the legacy query with the resolve job.
+#[tokio::test]
+async fn legacy_query_combined_with_timer_fire_repro() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let scheduled_event_id = t.add_activity_task_scheduled("1");
+    let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
+    t.add_timer_fired(timer_started_event_id, "1".to_string());
+    t.add_full_wf_task();
+    t.add(
+        EventType::ActivityTaskCancelRequested,
+        history_event::Attributes::ActivityTaskCancelRequestedEventAttributes(
+            ActivityTaskCancelRequestedEventAttributes {
+                scheduled_event_id,
+                ..Default::default()
+            },
+        ),
+    );
+
+    let tasks = [
+        hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::ToTaskNum(1)),
+        {
+            // One task is super important here - as we need to look like we hit the cache
+            // to apply this query right away
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(2));
+            pr.queries = HashMap::new();
+            pr.queries.insert(
+                "the-query".to_string(),
+                WorkflowQuery {
+                    query_type: "query-type".to_string(),
+                    query_args: Some(b"hi".into()),
+                    header: None,
+                },
+            );
+            pr
+        },
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::ToTaskNum(2));
+            // Strip history, we need to look like we hit the cache for a legacy query
+            pr.history = Some(History { events: vec![] });
+            pr.query = Some(WorkflowQuery {
+                query_type: "query-type".to_string(),
+                query_args: Some(b"hi".into()),
+                header: None,
+            });
+            pr
+        },
+    ];
+    let mut mock = mock_workflow_client();
+    mock.expect_respond_legacy_query()
+        .times(1)
+        .returning(move |_, _| Ok(Default::default()));
+    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);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        task.run_id,
+        vec![
+            schedule_activity_cmd(
+                1,
+                "whatever",
+                "1",
+                ActivityCancellationType::TryCancel,
+                Duration::from_secs(60),
+                Duration::from_secs(60),
+            ),
+            start_timer_cmd(1, Duration::from_secs(1)),
+        ],
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        task.run_id,
+        vec![
+            RequestCancelActivity { seq: 1 }.into(),
+            QueryResult {
+                query_id: "the-query".to_string(),
+                variant: Some(
+                    QuerySuccess {
+                        response: Some("whatever".into()),
+                    }
+                    .into(),
+                ),
+            }
+            .into(),
+        ],
+    ))
+    .await
+    .unwrap();
+
+    // First should get the activity resolve
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
+        }]
+    );
+    core.complete_execution(&task.run_id).await;
+
+    // Then the query
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(_)),
+        }]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        QueryResult {
+            query_id: LEGACY_QUERY_ID.to_string(),
+            variant: Some(
+                QuerySuccess {
+                    response: Some("whatever".into()),
+                }
+                .into(),
+            ),
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+    core.shutdown().await;
+}

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

@@ -24,7 +24,7 @@ use tokio::sync::{watch, Barrier};
 #[tokio::test]
 async fn after_shutdown_of_worker_get_shutdown_err() {
     let t = canned_histories::single_timer("1");
-    let worker = build_fake_worker("fake_wf_id", t, &[1]);
+    let worker = build_fake_worker("fake_wf_id", t, [1]);
     let res = worker.poll_workflow_activation().await.unwrap();
     assert_eq!(res.jobs.len(), 1);
     let run_id = res.run_id;
@@ -53,7 +53,7 @@ async fn after_shutdown_of_worker_get_shutdown_err() {
 #[tokio::test]
 async fn shutdown_worker_can_complete_pending_activation() {
     let t = canned_histories::single_timer("1");
-    let worker = build_fake_worker("fake_wf_id", t, &[2]);
+    let worker = build_fake_worker("fake_wf_id", t, [2]);
     let res = worker.poll_workflow_activation().await.unwrap();
     assert_eq!(res.jobs.len(), 1);
     // Complete the timer, will queue PA

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

@@ -107,7 +107,7 @@ async fn timer_then_cancel_req_then_timer_then_cancelled() {
 async fn immediate_cancel() {
     let wfid = "fake_wf_id";
     let t = canned_histories::immediate_wf_cancel();
-    let core = build_fake_worker(wfid, t, &[1]);
+    let core = build_fake_worker(wfid, t, [1]);
 
     poll_and_reply(
         &core,

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

@@ -7,7 +7,6 @@ use crate::{
         mock_worker, poll_and_reply, poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg,
         test_worker_cfg, FakeWfResponses, MockPollCfg, MocksHolder, ResponseType,
         WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
-        TEST_Q,
     },
     worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
     Worker,
@@ -652,7 +651,7 @@ async fn workflow_update_random_seed_on_workflow_reset() {
         timer_1_id.to_string().as_str(),
         new_run_id,
     );
-    let core = build_fake_worker(wfid, t, &[2]);
+    let core = build_fake_worker(wfid, t, [2]);
 
     poll_and_reply(
         &core,
@@ -706,7 +705,7 @@ async fn cancel_timer_before_sent_wf_bridge() {
     t.add_full_wf_task();
     t.add_workflow_execution_completed();
 
-    let core = build_fake_worker(wfid, t, &[1]);
+    let core = build_fake_worker(wfid, t, [1]);
 
     poll_and_reply(
         &core,
@@ -1037,7 +1036,6 @@ async fn lots_of_workflows() {
     let completed_count = Arc::new(Semaphore::new(0));
     let killer = async {
         let _ = completed_count.acquire_many(total_wfs).await.unwrap();
-        dbg!("Shutdown initted");
         worker.initiate_shutdown();
     };
     let poller = fanout_tasks(5, |_| {
@@ -1122,7 +1120,7 @@ async fn complete_after_eviction() {
     let t = canned_histories::single_timer("1");
     let mut mock = mock_workflow_client();
     mock.expect_complete_workflow_task().times(0);
-    let mock = single_hist_mock_sg(wfid, t, &[2], mock, true);
+    let mock = single_hist_mock_sg(wfid, t, [2], mock, true);
     let core = mock_worker(mock);
 
     let activation = core.poll_workflow_activation().await.unwrap();
@@ -1164,7 +1162,7 @@ async fn sends_appropriate_sticky_task_queue_responses() {
         .times(1)
         .returning(|_| Ok(Default::default()));
     mock.expect_complete_workflow_task().times(0);
-    let mut mock = single_hist_mock_sg(wfid, t, &[1], mock, false);
+    let mut mock = single_hist_mock_sg(wfid, t, [1], mock, false);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
     let core = mock_worker(mock);
 
@@ -1182,7 +1180,7 @@ async fn sends_appropriate_sticky_task_queue_responses() {
 async fn new_server_work_while_eviction_outstanding_doesnt_overwrite_activation() {
     let wfid = "fake_wf_id";
     let t = canned_histories::single_timer("1");
-    let mock = single_hist_mock_sg(wfid, t, &[1, 2], mock_workflow_client(), false);
+    let mock = single_hist_mock_sg(wfid, t, [1, 2], mock_workflow_client(), false);
     let taskmap = mock.outstanding_task_map.clone().unwrap();
     let core = mock_worker(mock);
 
@@ -1224,7 +1222,7 @@ async fn buffered_work_drained_on_shutdown() {
     t.add_workflow_task_scheduled_and_started();
     // Need to build the first response before adding the timeout events b/c otherwise the history
     // builder will include them in the first task
-    let resp_1 = hist_to_poll_resp(&t, wfid.to_owned(), 1.into(), TEST_Q.to_string()).resp;
+    let resp_1 = hist_to_poll_resp(&t, wfid.to_owned(), 1.into()).resp;
     t.add_workflow_task_timed_out();
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
@@ -1242,10 +1240,7 @@ async fn buffered_work_drained_on_shutdown() {
     // Extend the task list with the now timeout-included version of the task. We add a bunch of
     // them because the poll loop will spin while new tasks are available and it is buffering them
     tasks.extend(
-        std::iter::repeat_with(|| {
-            hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()).resp
-        })
-        .take(50),
+        std::iter::repeat_with(|| hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp).take(50),
     );
     let mut mock = mock_workflow_client();
     mock.expect_complete_workflow_task()
@@ -1448,7 +1443,7 @@ async fn tries_cancel_of_completed_activity() {
     t.add_workflow_task_scheduled_and_started();
 
     let mock = mock_workflow_client();
-    let mut mock = single_hist_mock_sg("fake_wf_id", t, &[1, 2], mock, true);
+    let mut mock = single_hist_mock_sg("fake_wf_id", t, [1, 2], mock, true);
     mock.worker_cfg(|cfg| cfg.max_cached_workflows = 1);
     let core = mock_worker(mock);
 
@@ -1658,9 +1653,7 @@ async fn tasks_from_completion_are_delivered() {
 
     let mut mock = mock_workflow_client();
     let complete_resp = RespondWorkflowTaskCompletedResponse {
-        workflow_task: Some(
-            hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()).resp,
-        ),
+        workflow_task: Some(hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp),
         activity_tasks: vec![],
     };
     mock.expect_complete_workflow_task()
@@ -1829,7 +1822,7 @@ async fn eviction_waits_until_replay_finished() {
     let wfid = "fake_wf_id";
     let t = canned_histories::long_sequential_timers(3);
     let mock = mock_workflow_client();
-    let mock = single_hist_mock_sg(wfid, t, &[3], mock, true);
+    let mock = single_hist_mock_sg(wfid, t, [3], mock, true);
     let core = mock_worker(mock);
 
     let activation = core.poll_workflow_activation().await.unwrap();
@@ -1890,7 +1883,7 @@ async fn autocompletes_wft_no_work() {
     t.add_activity_task_completed(scheduled_event_id, started_event_id, Default::default());
     t.add_full_wf_task();
     let mock = mock_workflow_client();
-    let mut mock = single_hist_mock_sg(wfid, t, &[1, 2, 3, 4], mock, true);
+    let mut mock = single_hist_mock_sg(wfid, t, [1, 2, 3, 4], mock, true);
     mock.worker_cfg(|w| w.max_cached_workflows = 1);
     let core = mock_worker(mock);
 
@@ -1951,8 +1944,7 @@ async fn no_race_acquiring_permits() {
         .expect_poll_workflow_task()
         .returning(move |_, _| {
             let t = canned_histories::single_timer("1");
-            let poll_resp =
-                hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()).resp;
+            let poll_resp = hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp;
             async move {
                 task_barr.wait().await;
                 Ok(poll_resp.clone())
@@ -2031,13 +2023,7 @@ async fn continue_as_new_preserves_some_values() {
     mock_client
         .expect_poll_workflow_task()
         .returning(move |_, _| {
-            Ok(hist_to_poll_resp(
-                &hist,
-                wfid.to_owned(),
-                ResponseType::AllHistory,
-                TEST_Q.to_string(),
-            )
-            .resp)
+            Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
         });
     mock_client
         .expect_complete_workflow_task()
@@ -2068,3 +2054,36 @@ async fn continue_as_new_preserves_some_values() {
         .await
         .unwrap();
 }
+
+#[rstest]
+#[tokio::test]
+async fn ignorable_events_are_ok(#[values(true, false)] attribs_unset: bool) {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    let id = t.add_get_event_id(
+        EventType::Unspecified,
+        Some(
+            history_event::Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(
+                Default::default(),
+            ),
+        ),
+    );
+    t.modify_event(id, |e| e.worker_may_ignore = true);
+    if attribs_unset {
+        t.modify_event(id, |e| {
+            e.event_type = EventType::WorkflowPropertiesModifiedExternally as i32;
+            e.attributes = None;
+        });
+    }
+    t.add_workflow_task_scheduled_and_started();
+
+    let mock = mock_workflow_client();
+    let mock = single_hist_mock_sg("wheee", t, [ResponseType::AllHistory], mock, true);
+    let core = mock_worker(mock);
+
+    let act = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        act.jobs[0].variant,
+        Some(workflow_activation_job::Variant::StartWorkflow(_))
+    );
+}