@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/src/core_tests/activity_tasks.rs

@@ -1,7 +1,7 @@
 use crate::{
     ActivityHeartbeat, Worker, advance_fut, job_assert, prost_dur,
     test_help::{
-        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, TEST_Q, WorkerExt,
+        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, WorkerExt,
         WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, fanout_tasks,
         gen_assert_and_reply, mock_manual_poller, mock_poller, mock_worker, poll_and_reply,
         single_hist_mock_sg, test_worker_cfg,
@@ -21,35 +21,39 @@ use std::{
     },
     time::{Duration, Instant},
 };
-use temporal_sdk_core_api::{
-    Worker as WorkerTrait, errors::CompleteActivityError, worker::PollerBehavior,
-};
-use temporal_sdk_core_protos::{
-    TestHistoryBuilder, canned_histories,
-    coresdk::{
-        ActivityTaskCompletion,
-        activity_result::{
-            ActivityExecutionResult, ActivityResolution, Success, activity_execution_result,
-            activity_resolution,
-        },
-        activity_task::{ActivityCancelReason, ActivityTask, Cancel, activity_task},
-        workflow_activation::{ResolveActivity, WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            ActivityCancellationType, CompleteWorkflowExecution, RequestCancelActivity,
-            ScheduleActivity,
+use temporalio_common::{
+    Worker as WorkerTrait,
+    errors::CompleteActivityError,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            ActivityTaskCompletion,
+            activity_result::{
+                ActivityExecutionResult, ActivityResolution, Success, activity_execution_result,
+                activity_resolution,
+            },
+            activity_task::{ActivityCancelReason, ActivityTask, Cancel, activity_task},
+            workflow_activation::{
+                ResolveActivity, WorkflowActivationJob, workflow_activation_job,
+            },
+            workflow_commands::{
+                ActivityCancellationType, CompleteWorkflowExecution, RequestCancelActivity,
+                ScheduleActivity,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes},
-        enums::v1::EventType,
-        workflowservice::v1::{
-            PollActivityTaskQueueResponse, RecordActivityTaskHeartbeatResponse,
-            RespondActivityTaskCanceledResponse, RespondActivityTaskCompletedResponse,
-            RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse,
+        temporal::api::{
+            command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes},
+            enums::v1::EventType,
+            workflowservice::v1::{
+                PollActivityTaskQueueResponse, RecordActivityTaskHeartbeatResponse,
+                RespondActivityTaskCanceledResponse, RespondActivityTaskCompletedResponse,
+                RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse,
+            },
         },
+        test_utils::start_timer_cmd,
     },
-    test_utils::start_timer_cmd,
+    worker::{PollerBehavior, WorkerTaskTypes},
 };
 use tokio::{join, time::sleep};
 use tokio_util::sync::CancellationToken;
@@ -721,7 +725,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
     mock.worker_cfg(|wc| {
         wc.max_cached_workflows = 2;
         if reason == "no_remote" {
-            wc.no_remote_activities = true;
+            wc.task_types = WorkerTaskTypes::workflow_only();
         } else {
             wc.max_task_queue_activities_per_second = Some(1.0);
         }
@@ -734,7 +738,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
         ScheduleActivity {
             seq: 1,
             activity_id: "act_id".to_string(),
-            task_queue: TEST_Q.to_string(),
+            task_queue: core.get_config().task_queue.clone(),
             cancellation_type: ActivityCancellationType::TryCancel as i32,
             ..Default::default()
         }
@@ -821,6 +825,7 @@ async fn activity_tasks_from_completion_are_delivered() {
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
+    let task_queue = core.get_config().task_queue.clone();
 
     // Test start
     let wf_task = core.poll_workflow_activation().await.unwrap();
@@ -829,7 +834,7 @@ async fn activity_tasks_from_completion_are_delivered() {
             ScheduleActivity {
                 seq,
                 activity_id: format!("act_id_{seq}_same_queue"),
-                task_queue: TEST_Q.to_string(),
+                task_queue: task_queue.clone(),
                 cancellation_type: ActivityCancellationType::TryCancel as i32,
                 ..Default::default()
             }
@@ -840,7 +845,7 @@ async fn activity_tasks_from_completion_are_delivered() {
         ScheduleActivity {
             seq: 4,
             activity_id: "act_id_same_queue_not_eager".to_string(),
-            task_queue: TEST_Q.to_string(),
+            task_queue: task_queue.clone(),
             cancellation_type: ActivityCancellationType::TryCancel as i32,
             ..Default::default()
         }

package/sdk-core/{core → crates/sdk-core}/src/core_tests/mod.rs

@@ -16,16 +16,19 @@ use crate::{
 };
 use futures_util::FutureExt;
 use std::{sync::LazyLock, time::Duration};
-use temporal_sdk_core_api::{Worker as WorkerTrait, worker::PollerBehavior};
-use temporal_sdk_core_protos::{
-    TestHistoryBuilder, canned_histories,
-    coresdk::{
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        enums::v1::EventType, history::v1::WorkflowExecutionOptionsUpdatedEventAttributes,
+use temporalio_common::{
+    Worker as WorkerTrait,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            enums::v1::EventType, history::v1::WorkflowExecutionOptionsUpdatedEventAttributes,
+        },
     },
+    worker::PollerBehavior,
 };
 use tokio::{sync::Barrier, time::sleep};
 

package/sdk-core/{core → crates/sdk-core}/src/core_tests/queries.rs

@@ -13,30 +13,33 @@ use std::{
     collections::{HashMap, VecDeque},
     time::Duration,
 };
-use temporal_sdk_core_api::{Worker as WorkerTrait, worker::WorkerVersioningStrategy};
-use temporal_sdk_core_protos::{
-    TestHistoryBuilder, canned_histories,
-    coresdk::{
-        workflow_activation::{
-            WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
-        },
-        workflow_commands::{
-            ActivityCancellationType, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution,
-            QueryResult, RequestCancelActivity, query_result,
+use temporalio_common::{
+    Worker as WorkerTrait,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_activation::{
+                WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
+            },
+            workflow_commands::{
+                ActivityCancellationType, CompleteWorkflowExecution,
+                ContinueAsNewWorkflowExecution, QueryResult, RequestCancelActivity, query_result,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        common::v1::Payload,
-        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
-        failure::v1::Failure,
-        history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event},
-        query::v1::WorkflowQuery,
-        workflowservice::v1::{
-            GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
+        temporal::api::{
+            common::v1::Payload,
+            enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
+            failure::v1::Failure,
+            history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event},
+            query::v1::WorkflowQuery,
+            workflowservice::v1::{
+                GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
+            },
         },
+        test_utils::{query_ok, schedule_activity_cmd, start_timer_cmd},
     },
-    test_utils::{query_ok, schedule_activity_cmd, start_timer_cmd},
+    worker::WorkerVersioningStrategy,
 };
 
 #[rstest::rstest]

package/sdk-core/{core → crates/sdk-core}/src/core_tests/replay_flag.rs

@@ -3,15 +3,17 @@ use crate::{
     worker::{LEGACY_QUERY_ID, client::mocks::mock_worker_client},
 };
 use std::{collections::VecDeque, time::Duration};
-use temporal_sdk_core_api::Worker as CoreWorker;
-use temporal_sdk_core_protos::{
-    TestHistoryBuilder, canned_histories,
-    coresdk::{
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_completion::WorkflowActivationCompletion,
+use temporalio_common::{
+    Worker as CoreWorker,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery},
+        test_utils::{query_ok, start_timer_cmd},
     },
-    temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery},
-    test_utils::{query_ok, start_timer_cmd},
 };
 
 #[tokio::test]

package/sdk-core/{core → crates/sdk-core}/src/core_tests/updates.rs

@@ -6,22 +6,24 @@ use crate::{
     },
     worker::client::mocks::mock_worker_client,
 };
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder,
-    coresdk::{
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            CompleteWorkflowExecution, ScheduleActivity, StartTimer, UpdateResponse,
-            update_response::Response,
+use temporalio_common::{
+    Worker,
+    protos::{
+        DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder,
+        coresdk::{
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{
+                CompleteWorkflowExecution, ScheduleActivity, StartTimer, UpdateResponse,
+                update_response::Response,
+            },
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::Payload,
+            enums::v1::EventType,
+            update::v1::{Acceptance, Rejection},
+            workflowservice::v1::RespondWorkflowTaskCompletedResponse,
         },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        common::v1::Payload,
-        enums::v1::EventType,
-        update::v1::{Acceptance, Rejection},
-        workflowservice::v1::RespondWorkflowTaskCompletedResponse,
     },
 };
 

package/sdk-core/{core → crates/sdk-core}/src/core_tests/workers.rs

@@ -1,8 +1,8 @@
 use crate::{
     PollError, prost_dur,
     test_help::{
-        MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt, WorkerTestHelpers,
-        build_fake_worker, build_mock_pollers, mock_worker, test_worker_cfg,
+        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, ResponseType, WorkerExt,
+        WorkerTestHelpers, build_fake_worker, build_mock_pollers, mock_worker, test_worker_cfg,
     },
     worker::{
         self,
@@ -14,18 +14,34 @@ use crate::{
 };
 use futures_util::{stream, stream::StreamExt};
 use std::{cell::RefCell, time::Duration};
-use temporal_sdk_core_api::{Worker, worker::PollerBehavior};
-use temporal_sdk_core_protos::{
-    canned_histories,
-    coresdk::{
-        workflow_activation::workflow_activation_job,
-        workflow_commands::{CompleteWorkflowExecution, StartTimer, workflow_command},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::workflowservice::v1::{
-        PollWorkflowTaskQueueResponse, RespondWorkflowTaskCompletedResponse, ShutdownWorkerResponse,
+use temporalio_common::{
+    Worker,
+    protos::{
+        canned_histories,
+        coresdk::{
+            ActivityTaskCompletion,
+            activity_result::ActivityExecutionResult,
+            nexus::NexusTaskCompletion,
+            workflow_activation::workflow_activation_job,
+            workflow_commands::{CompleteWorkflowExecution, StartTimer, workflow_command},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::{ActivityType, WorkflowExecution},
+            nexus::v1::{
+                Request as NexusRequest, Response as NexusResponse, StartOperationRequest,
+                StartOperationResponse, start_operation_response,
+            },
+            workflowservice::v1::{
+                PollActivityTaskQueueResponse, PollNexusTaskQueueResponse,
+                PollWorkflowTaskQueueResponse, RespondActivityTaskCompletedResponse,
+                RespondNexusTaskCompletedResponse, RespondWorkflowTaskCompletedResponse,
+                ShutdownWorkerResponse,
+            },
+        },
+        test_utils::start_timer_cmd,
     },
-    test_utils::start_timer_cmd,
+    worker::{PollerBehavior, WorkerTaskTypes},
 };
 use tokio::sync::{Barrier, watch};
 
@@ -131,7 +147,7 @@ async fn can_shutdown_local_act_only_worker_when_act_polling() {
     let mh = MockPollCfg::from_resp_batches("fakeid", t, [1], mock);
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|w| {
-        w.no_remote_activities = true;
+        w.task_types = WorkerTaskTypes::workflow_only();
         w.max_cached_workflows = 1;
     });
     let worker = mock_worker(mock);
@@ -315,18 +331,18 @@ async fn worker_shutdown_api(#[case] use_cache: bool, #[case] api_success: bool)
     mock.expect_is_mock().returning(|| true);
     mock.expect_sdk_name_and_version()
         .returning(|| ("test-core".to_string(), "0.0.0".to_string()));
-    mock.expect_get_identity()
+    mock.expect_identity()
         .returning(|| "test-identity".to_string());
     if use_cache {
         if api_success {
             mock.expect_shutdown_worker()
                 .times(1)
-                .returning(|_| Ok(ShutdownWorkerResponse {}));
+                .returning(|_, _| Ok(ShutdownWorkerResponse {}));
         } else {
             // worker.shutdown() should succeed even if shutdown_worker fails
             mock.expect_shutdown_worker()
                 .times(1)
-                .returning(|_| Err(tonic::Status::unavailable("fake shutdown error")));
+                .returning(|_, _| Err(tonic::Status::unavailable("fake shutdown error")));
         }
     } else {
         mock.expect_shutdown_worker().times(0);
@@ -364,3 +380,212 @@ async fn worker_shutdown_api(#[case] use_cache: bool, #[case] api_success: bool)
         );
     });
 }
+
+fn create_test_activity_task() -> PollActivityTaskQueueResponse {
+    PollActivityTaskQueueResponse {
+        task_token: b"act-task".to_vec(),
+        workflow_execution: Some(WorkflowExecution {
+            workflow_id: "test".to_string(),
+            run_id: "run-id".to_string(),
+        }),
+        activity_id: "activity".to_string(),
+        activity_type: Some(ActivityType {
+            name: "activity".to_string(),
+        }),
+        ..Default::default()
+    }
+}
+
+fn create_test_nexus_task() -> PollNexusTaskQueueResponse {
+    PollNexusTaskQueueResponse {
+        task_token: b"nex-task".to_vec(),
+        request: Some(NexusRequest {
+            header: Default::default(),
+            scheduled_time: None,
+            variant: Some(temporalio_common::protos::temporal::api::nexus::v1::request::Variant::StartOperation(
+                StartOperationRequest {
+                    service: "test-service".to_string(),
+                    operation: "test-operation".to_string(),
+                    request_id: "test-request-id".to_string(),
+                    callback: "".to_string(),
+                    payload: None,
+                    callback_header: Default::default(),
+                    links: vec![],
+                }
+            )),
+        }),
+        poller_scaling_decision: None,
+    }
+}
+
+fn create_test_nexus_completion(task_token: &[u8]) -> NexusTaskCompletion {
+    NexusTaskCompletion {
+        task_token: task_token.to_vec(),
+        status: Some(temporalio_common::protos::coresdk::nexus::nexus_task_completion::Status::Completed(
+            NexusResponse {
+                variant: Some(temporalio_common::protos::temporal::api::nexus::v1::response::Variant::StartOperation(
+                    StartOperationResponse {
+                        variant: Some(start_operation_response::Variant::SyncSuccess(
+                            start_operation_response::Sync {
+                                payload: None,
+                                links: vec![],
+                            }
+                        )),
+                    }
+                )),
+            }
+        )),
+    }
+}
+
+#[rstest::rstest]
+// With tasks
+#[case::activity_only_with_task(false, false, true, false, true, "activity-only")]
+#[case::nexus_only_with_task(false, false, false, true, true, "nexus-only")]
+#[case::workflow_only_with_task(true, false, false, false, true, "workflow-only")]
+#[case::workflow_and_activity_with_task(true, true, true, false, true, "workflow-activity")]
+#[case::workflow_and_local_activity_with_task(
+    true,
+    true,
+    false,
+    false,
+    true,
+    "workflow-local-activity"
+)]
+#[case::workflow_and_nexus_with_task(true, false, false, true, true, "workflow-nexus")]
+#[case::activity_and_nexus_with_task(false, false, true, true, true, "activity-nexus")]
+// Without tasks (idle worker shutdown)
+#[case::activity_only_idle(false, false, true, false, false, "activity-only-idle")]
+#[case::nexus_only_idle(false, false, false, true, false, "nexus-only-idle")]
+#[case::workflow_only_idle(true, false, false, false, false, "workflow-only-idle")]
+#[case::workflow_and_activity_idle(true, true, true, false, false, "workflow-activity-idle")]
+#[case::workflow_and_local_activity_idle(
+    true,
+    true,
+    false,
+    false,
+    false,
+    "workflow-local-activity-idle"
+)]
+#[case::workflow_and_nexus_idle(true, false, false, true, false, "workflow-nexus-idle")]
+#[case::activity_and_nexus_idle(false, false, true, true, false, "activity-nexus-idle")]
+#[tokio::test]
+async fn test_task_type_combinations_unified(
+    #[case] enable_workflows: bool,
+    #[case] enable_local_activities: bool,
+    #[case] enable_remote_activities: bool,
+    #[case] enable_nexus: bool,
+    #[case] with_task: bool,
+    #[case] queue_name: &str,
+) {
+    let mut client = mock_worker_client();
+
+    if with_task {
+        if enable_local_activities || enable_remote_activities {
+            client
+                .expect_complete_activity_task()
+                .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
+        }
+        if enable_nexus {
+            client
+                .expect_complete_nexus_task()
+                .returning(|_, _| Ok(RespondNexusTaskCompletedResponse::default()));
+        }
+    }
+
+    let mut mocks = if enable_workflows && with_task {
+        let t = canned_histories::single_timer(queue_name);
+        let wf_cfg = MockPollCfg::from_resp_batches(queue_name, t, [1], client);
+        let mut mocks = build_mock_pollers(wf_cfg);
+        if enable_remote_activities {
+            mocks.set_act_poller_from_resps(vec![QueueResponse::from(create_test_activity_task())]);
+        }
+        if enable_nexus {
+            mocks.set_nexus_poller_from_resps(vec![QueueResponse::from(create_test_nexus_task())]);
+        }
+        mocks
+    } else {
+        let wft_stream = if enable_workflows {
+            Some(stream::empty())
+        } else {
+            None
+        };
+        let activity_tasks = if enable_remote_activities && with_task {
+            Some(vec![QueueResponse::from(create_test_activity_task())])
+        } else {
+            None
+        };
+        let nexus_tasks = if enable_nexus && with_task {
+            Some(vec![QueueResponse::from(create_test_nexus_task())])
+        } else {
+            None
+        };
+        MocksHolder::from_client_with_custom(client, wft_stream, activity_tasks, nexus_tasks)
+    };
+
+    mocks.worker_cfg(|w| {
+        w.task_queue = queue_name.to_string();
+        w.task_types = WorkerTaskTypes {
+            enable_workflows,
+            enable_local_activities,
+            enable_remote_activities,
+            enable_nexus,
+        };
+        w.skip_client_worker_set_check = true;
+    });
+    let worker = mock_worker(mocks);
+
+    if with_task {
+        if enable_workflows {
+            let activation = worker.poll_workflow_activation().await.unwrap();
+            worker
+                .complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+                    activation.run_id.clone(),
+                    vec![CompleteWorkflowExecution::default().into()],
+                ))
+                .await
+                .unwrap();
+        }
+
+        if enable_remote_activities {
+            let activity_task = worker.poll_activity_task().await.unwrap();
+            worker
+                .complete_activity_task(ActivityTaskCompletion {
+                    task_token: activity_task.task_token,
+                    result: Some(ActivityExecutionResult::ok(vec![1].into())),
+                })
+                .await
+                .unwrap();
+        }
+
+        if enable_nexus {
+            let nexus_task = worker.poll_nexus_task().await.unwrap();
+            worker
+                .complete_nexus_task(create_test_nexus_completion(nexus_task.task_token()))
+                .await
+                .unwrap();
+        }
+    }
+
+    worker.initiate_shutdown();
+    if enable_workflows {
+        assert_matches!(
+            worker.poll_workflow_activation().await.unwrap_err(),
+            PollError::ShutDown
+        );
+    }
+    if enable_local_activities || enable_remote_activities {
+        assert_matches!(
+            worker.poll_activity_task().await.unwrap_err(),
+            PollError::ShutDown
+        );
+    }
+    if enable_nexus {
+        assert_matches!(
+            worker.poll_nexus_task().await.unwrap_err(),
+            PollError::ShutDown
+        );
+    }
+    worker.shutdown().await;
+    worker.finalize_shutdown().await;
+}

package/sdk-core/{core → crates/sdk-core}/src/core_tests/workflow_cancels.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use rstest::rstest;
 use std::time::Duration;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     canned_histories,
     coresdk::{
         workflow_activation::{WorkflowActivationJob, workflow_activation_job},