temporalio 0.0.1 → 0.1.0

data/bridge/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);
@@ -212,7 +206,7 @@ async fn new_queries(#[case] num_queries: usize) {
     let mut qresults: Vec<_> = (1..=num_queries)
         .map(|i| {
             QueryResult {
-                query_id: format!("q{}", i),
+                query_id: format!("q{i}"),
                 variant: Some(
                     QuerySuccess {
                         response: Some(query_resp.into()),
@@ -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,207 @@ 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_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;
+}

data/bridge/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
@@ -190,9 +190,7 @@ async fn complete_with_task_not_found_during_shutdown() {
         complete_order.borrow_mut().push(1);
     };
     tokio::join!(shutdown_fut, poll_fut, complete_fut);
-    // Shutdown will currently complete first before the actual eviction reply since the
-    // workflow task is marked complete as soon as we get not found back from the server.
-    assert_eq!(&complete_order.into_inner(), &[1, 3, 2])
+    assert_eq!(&complete_order.into_inner(), &[1, 2, 3])
 }
 
 #[tokio::test]

data/bridge/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,