@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/worker_tests.rs

@@ -1,5 +1,8 @@
 use crate::{
-    common::{CoreWfStarter, get_integ_server_options, get_integ_telem_options, mock_sdk_cfg},
+    common::{
+        CoreWfStarter, fake_grpc_server::fake_server, get_integ_runtime_options,
+        get_integ_server_options, get_integ_telem_options, mock_sdk_cfg,
+    },
     shared_tests,
 };
 use assert_matches::assert_matches;
@@ -8,56 +11,60 @@ use std::{
     cell::Cell,
     sync::{
         Arc, Mutex,
-        atomic::{AtomicBool, Ordering::Relaxed},
+        atomic::{
+            AtomicBool, AtomicU8,
+            Ordering::{self, Relaxed},
+        },
     },
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{
-    ActivityOptions, LocalActivityOptions, WfContext, interceptors::WorkerInterceptor,
-};
-use temporal_sdk_core::{
-    CoreRuntime, ResourceBasedTuner, ResourceSlotOptions, TunerBuilder, init_worker,
-    test_help::{
-        FakeWfResponses, MockPollCfg, ResponseType, TEST_Q, build_mock_pollers,
-        drain_pollers_and_shutdown, hist_to_poll_resp, mock_worker, mock_worker_client,
-    },
-};
-use temporal_sdk_core_api::{
+use temporalio_client::WorkflowOptions;
+use temporalio_common::{
     Worker,
     errors::WorkerValidationError,
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
+        coresdk::{
+            ActivityTaskCompletion,
+            activity_result::ActivityExecutionResult,
+            workflow_completion::{
+                Failure, WorkflowActivationCompletion, workflow_activation_completion::Status,
+            },
+        },
+        temporal::api::{
+            command::v1::command::Attributes,
+            common::v1::WorkerVersionStamp,
+            enums::v1::{
+                EventType, WorkflowTaskFailedCause, WorkflowTaskFailedCause::GrpcMessageTooLarge,
+            },
+            failure::v1::Failure as InnerFailure,
+            history::v1::{
+                ActivityTaskScheduledEventAttributes, history_event,
+                history_event::Attributes::{
+                    self as EventAttributes, WorkflowTaskFailedEventAttributes,
+                },
+            },
+            workflowservice::v1::{
+                GetWorkflowExecutionHistoryResponse, PollActivityTaskQueueResponse,
+                RespondActivityTaskCompletedResponse,
+            },
+        },
+    },
     worker::{
         ActivitySlotKind, LocalActivitySlotKind, PollerBehavior, SlotInfo, SlotInfoTrait,
         SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
-        SlotSupplierPermit, WorkerConfigBuilder, WorkerVersioningStrategy, WorkflowSlotKind,
+        SlotSupplierPermit, WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy,
+        WorkflowSlotKind,
     },
 };
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
-    coresdk::{
-        ActivityTaskCompletion,
-        activity_result::ActivityExecutionResult,
-        workflow_completion::{
-            Failure, WorkflowActivationCompletion, workflow_activation_completion::Status,
-        },
-    },
-    temporal::api::{
-        command::v1::command::Attributes,
-        common::v1::WorkerVersionStamp,
-        enums::v1::{
-            EventType, WorkflowTaskFailedCause, WorkflowTaskFailedCause::GrpcMessageTooLarge,
-        },
-        failure::v1::Failure as InnerFailure,
-        history::v1::{
-            ActivityTaskScheduledEventAttributes, history_event,
-            history_event::Attributes::{
-                self as EventAttributes, WorkflowTaskFailedEventAttributes,
-            },
-        },
-        workflowservice::v1::{
-            GetWorkflowExecutionHistoryResponse, PollActivityTaskQueueResponse,
-            RespondActivityTaskCompletedResponse,
-        },
+use temporalio_sdk::{
+    ActivityOptions, LocalActivityOptions, WfContext, interceptors::WorkerInterceptor,
+};
+use temporalio_sdk_core::{
+    CoreRuntime, ResourceBasedTuner, ResourceSlotOptions, TunerBuilder, init_worker,
+    test_help::{
+        FakeWfResponses, MockPollCfg, ResponseType, build_mock_pollers, drain_pollers_and_shutdown,
+        hist_to_poll_resp, mock_worker, mock_worker_client,
     },
 };
 use tokio::sync::{Barrier, Notify, Semaphore};
@@ -67,7 +74,9 @@ use uuid::Uuid;
 #[tokio::test]
 async fn worker_validation_fails_on_nonexistent_namespace() {
     let opts = get_integ_server_options();
-    let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
+    let runtime =
+        CoreRuntime::new_assume_tokio(get_integ_runtime_options(get_integ_telem_options()))
+            .unwrap();
     let retrying_client = opts
         .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter())
         .await
@@ -81,6 +90,7 @@ async fn worker_validation_fails_on_nonexistent_namespace() {
             .versioning_strategy(WorkerVersioningStrategy::None {
                 build_id: "blah".to_owned(),
             })
+            .task_types(WorkerTaskTypes::all())
             .build()
             .unwrap(),
         retrying_client,
@@ -145,7 +155,7 @@ async fn worker_handles_unknown_workflow_types_gracefully() {
                 self.notify.notify_one();
             }
         }
-        fn on_shutdown(&self, _: &temporal_sdk::Worker) {}
+        fn on_shutdown(&self, _: &temporalio_sdk::Worker) {}
     }
 
     let inner = worker.inner_mut();
@@ -169,7 +179,7 @@ async fn resource_based_few_pollers_guarantees_non_sticky_poll() {
     starter
         .worker_config
         .clear_max_outstanding_opts()
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         // 3 pollers so the minimum slots of 2 can both be handed out to a sticky poller
         .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(3_usize));
     // Set the limits to zero so it's essentially unwilling to hand out slots
@@ -200,9 +210,15 @@ async fn resource_based_few_pollers_guarantees_non_sticky_poll() {
 
 #[tokio::test]
 async fn oversize_grpc_message() {
+    use crate::common::{NAMESPACE, prom_metrics};
     let wf_name = "oversize_grpc_message";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    // Enable Prometheus metrics for this test and capture the address
+    let (telemopts, addr, _aborter) = prom_metrics(None);
+    let runtime = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
+    let mut starter = CoreWfStarter::new_with_runtime(wf_name, runtime);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut core = starter.worker().await;
 
     static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);
@@ -226,7 +242,25 @@ async fn oversize_grpc_message() {
             } else {
                 false
             }
-    }))
+    }));
+
+    // Verify the workflow task failure metric includes the GrpcMessageTooLarge reason
+    let tq = starter.get_task_queue();
+    crate::common::eventually(
+        || async {
+            let body = crate::integ_tests::metrics_tests::get_text(format!("http://{addr}/metrics")).await;
+            if body.contains(&format!(
+                "temporal_workflow_task_execution_failed{{failure_reason=\"GrpcMessageTooLarge\",namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",task_queue=\"{tq}\"}} 1"
+            )) {
+                Ok(())
+            } else {
+                Err(())
+            }
+        },
+        Duration::from_secs(2),
+    )
+    .await
+    .unwrap();
 }
 
 #[tokio::test]
@@ -324,7 +358,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
         cfg.max_outstanding_activities = Some(2);
     });
     let core = Arc::new(mock_worker(mock));
-    let mut worker = crate::common::TestWorker::new(core.clone(), TEST_Q.to_string());
+    let mut worker = crate::common::TestWorker::new(core.clone());
 
     // First poll for activities twice, occupying both slots
     let at1 = core.poll_activity_task().await.unwrap();
@@ -380,7 +414,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
         core.initiate_shutdown();
         // Even though this test requests eager activity tasks, none are returned in poll responses.
         let err = core.poll_activity_task().await.unwrap_err();
-        assert_matches!(err, temporal_sdk_core_api::errors::PollError::ShutDown);
+        assert_matches!(err, temporalio_common::errors::PollError::ShutDown);
     };
     // This wf poll should *not* set the flag that it wants tasks back since both slots are
     // occupied
@@ -633,7 +667,7 @@ impl<SK> TrackingSlotSupplier<SK> {
 #[async_trait::async_trait]
 impl<SK> SlotSupplier for TrackingSlotSupplier<SK>
 where
-    SK: temporal_sdk_core_api::worker::SlotKind + Send + Sync,
+    SK: temporalio_common::worker::SlotKind + Send + Sync,
     SK::Info: SlotInfoTrait,
 {
     type SlotKind = SK;
@@ -690,7 +724,7 @@ async fn test_custom_slot_supplier_simple() {
 
     worker.register_activity(
         "SlotSupplierActivity",
-        |_: temporal_sdk::ActContext, _: ()| async move { Ok(()) },
+        |_: temporalio_sdk::ActContext, _: ()| async move { Ok(()) },
     );
     worker.register_wf(
         "SlotSupplierWorkflow".to_owned(),
@@ -856,3 +890,31 @@ async fn test_custom_slot_supplier_simple() {
         "Number of reserves should equal number of releases"
     );
 }
+
+#[tokio::test]
+async fn shutdown_worker_not_retried() {
+    let shutdown_call_count = Arc::new(AtomicU8::new(0));
+    let scc = shutdown_call_count.clone();
+    let fs = fake_server(move |req| {
+        if req.uri().to_string().contains("ShutdownWorker") {
+            scc.fetch_add(1, Ordering::Relaxed);
+        }
+        let s = tonic::Status::new(tonic::Code::Unknown, "bla").into_http();
+        async { s }.boxed()
+    })
+    .await;
+
+    let mut opts = get_integ_server_options();
+    let uri = format!("http://localhost:{}", fs.addr.port())
+        .parse()
+        .unwrap();
+    opts.target_url = uri;
+    opts.skip_get_system_info = true;
+    let client = opts.connect("ns", None).await.unwrap();
+
+    let wf_type = "shutdown_worker_not_retried";
+    let mut starter = CoreWfStarter::new_with_overrides(wf_type, None, Some(client));
+    let worker = starter.get_worker().await;
+    drain_pollers_and_shutdown(&worker).await;
+    assert_eq!(shutdown_call_count.load(Ordering::Relaxed), 1);
+}

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/worker_versioning_tests.rs

@@ -3,25 +3,27 @@ use crate::{
     integ_tests::activity_functions::echo,
 };
 use std::time::Duration;
-use temporal_client::{NamespacedClient, WorkflowOptions, WorkflowService};
-use temporal_sdk::{ActivityOptions, WfContext};
-use temporal_sdk_core::test_help::WorkerTestHelpers;
-use temporal_sdk_core_api::worker::{
-    WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerVersioningStrategy,
-};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        AsJsonPayloadExt, workflow_commands::CompleteWorkflowExecution, workflow_completion,
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        enums::v1::VersioningBehavior,
-        history::v1::history_event::Attributes,
-        workflowservice::v1::{
-            DescribeWorkerDeploymentRequest, SetWorkerDeploymentCurrentVersionRequest,
+use temporalio_client::{NamespacedClient, WorkflowOptions, WorkflowService};
+use temporalio_common::{
+    protos::{
+        coresdk::{
+            AsJsonPayloadExt, workflow_commands::CompleteWorkflowExecution, workflow_completion,
+            workflow_completion::WorkflowActivationCompletion,
         },
+        temporal::api::{
+            enums::v1::VersioningBehavior,
+            history::v1::history_event::Attributes,
+            workflowservice::v1::{
+                DescribeWorkerDeploymentRequest, SetWorkerDeploymentCurrentVersionRequest,
+            },
+        },
+    },
+    worker::{
+        WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerTaskTypes, WorkerVersioningStrategy,
     },
 };
+use temporalio_sdk::{ActivityOptions, WfContext};
+use temporalio_sdk_core::test_help::WorkerTestHelpers;
 use tokio::join;
 use tonic::IntoRequest;
 
@@ -44,7 +46,7 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
                 default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
             },
         ))
-        .no_remote_activities(true);
+        .task_types(WorkerTaskTypes::workflow_only());
     let core = starter.get_worker().await;
     let client = starter.get_client().await;
 

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/activities.rs

@@ -12,40 +12,45 @@ use std::{
     sync::atomic::{AtomicBool, Ordering},
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
-use temporal_sdk::{
-    ActContext, ActExitValue, ActivityError, ActivityOptions, CancellableFuture, WfContext,
-    WfExitValue, WorkflowFunction, WorkflowResult,
-};
-use temporal_sdk_core::test_help::{
-    MockPollCfg, ResponseType, WorkerTestHelpers, drain_pollers_and_shutdown, mock_worker_client,
+use temporalio_client::{
+    WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions,
 };
-use temporal_sdk_core_api::worker::PollerBehavior;
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TaskToken, TestHistoryBuilder, canned_histories,
-    coresdk::{
-        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
-        IntoCompletion, IntoPayloadsExt,
-        activity_result::{
-            self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
-        },
-        activity_task::activity_task as act_task,
-        workflow_activation::{
-            FireTimer, ResolveActivity, WorkflowActivationJob, workflow_activation_job,
+use temporalio_common::{
+    prost_dur,
+    protos::{
+        DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TaskToken, TestHistoryBuilder,
+        canned_histories,
+        coresdk::{
+            ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
+            IntoCompletion, IntoPayloadsExt,
+            activity_result::{
+                self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
+            },
+            activity_task::activity_task as act_task,
+            workflow_activation::{
+                FireTimer, ResolveActivity, WorkflowActivationJob, workflow_activation_job,
+            },
+            workflow_commands::{
+                ActivityCancellationType, RequestCancelActivity, ScheduleActivity, StartTimer,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_commands::{
-            ActivityCancellationType, RequestCancelActivity, ScheduleActivity, StartTimer,
+        temporal::api::{
+            common::v1::{ActivityType, Payload, Payloads, RetryPolicy},
+            enums::v1::{CommandType, EventType, RetryState},
+            failure::v1::{ActivityFailureInfo, Failure, failure::FailureInfo},
+            sdk::v1::UserMetadata,
         },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    prost_dur,
-    temporal::api::{
-        common::v1::{ActivityType, Payload, Payloads, RetryPolicy},
-        enums::v1::{CommandType, EventType, RetryState},
-        failure::v1::{ActivityFailureInfo, Failure, failure::FailureInfo},
-        sdk::v1::UserMetadata,
+        test_utils::schedule_activity_cmd,
     },
-    test_utils::schedule_activity_cmd,
+    worker::PollerBehavior,
+};
+use temporalio_sdk::{
+    ActContext, ActExitValue, ActivityError, ActivityOptions, CancellableFuture, WfContext,
+    WfExitValue, WorkflowFunction, WorkflowResult,
+};
+use temporalio_sdk_core::test_help::{
+    MockPollCfg, ResponseType, WorkerTestHelpers, drain_pollers_and_shutdown, mock_worker_client,
 };
 use tokio::{join, sync::Semaphore, time::sleep};
 

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/appdata_propagation.rs

@@ -1,9 +1,9 @@
 use crate::common::CoreWfStarter;
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_client::{WfClientExt, WorkflowExecutionResult, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporalio_client::{WfClientExt, WorkflowExecutionResult, WorkflowOptions};
+use temporalio_common::protos::coresdk::AsJsonPayloadExt;
+use temporalio_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
 
 const TEST_APPDATA_MESSAGE: &str = "custom app data, yay";
 

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/cancel_external.rs

@@ -1,12 +1,15 @@
 use crate::common::{CoreWfStarter, build_fake_sdk};
-use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowOptions};
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core::test_help::MockPollCfg;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
-    coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution},
-    temporal::api::enums::v1::{CommandType, EventType},
+use temporalio_client::{GetWorkflowResultOptions, WfClientExt, WorkflowOptions};
+use temporalio_common::{
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+        coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution},
+        temporal::api::enums::v1::{CommandType, EventType},
+    },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{WfContext, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
 
 const RECEIVER_WFID: &str = "sends-cancel-receiver";
 
@@ -39,7 +42,9 @@ async fn cancel_receiver(ctx: WfContext) -> WorkflowResult<String> {
 #[tokio::test]
 async fn sends_cancel_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_cancel_to_other_wf");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf("sender", cancel_sender);
     worker.register_wf("receiver", cancel_receiver);
@@ -68,7 +73,7 @@ async fn sends_cancel_to_other_wf() {
         .await
         .get_untyped_workflow_handle(RECEIVER_WFID, receiver_run_id);
     let res = String::from_json_payload(
-        &h.get_workflow_result(GetWorkflowResultOpts::default())
+        &h.get_workflow_result(GetWorkflowResultOptions::default())
             .await
             .unwrap()
             .unwrap_success()[0],

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/cancel_wf.rs

@@ -1,13 +1,16 @@
 use crate::common::{ActivationAssertionsInterceptor, CoreWfStarter, build_fake_sdk};
 use std::time::Duration;
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core::test_help::MockPollCfg;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, canned_histories,
-    coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-    temporal::api::enums::v1::{CommandType, WorkflowExecutionStatus},
+use temporalio_client::WorkflowClientTrait;
+use temporalio_common::{
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, canned_histories,
+        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        temporal::api::enums::v1::{CommandType, WorkflowExecutionStatus},
+    },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
 
 async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
     let mut reason = "".to_string();
@@ -32,7 +35,9 @@ async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn cancel_during_timer() {
     let wf_name = "cancel_during_timer";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_string(), cancelled_wf);

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/child_workflows.rs

@@ -2,42 +2,47 @@ use crate::common::{CoreWfStarter, build_fake_sdk, mock_sdk, mock_sdk_cfg};
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{
+use temporalio_client::{WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::{
+    Worker,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            AsJsonPayloadExt,
+            child_workflow::{
+                ChildWorkflowCancellationType, StartChildWorkflowExecutionFailedCause, Success,
+                child_workflow_result,
+            },
+            workflow_activation::{
+                WorkflowActivationJob,
+                resolve_child_workflow_execution_start::Status as StartStatus,
+                workflow_activation_job,
+            },
+            workflow_commands::{
+                CancelChildWorkflowExecution, CompleteWorkflowExecution,
+                StartChildWorkflowExecution,
+            },
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::Payload,
+            enums::v1::{CommandType, EventType, ParentClosePolicy},
+            history::v1::{
+                StartChildWorkflowExecutionFailedEventAttributes,
+                StartChildWorkflowExecutionInitiatedEventAttributes,
+            },
+            sdk::v1::UserMetadata,
+        },
+    },
+    worker::WorkerTaskTypes,
+};
+use temporalio_sdk::{
     CancellableFuture, ChildWorkflowOptions, Signal, WfContext, WfExitValue, WorkflowResult,
 };
-use temporal_sdk_core::{
+use temporalio_sdk_core::{
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{MockPollCfg, ResponseType, mock_worker, mock_worker_client, single_hist_mock_sg},
 };
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::{
-    TestHistoryBuilder, canned_histories,
-    coresdk::{
-        AsJsonPayloadExt,
-        child_workflow::{
-            ChildWorkflowCancellationType, StartChildWorkflowExecutionFailedCause, Success,
-            child_workflow_result,
-        },
-        workflow_activation::{
-            WorkflowActivationJob, resolve_child_workflow_execution_start::Status as StartStatus,
-            workflow_activation_job,
-        },
-        workflow_commands::{
-            CancelChildWorkflowExecution, CompleteWorkflowExecution, StartChildWorkflowExecution,
-        },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        common::v1::Payload,
-        enums::v1::{CommandType, EventType, ParentClosePolicy},
-        history::v1::{
-            StartChildWorkflowExecutionFailedEventAttributes,
-            StartChildWorkflowExecutionInitiatedEventAttributes,
-        },
-        sdk::v1::UserMetadata,
-    },
-};
 use tokio::{join, sync::Barrier};
 
 static PARENT_WF_TYPE: &str = "parent_wf";
@@ -81,7 +86,9 @@ async fn happy_parent(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn child_workflow_happy_path() {
     let mut starter = CoreWfStarter::new("child-workflows");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
 
     worker.register_wf(PARENT_WF_TYPE.to_string(), happy_parent);
@@ -102,7 +109,9 @@ async fn child_workflow_happy_path() {
 #[tokio::test]
 async fn abandoned_child_bug_repro() {
     let mut starter = CoreWfStarter::new("child-workflow-abandon-bug");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
 
@@ -173,7 +182,9 @@ async fn abandoned_child_bug_repro() {
 #[tokio::test]
 async fn abandoned_child_resolves_post_cancel() {
     let mut starter = CoreWfStarter::new("child-workflow-resolves-post-cancel");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
 
@@ -240,7 +251,9 @@ async fn abandoned_child_resolves_post_cancel() {
 async fn cancelled_child_gets_reason() {
     let wf_name = "cancelled-child-gets-reason";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
 
     worker.register_wf(wf_name.to_string(), move |ctx: WfContext| async move {

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/continue_as_new.rs

@@ -1,13 +1,16 @@
 use crate::common::{CoreWfStarter, build_fake_sdk};
 use std::time::Duration;
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core::test_help::MockPollCfg;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, canned_histories,
-    coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
-    temporal::api::enums::v1::CommandType,
+use temporalio_client::WorkflowOptions;
+use temporalio_common::{
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, canned_histories,
+        coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
+        temporal::api::enums::v1::CommandType,
+    },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
 
 async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
     let run_ct = ctx.get_args()[0].data[0];
@@ -26,7 +29,9 @@ async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn continue_as_new_happy_path() {
     let wf_name = "continue_as_new_happy_path";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
@@ -48,7 +53,7 @@ async fn continue_as_new_multiple_concurrent() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         .max_cached_workflows(5_usize)
         .max_outstanding_workflow_tasks(5_usize);
     let mut worker = starter.worker().await;