temporalio 0.1.0 → 0.2.0

data/bridge/sdk-core/core/src/core_tests/queries.rs

@@ -1,893 +0,0 @@
-use crate::{
-    test_help::{
-        build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, single_hist_mock_sg,
-        MockPollCfg, ResponseType,
-    },
-    worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
-};
-use std::{
-    collections::{HashMap, VecDeque},
-    time::Duration,
-};
-use temporal_sdk_core_api::Worker as WorkerTrait;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        workflow_activation::{
-            remove_from_cache::EvictionReason, workflow_activation_job, WorkflowActivationJob,
-        },
-        workflow_commands::{
-            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_event, ActivityTaskCancelRequestedEventAttributes, History},
-        query::v1::WorkflowQuery,
-        workflowservice::v1::{
-            GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
-        },
-    },
-    TestHistoryBuilder,
-};
-use temporal_sdk_core_test_utils::{schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers};
-
-#[rstest::rstest]
-#[case::with_history(true)]
-#[case::without_history(false)]
-#[tokio::test]
-async fn legacy_query(#[case] include_history: bool) {
-    let wfid = "fake_wf_id";
-    let query_resp = "response";
-    let t = canned_histories::single_timer("1");
-    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()),
-        {
-            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: Some(header.into()),
-            });
-            if !include_history {
-                pr.history = Some(History { events: vec![] });
-            }
-            pr
-        },
-        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;
-    let mut mock = build_mock_pollers(mock);
-    if !include_history {
-        mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    }
-    let worker = mock_worker(mock);
-
-    let first_wft = || async {
-        let task = worker.poll_workflow_activation().await.unwrap();
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                task.run_id,
-                start_timer_cmd(1, Duration::from_secs(1)),
-            ))
-            .await
-            .unwrap();
-    };
-    let clear_eviction = || async {
-        let t = worker.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            t.jobs[0].variant,
-            Some(workflow_activation_job::Variant::RemoveFromCache(_))
-        );
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::empty(t.run_id))
-            .await
-            .unwrap();
-    };
-
-    first_wft().await;
-
-    if include_history {
-        clear_eviction().await;
-        first_wft().await;
-    }
-
-    let task = worker.poll_workflow_activation().await.unwrap();
-    // Poll again, and we end up getting a `query` field query response
-    let query = assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-        }] => q
-    );
-    assert_eq!(query.headers.get("head").unwrap(), &b"er".into());
-    // Complete the query
-    worker
-        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-            task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some(query_resp.into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
-        ))
-        .await
-        .unwrap();
-
-    if include_history {
-        clear_eviction().await;
-        first_wft().await;
-    }
-
-    let task = worker.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-        }]
-    );
-    worker
-        .complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            task.run_id,
-            vec![CompleteWorkflowExecution { result: None }.into()],
-        ))
-        .await
-        .unwrap();
-    worker.shutdown().await;
-}
-
-#[rstest::rstest]
-#[case::one_query(1)]
-#[case::multiple_queries(3)]
-#[tokio::test]
-async fn new_queries(#[case] num_queries: usize) {
-    let wfid = "fake_wf_id";
-    let query_resp = "response";
-    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()), {
-        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
-    }]);
-    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);
-    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    let core = mock_worker(mock);
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    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::FireTimer(_)),
-        }
-    );
-    for i in 1..=num_queries {
-        assert_matches!(
-            task.jobs[i],
-            WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
-            } => {
-                assert_eq!(q.headers.get("head").unwrap(), &b"er".into());
-            }
-        );
-    }
-    let mut qresults: Vec<_> = (1..=num_queries)
-        .map(|i| {
-            QueryResult {
-                query_id: format!("q{i}"),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some(query_resp.into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into()
-        })
-        .collect();
-    qresults.push(CompleteWorkflowExecution { result: None }.into());
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        qresults,
-    ))
-    .await
-    .unwrap();
-    core.shutdown().await;
-}
-
-#[tokio::test]
-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()), {
-        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);
-    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    let core = mock_worker(mock);
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    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();
-    // Poll again, and we end up getting a `query` field query response
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-        }] => q
-    );
-    // Fail wft which should result in query being failed
-    core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-        task.run_id,
-        Failure {
-            message: "Ahh i broke".to_string(),
-            ..Default::default()
-        },
-    ))
-    .await
-    .unwrap();
-
-    core.shutdown().await;
-}
-
-#[rstest::rstest]
-#[tokio::test]
-async fn query_failure_because_nondeterminism(#[values(true, false)] legacy: bool) {
-    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);
-        if legacy {
-            pr.query = Some(WorkflowQuery {
-                query_type: "query-type".to_string(),
-                query_args: Some(b"hi".into()),
-                header: None,
-            });
-        } else {
-            pr.queries = HashMap::new();
-            pr.queries.insert(
-                "q1".to_string(),
-                WorkflowQuery {
-                    query_type: "query-type".to_string(),
-                    query_args: Some(b"hi".into()),
-                    header: None,
-                },
-            );
-        }
-        pr
-    }];
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
-    if legacy {
-        mock.num_expected_legacy_query_resps = 1;
-    } else {
-        mock.num_expected_fails = 1;
-    }
-    let mut mock = build_mock_pollers(mock);
-    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    let core = mock_worker(mock);
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    // Nondeterminism, should result in WFT/query being failed
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-        .await
-        .unwrap();
-    let task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs[0].variant,
-        Some(workflow_activation_job::Variant::RemoveFromCache(_))
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-        .await
-        .unwrap();
-
-    core.shutdown().await;
-}
-
-#[rstest::rstest]
-#[tokio::test]
-async fn legacy_query_after_complete(#[values(false, true)] full_history: bool) {
-    let wfid = "fake_wf_id";
-    let t = if full_history {
-        canned_histories::single_timer_wf_completes("1")
-    } else {
-        let mut t = canned_histories::single_timer("1");
-        t.add_workflow_task_completed();
-        t
-    };
-    let query_with_hist_task = {
-        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()),
-            header: None,
-        });
-        pr.resp
-    };
-    // Server would never send us a workflow task *without* a query that goes all the way to
-    // execution completed. So, don't do that. It messes with the mock unlocking the next
-    // task since we (appropriately) won't respond to server in that situation.
-    let mut tasks = if full_history {
-        vec![]
-    } else {
-        vec![hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory).resp]
-    };
-    tasks.extend([query_with_hist_task.clone(), query_with_hist_task]);
-
-    let mut mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock_workflow_client());
-    mock.num_expected_legacy_query_resps = 2;
-    let mut mock = build_mock_pollers(mock);
-    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    let core = mock_worker(mock);
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    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();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        vec![CompleteWorkflowExecution { result: None }.into()],
-    ))
-    .await
-    .unwrap();
-
-    // We should get queries two times
-    for _ in 1..=2 {
-        let task = core.poll_workflow_activation().await.unwrap();
-        let query = assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-            }] => q
-        );
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-            task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some("whatever".into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
-        ))
-        .await
-        .unwrap();
-    }
-
-    core.shutdown().await;
-}
-
-enum QueryHists {
-    Empty,
-    Full,
-    Partial,
-}
-#[rstest::rstest]
-#[tokio::test]
-async fn query_cache_miss_causes_page_fetch_dont_reply_wft_too_early(
-    #[values(QueryHists::Empty, QueryHists::Full, QueryHists::Partial)] hist_type: QueryHists,
-) {
-    let wfid = "fake_wf_id";
-    let query_resp = "response";
-    let t = canned_histories::single_timer("1");
-    let full_hist = t.get_full_history_info().unwrap();
-    let tasks = VecDeque::from(vec![{
-        let mut pr = match hist_type {
-            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);
-                pr.history = Some(Default::default());
-                pr
-            }
-            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))
-            }
-        };
-        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 mock_client = mock_workflow_client();
-    if !matches!(hist_type, QueryHists::Full) {
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| {
-                Ok(GetWorkflowExecutionHistoryResponse {
-                    history: Some(full_hist.clone().into()),
-                    ..Default::default()
-                })
-            });
-    }
-    mock_client
-        .expect_complete_workflow_task()
-        .times(1)
-        .returning(|resp| {
-            // Verify both the complete command and the query response are sent
-            assert_eq!(resp.commands.len(), 1);
-            assert_eq!(resp.query_responses.len(), 1);
-
-            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();
-    // The first task should *only* start the workflow. It should *not* have a query in it, which
-    // was the bug. Query should only appear after we have caught up on replay.
-    assert_matches!(
-        task.jobs.as_slice(),
-        [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.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        task.run_id,
-        CompleteWorkflowExecution { result: None }.into(),
-    ))
-    .await
-    .unwrap();
-
-    // Now the query shall arrive
-    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: "the-query".to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some(query_resp.into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-
-    core.shutdown().await;
-}
-
-#[tokio::test]
-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));
-        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 tasks = VecDeque::from(vec![query_with_hist_task]);
-    let mut mock_client = mock_workflow_client();
-    mock_client
-        .expect_complete_workflow_task()
-        .times(1)
-        .returning(|resp| {
-            // Verify both the complete command and the query response are sent
-            assert_eq!(resp.commands.len(), 1);
-            assert_eq!(resp.query_responses.len(), 1);
-            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();
-    // Scheduling and immediately canceling an activity produces another activation which is
-    // important in this repro
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        vec![
-            schedule_activity_cmd(
-                0,
-                "whatever",
-                "act-id",
-                ActivityCancellationType::TryCancel,
-                Duration::from_secs(60),
-                Duration::from_secs(60),
-            ),
-            RequestCancelActivity { seq: 0 }.into(),
-            ContinueAsNewWorkflowExecution {
-                ..Default::default()
-            }
-            .into(),
-        ],
-    ))
-    .await
-    .unwrap();
-
-    // Activity unblocked
-    let task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-        .await
-        .unwrap();
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    let query = assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-        }] => q
-    );
-    // Throw an evict in there. Repro required a pending eviction during complete.
-    core.request_wf_eviction(&task.run_id, "I said so", EvictionReason::LangRequested);
-
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        task.run_id,
-        QueryResult {
-            query_id: query.query_id.clone(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("whatever".into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-
-    core.shutdown().await;
-}
-
-#[tokio::test]
-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());
-        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 |_, _| Err(tonic::Status::not_found("Query gone boi")));
-    let mock = MockPollCfg::from_resp_batches(wfid, t, tasks, mock);
-    let mut mock = build_mock_pollers(mock);
-    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
-    let core = mock_worker(mock);
-
-    let task = core.poll_workflow_activation().await.unwrap();
-    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();
-    // Poll again, and we end up getting a `query` field query response
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-        }] => q
-    );
-    // Fail wft which should result in query being failed
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        task.run_id,
-        QueryResult {
-            query_id: LEGACY_QUERY_ID.to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("hi".into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-
-    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_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "1".to_string());
-    t.add_full_wf_task();
-    t.add(
-        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;
-}