@temporalio/core-bridge 0.23.0 → 1.0.0

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

@@ -1,8 +1,9 @@
 use crate::{
     test_help::{
-        canned_histories, hist_to_poll_resp, mock_worker, MocksHolder, ResponseType, TEST_Q,
+        build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, single_hist_mock_sg,
+        MockPollCfg, ResponseType, TEST_Q,
     },
-    worker::client::mocks::mock_workflow_client,
+    worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
 };
 use std::{
     collections::{HashMap, VecDeque},
@@ -26,8 +27,7 @@ use temporal_sdk_core_protos::{
         history::v1::History,
         query::v1::WorkflowQuery,
         workflowservice::v1::{
-            GetWorkflowExecutionHistoryResponse, RespondQueryTaskCompletedResponse,
-            RespondWorkflowTaskCompletedResponse,
+            GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
 };
@@ -43,7 +43,7 @@ async fn legacy_query(#[case] include_history: bool) {
     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![
+    let tasks = [
         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());
@@ -58,17 +58,10 @@ async fn legacy_query(#[case] include_history: bool) {
             pr
         },
         hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()),
-    ]);
-    let mut mock_client = mock_workflow_client();
-    mock_client
-        .expect_complete_workflow_task()
-        .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
-    mock_client
-        .expect_respond_legacy_query()
-        .times(1)
-        .returning(move |_, _| Ok(RespondQueryTaskCompletedResponse::default()));
-
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    ];
+    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);
     }
@@ -186,12 +179,8 @@ async fn new_queries(#[case] num_queries: usize) {
         },
     ]);
     let mut mock_client = mock_workflow_client();
-    mock_client
-        .expect_complete_workflow_task()
-        .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
     mock_client.expect_respond_legacy_query().times(0);
-
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    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);
 
@@ -260,18 +249,10 @@ async fn legacy_query_failure_on_wft_failure() {
             pr.history = Some(History { events: vec![] });
             pr
         },
-        hist_to_poll_resp(&t, wfid.to_owned(), 2.into(), TEST_Q.to_string()),
     ]);
-    let mut mock_client = mock_workflow_client();
-    mock_client
-        .expect_complete_workflow_task()
-        .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
-    mock_client
-        .expect_respond_legacy_query()
-        .times(1)
-        .returning(move |_, _| Ok(RespondQueryTaskCompletedResponse::default()));
-
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    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);
 
@@ -305,6 +286,64 @@ async fn legacy_query_failure_on_wft_failure() {
     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,
+            TEST_Q.to_string(),
+        );
+        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) {
@@ -328,28 +367,29 @@ async fn legacy_query_after_complete(#[values(false, true)] full_history: bool)
             query_args: Some(b"hi".into()),
             header: None,
         });
-        pr
+        pr.resp
     };
-    let tasks = VecDeque::from(vec![
-        hist_to_poll_resp(
-            &t,
-            wfid.to_owned(),
-            ResponseType::AllHistory,
-            TEST_Q.to_string(),
-        ),
-        query_with_hist_task.clone(),
-        query_with_hist_task,
-    ]);
-    let mut mock_client = mock_workflow_client();
-    mock_client
-        .expect_complete_workflow_task()
-        .returning(|_| Ok(RespondWorkflowTaskCompletedResponse::default()));
-    mock_client
-        .expect_respond_legacy_query()
-        .times(2)
-        .returning(move |_, _| Ok(RespondQueryTaskCompletedResponse::default()));
+    // 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,
+                TEST_Q.to_string(),
+            )
+            .resp,
+        ]
+    };
+    tasks.extend([query_with_hist_task.clone(), query_with_hist_task]);
 
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    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);
 
@@ -474,7 +514,7 @@ async fn query_cache_miss_causes_page_fetch_dont_reply_wft_too_early(
             Ok(RespondWorkflowTaskCompletedResponse::default())
         });
 
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    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();
@@ -568,7 +608,7 @@ async fn query_replay_with_continue_as_new_doesnt_reply_empty_command() {
             Ok(RespondWorkflowTaskCompletedResponse::default())
         });
 
-    let mut mock = MocksHolder::from_client_with_responses(mock_client, tasks, vec![]);
+    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);
 
@@ -634,17 +674,63 @@ async fn query_replay_with_continue_as_new_doesnt_reply_empty_command() {
     .await
     .unwrap();
 
-    // Need to complete the eviction to finally send commands and finish
+    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(), TEST_Q.to_string());
+        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::RemoveFromCache(_))
-        }]
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+        }] => q
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-        .await
-        .unwrap();
+    // 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;
 }

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

@@ -1,4 +1,4 @@
-use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
+use crate::{test_help::canned_histories, worker::ManagedWFFunc};
 use rstest::{fixture, rstest};
 use std::time::Duration;
 use temporal_sdk::{WfContext, WorkflowFunction};

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

@@ -1,7 +1,7 @@
 use crate::{
     test_help::{
         build_fake_worker, build_mock_pollers, canned_histories, mock_manual_poller, mock_worker,
-        MockPollCfg, MockWorker, MocksHolder,
+        MockPollCfg, MockWorkerInputs, MocksHolder,
     },
     worker::client::mocks::mock_workflow_client,
     PollActivityError, PollWfError,
@@ -40,16 +40,8 @@ async fn after_shutdown_of_worker_get_shutdown_err() {
             ))
             .await
             .unwrap();
-        // Since non-sticky, one more activation for eviction
-        let res = worker.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            res.jobs[0].variant,
-            Some(workflow_activation_job::Variant::RemoveFromCache(_))
-        );
-        worker
-            .complete_workflow_activation(WorkflowActivationCompletion::empty(run_id.clone()))
-            .await
-            .unwrap();
+
+        // Shutdown proceeds if the only outstanding activations are evictions
         assert_matches!(
             worker.poll_workflow_activation().await.unwrap_err(),
             PollWfError::ShutDown
@@ -83,9 +75,7 @@ async fn shutdown_worker_can_complete_pending_activation() {
             ))
             .await
             .unwrap();
-        // Since non-sticky, one more activation for eviction
-        worker.poll_workflow_activation().await.unwrap();
-        // Now it's shut down
+        // Shutdown proceeds if the only outstanding activations are evictions
         assert_matches!(
             worker.poll_workflow_activation().await.unwrap_err(),
             PollWfError::ShutDown
@@ -109,7 +99,7 @@ async fn worker_shutdown_during_poll_doesnt_deadlock() {
         }
         .boxed()
     });
-    let mw = MockWorker::new(Box::new(mock_poller));
+    let mw = MockWorkerInputs::new_from_poller(Box::new(mock_poller));
     let mut mock_client = mock_workflow_client();
     mock_client
         .expect_complete_workflow_task()
@@ -182,16 +172,11 @@ async fn complete_with_task_not_found_during_shutdown() {
         complete_order.borrow_mut().push(3);
     };
     let poll_fut = async {
-        // This should *not* return shutdown, but instead should do nothing until the complete
-        // goes through, at which point it will return the eviction.
-        let res = core.poll_workflow_activation().await.unwrap();
+        // This will return shutdown once the completion goes through
         assert_matches!(
-            res.jobs[0].variant,
-            Some(workflow_activation_job::Variant::RemoveFromCache(_))
+            core.poll_workflow_activation().await.unwrap_err(),
+            PollWfError::ShutDown
         );
-        core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
-            .await
-            .unwrap();
         complete_order.borrow_mut().push(2);
     };
     let complete_fut = async {
@@ -208,3 +193,34 @@ async fn complete_with_task_not_found_during_shutdown() {
     // 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])
 }
+
+#[tokio::test]
+async fn complete_eviction_after_shutdown_doesnt_panic() {
+    let t = canned_histories::single_timer("1");
+    let mut mh = build_mock_pollers(MockPollCfg::from_resp_batches(
+        "fakeid",
+        t,
+        [1],
+        mock_workflow_client(),
+    ));
+    mh.make_wft_stream_interminable();
+    let core = mock_worker(mh);
+
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(res.jobs.len(), 1);
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        res.run_id,
+        vec![start_timer_cmd(1, Duration::from_secs(1))],
+    ))
+    .await
+    .unwrap();
+    let res = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        res.jobs[0].variant,
+        Some(workflow_activation_job::Variant::RemoveFromCache(_))
+    );
+    core.shutdown().await;
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
+        .await
+        .unwrap();
+}

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

@@ -2,8 +2,8 @@ use crate::{
     job_assert,
     test_help::{
         build_fake_worker, canned_histories, gen_assert_and_reply, poll_and_reply, ResponseType,
+        WorkflowCachingPolicy::NonSticky,
     },
-    workflow::WorkflowCachingPolicy::NonSticky,
 };
 use rstest::rstest;
 use std::time::Duration;