@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/sdk-core/crates/sdk-core/tests/integ_tests/worker_tests.rs

@@ -1,9 +1,9 @@
 use crate::{
     common::{
-        CoreWfStarter, fake_grpc_server::fake_server, get_integ_runtime_options,
-        get_integ_server_options, get_integ_telem_options, mock_sdk_cfg,
+        CoreWfStarter, activity_functions::StdActivities, fake_grpc_server::fake_server,
+        get_integ_runtime_options, get_integ_server_options, get_integ_telem_options, mock_sdk_cfg,
     },
-    shared_tests,
+    shared_tests::{self, is_oversize_grpc_event},
 };
 use assert_matches::assert_matches;
 use futures_util::FutureExt;
@@ -18,10 +18,9 @@ use std::{
     },
     time::Duration,
 };
-use temporalio_client::WorkflowOptions;
+use temporalio_client::{Connection, WorkflowStartOptions};
 use temporalio_common::{
-    Worker,
-    errors::WorkerValidationError,
+    data_converters::{DataConverter, RawValue},
     protos::{
         DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
         coresdk::{
@@ -35,13 +34,15 @@ use temporalio_common::{
             command::v1::command::Attributes,
             common::v1::WorkerVersionStamp,
             enums::v1::{
-                EventType, WorkflowTaskFailedCause, WorkflowTaskFailedCause::GrpcMessageTooLarge,
+                EventType,
+                WorkflowTaskFailedCause::{self},
             },
             failure::v1::Failure as InnerFailure,
             history::v1::{
-                ActivityTaskScheduledEventAttributes, history_event,
-                history_event::Attributes::{
-                    self as EventAttributes, WorkflowTaskFailedEventAttributes,
+                ActivityTaskScheduledEventAttributes,
+                history_event::{
+                    self,
+                    Attributes::{self as EventAttributes},
                 },
             },
             workflowservice::v1::{
@@ -50,18 +51,20 @@ use temporalio_common::{
             },
         },
     },
-    worker::{
-        ActivitySlotKind, LocalActivitySlotKind, PollerBehavior, SlotInfo, SlotInfoTrait,
-        SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
-        SlotSupplierPermit, WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy,
-        WorkflowSlotKind,
-    },
+    worker::WorkerTaskTypes,
 };
+use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityOptions, LocalActivityOptions, WfContext, interceptors::WorkerInterceptor,
+    ActivityOptions, LocalActivityOptions, WorkerOptions, WorkflowContext, WorkflowResult,
+    WorkflowTermination,
+    activities::{ActivityContext, ActivityError},
+    interceptors::WorkerInterceptor,
 };
 use temporalio_sdk_core::{
-    CoreRuntime, ResourceBasedTuner, ResourceSlotOptions, TunerBuilder, init_worker,
+    ActivitySlotKind, CoreRuntime, LocalActivitySlotKind, PollError, PollerBehavior,
+    ResourceBasedTuner, ResourceSlotOptions, SlotInfo, SlotInfoTrait, SlotMarkUsedContext,
+    SlotReleaseContext, SlotReservationContext, SlotSupplier, SlotSupplierPermit, TunerBuilder,
+    WorkerConfig, WorkerValidationError, WorkerVersioningStrategy, WorkflowSlotKind, init_worker,
     test_help::{
         FakeWfResponses, MockPollCfg, ResponseType, build_mock_pollers, drain_pollers_and_shutdown,
         hist_to_poll_resp, mock_worker, mock_worker_client,
@@ -73,18 +76,16 @@ use uuid::Uuid;
 
 #[tokio::test]
 async fn worker_validation_fails_on_nonexistent_namespace() {
-    let opts = get_integ_server_options();
+    let mut opts = get_integ_server_options();
     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
-        .unwrap();
+    opts.metrics_meter = runtime.telemetry().get_temporal_metric_meter();
+    let connection = Connection::connect(opts).await.unwrap();
 
     let worker = init_worker(
         &runtime,
-        WorkerConfigBuilder::default()
+        WorkerConfig::builder()
             .namespace("i_dont_exist")
             .task_queue("Wheee!")
             .versioning_strategy(WorkerVersioningStrategy::None {
@@ -93,7 +94,7 @@ async fn worker_validation_fails_on_nonexistent_namespace() {
             .task_types(WorkerTaskTypes::all())
             .build()
             .unwrap(),
-        retrying_client,
+        connection,
     )
     .unwrap();
 
@@ -110,12 +111,13 @@ async fn worker_handles_unknown_workflow_types_gracefully() {
     let mut starter = CoreWfStarter::new(wf_type);
     let mut worker = starter.worker().await;
 
+    let task_queue = starter.get_task_queue().to_owned();
+    let wf_id = format!("wce-{}", Uuid::new_v4());
     let run_id = worker
         .submit_wf(
-            format!("wce-{}", Uuid::new_v4()),
             "unregistered".to_string(),
             vec![],
-            WorkflowOptions::default(),
+            WorkflowStartOptions::new(task_queue, wf_id).build(),
         )
         .await
         .unwrap();
@@ -172,35 +174,41 @@ async fn worker_handles_unknown_workflow_types_gracefully() {
     });
 }
 
+#[workflow]
+#[derive(Default)]
+struct ResourceBasedNonStickyWf;
+
+#[workflow_methods]
+impl ResourceBasedNonStickyWf {
+    #[run]
+    async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
 #[tokio::test]
 async fn resource_based_few_pollers_guarantees_non_sticky_poll() {
     let wf_name = "resource_based_few_pollers_guarantees_non_sticky_poll";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .clear_max_outstanding_opts()
-        .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));
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    // 3 pollers so the minimum slots of 2 can both be handed out to a sticky poller
+    starter.sdk_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(3_usize);
     // Set the limits to zero so it's essentially unwilling to hand out slots
     let mut tuner = ResourceBasedTuner::new(0.0, 0.0);
     tuner.with_workflow_slots_options(ResourceSlotOptions::new(2, 10, Duration::from_millis(0)));
-    starter.worker_config.tuner(Arc::new(tuner));
+    starter.sdk_config.tuner = Arc::new(tuner);
     let mut worker = starter.worker().await;
 
     // Workflow doesn't actually need to do anything. We just need to see that we don't get stuck
     // by assigning all slots to sticky pollers.
-    worker.register_wf(
-        wf_name.to_owned(),
-        |_: WfContext| async move { Ok(().into()) },
-    );
+    worker.register_workflow::<ResourceBasedNonStickyWf>();
+    let task_queue = starter.get_task_queue().to_owned();
     for i in 0..20 {
         worker
-            .submit_wf(
-                format!("{wf_name}_{i}"),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
+            .submit_workflow(
+                ResourceBasedNonStickyWf::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), format!("{wf_name}_{i}")).build(),
             )
             .await
             .unwrap();
@@ -216,33 +224,47 @@ async fn oversize_grpc_message() {
     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());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut core = starter.worker().await;
 
-    static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);
-    core.register_wf(wf_name.to_owned(), |_ctx: WfContext| async move {
-        if OVERSIZE_GRPC_MESSAGE_RUN.load(Relaxed) {
-            Ok(vec![].into())
-        } else {
-            OVERSIZE_GRPC_MESSAGE_RUN.store(true, Relaxed);
-            let result: Vec<u8> = vec![0; 5000000];
-            Ok(result.into())
+    let has_run = Arc::new(AtomicBool::new(false));
+    let has_run_clone = has_run.clone();
+
+    #[workflow]
+    struct OversizeGrpcMessageWf {
+        has_run: Arc<AtomicBool>,
+    }
+
+    #[workflow_methods(factory_only)]
+    impl OversizeGrpcMessageWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<Vec<u8>> {
+            if ctx.state(|wf| wf.has_run.load(Relaxed)) {
+                Ok(vec![])
+            } else {
+                ctx.state(|wf| wf.has_run.store(true, Relaxed));
+                let result: Vec<u8> = vec![0; 5000000];
+                Ok(result)
+            }
         }
+    }
+
+    core.register_workflow_with_factory(move || OversizeGrpcMessageWf {
+        has_run: has_run_clone.clone(),
     });
-    starter.start_with_worker(wf_name, &mut core).await;
+    starter
+        .start_with_worker(OversizeGrpcMessageWf::name(), &mut core)
+        .await;
     core.run_until_done().await.unwrap();
 
-    assert!(starter.get_history().await.events.iter().any(|e| {
-        e.event_type == EventType::WorkflowTaskFailed as i32
-            && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                attr.cause == GrpcMessageTooLarge as i32
-                    && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
-            } else {
-                false
-            }
-    }));
+    assert!(
+        starter
+            .get_history()
+            .await
+            .events
+            .iter()
+            .any(is_oversize_grpc_event)
+    );
 
     // Verify the workflow task failure metric includes the GrpcMessageTooLarge reason
     let tq = starter.get_task_queue();
@@ -358,7 +380,10 @@ 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());
+    let mut worker = crate::common::TestWorker::new(temporalio_sdk::Worker::new_from_core(
+        core.clone(),
+        DataConverter::default(),
+    ));
 
     // First poll for activities twice, occupying both slots
     let at1 = core.poll_activity_task().await.unwrap();
@@ -366,33 +391,45 @@ async fn activity_tasks_from_completion_reserve_slots() {
     let workflow_complete_token = CancellationToken::new();
     let workflow_complete_token_clone = workflow_complete_token.clone();
 
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| {
-        let complete_token = workflow_complete_token.clone();
-        async move {
-            ctx.activity(ActivityOptions {
-                activity_type: "act1".to_string(),
-                ..Default::default()
-            })
-            .await;
-            ctx.activity(ActivityOptions {
-                activity_type: "act2".to_string(),
-                ..Default::default()
-            })
-            .await;
-            complete_token.cancel();
-            Ok(().into())
+    struct FakeAct;
+    #[activities]
+    impl FakeAct {
+        #[activity(name = "act1")]
+        fn act1(_: ActivityContext) -> Result<RawValue, ActivityError> {
+            unreachable!("doesn't actually run")
+        }
+
+        #[activity(name = "act2")]
+        fn act2(_: ActivityContext) -> Result<RawValue, ActivityError> {
+            unreachable!("doesn't actually run")
         }
+    }
+
+    #[workflow]
+    struct ActivityTasksCompletionWf {
+        complete_token: CancellationToken,
+    }
+
+    #[workflow_methods(factory_only)]
+    impl ActivityTasksCompletionWf {
+        #[run(name = DEFAULT_WORKFLOW_TYPE)]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.start_activity(FakeAct::act1, (), ActivityOptions::default())
+                .await
+                .map_err(|e| WorkflowTermination::from(anyhow::Error::from(e)))?;
+            ctx.start_activity(FakeAct::act2, (), ActivityOptions::default())
+                .await
+                .map_err(|e| WorkflowTermination::from(anyhow::Error::from(e)))?;
+            ctx.state(|wf| wf.complete_token.cancel());
+            Ok(())
+        }
+    }
+
+    let wf_token = workflow_complete_token.clone();
+    worker.register_workflow_with_factory(move || ActivityTasksCompletionWf {
+        complete_token: wf_token.clone(),
     });
 
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            DEFAULT_WORKFLOW_TYPE,
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
     let act_completer = async {
         barr.wait().await;
         core.complete_activity_task(ActivityTaskCompletion {
@@ -408,13 +445,13 @@ async fn activity_tasks_from_completion_reserve_slots() {
         .await
         .unwrap();
         barr.wait().await;
-        // Wait for workflow to complete in order for all eager activities to be requested before shutting down.
-        // After shutdown, no eager activities slots can be allocated.
+        // Wait for workflow to complete in order for all eager activities to be requested before
+        // shutting down. After shutdown, no eager activities slots can be allocated.
         workflow_complete_token_clone.cancelled().await;
         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, temporalio_common::errors::PollError::ShutDown);
+        assert_matches!(err, PollError::ShutDown);
     };
     // This wf poll should *not* set the flag that it wants tasks back since both slots are
     // occupied
@@ -439,23 +476,27 @@ async fn max_wft_respected() {
         cfg.max_cached_workflows = total_wfs as usize;
         cfg.max_outstanding_workflow_tasks = Some(1);
     });
-    let active_count: &'static _ = Box::leak(Box::new(Semaphore::new(1)));
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
-        drop(
-            active_count
-                .try_acquire()
-                .expect("No multiple concurrent workflow tasks!"),
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
-
-    for wf_id in wf_ids {
-        worker
-            .submit_wf(wf_id, DEFAULT_WORKFLOW_TYPE, vec![], Default::default())
-            .await
-            .unwrap();
+    static ACTIVE_COUNT: Semaphore = Semaphore::const_new(1);
+
+    #[workflow]
+    #[derive(Default)]
+    struct MaxWftWf;
+
+    #[workflow_methods]
+    impl MaxWftWf {
+        #[run(name = DEFAULT_WORKFLOW_TYPE)]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            drop(
+                ACTIVE_COUNT
+                    .try_acquire()
+                    .expect("No multiple concurrent workflow tasks!"),
+            );
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(())
+        }
     }
+
+    worker.register_workflow::<MaxWftWf>();
     worker.run_until_done().await.unwrap();
 }
 
@@ -528,23 +569,24 @@ async fn history_length_with_fail_and_timeout(
             wc.max_cached_workflows = 1;
         }
     });
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        assert_eq!(ctx.history_length(), 3);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.history_length(), 14);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.history_length(), 19);
-        Ok(().into())
-    });
-    worker
-        .submit_wf(
-            wfid.to_owned(),
-            DEFAULT_WORKFLOW_TYPE.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    #[workflow]
+    #[derive(Default)]
+    struct HistoryLengthWf;
+
+    #[workflow_methods]
+    impl HistoryLengthWf {
+        #[run(name = DEFAULT_WORKFLOW_TYPE)]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            assert_eq!(ctx.history_length(), 3);
+            ctx.timer(Duration::from_secs(1)).await;
+            assert_eq!(ctx.history_length(), 14);
+            ctx.timer(Duration::from_secs(1)).await;
+            assert_eq!(ctx.history_length(), 19);
+            Ok(())
+        }
+    }
+
+    worker.register_workflow::<HistoryLengthWf>();
     worker.run_until_done().await.unwrap();
 }
 
@@ -584,31 +626,37 @@ async fn sets_build_id_from_wft_complete() {
         },
     );
 
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        // First task, it should be empty, since replaying and nothing in first WFT completed
-        assert_eq!(ctx.current_deployment_version(), None);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "enchi-cat"
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        // Not replaying at this point, so we should see the worker's build id
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "fierce-predator"
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "fierce-predator"
-        );
-        Ok(().into())
-    });
-    worker
-        .submit_wf(wfid, DEFAULT_WORKFLOW_TYPE, vec![], Default::default())
-        .await
-        .unwrap();
+    #[workflow]
+    #[derive(Default)]
+    struct BuildIdWf;
+
+    #[workflow_methods]
+    impl BuildIdWf {
+        #[run(name = DEFAULT_WORKFLOW_TYPE)]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            // First task, it should be empty, since replaying and nothing in first WFT completed
+            assert_eq!(ctx.current_deployment_version(), None);
+            ctx.timer(Duration::from_secs(1)).await;
+            assert_eq!(
+                ctx.current_deployment_version().unwrap().build_id,
+                "enchi-cat"
+            );
+            ctx.timer(Duration::from_secs(1)).await;
+            // Not replaying at this point, so we should see the worker's build id
+            assert_eq!(
+                ctx.current_deployment_version().unwrap().build_id,
+                "fierce-predator"
+            );
+            ctx.timer(Duration::from_secs(1)).await;
+            assert_eq!(
+                ctx.current_deployment_version().unwrap().build_id,
+                "fierce-predator"
+            );
+            Ok(())
+        }
+    }
+
+    worker.register_workflow::<BuildIdWf>();
     worker.run_until_done().await.unwrap();
 }
 
@@ -667,7 +715,7 @@ impl<SK> TrackingSlotSupplier<SK> {
 #[async_trait::async_trait]
 impl<SK> SlotSupplier for TrackingSlotSupplier<SK>
 where
-    SK: temporalio_common::worker::SlotKind + Send + Sync,
+    SK: temporalio_sdk_core::SlotKind + Send + Sync,
     SK::Info: SlotInfoTrait,
 {
     type SlotKind = SK;
@@ -712,47 +760,56 @@ async fn test_custom_slot_supplier_simple() {
     ));
 
     let mut starter = CoreWfStarter::new("test_custom_slot_supplier_simple");
-    starter.worker_config.clear_max_outstanding_opts();
+    starter.sdk_config.register_activities(StdActivities);
 
     let mut tb = TunerBuilder::default();
     tb.workflow_slot_supplier(wf_supplier.clone());
     tb.activity_slot_supplier(activity_supplier.clone());
     tb.local_activity_slot_supplier(local_activity_supplier.clone());
-    starter.worker_config.tuner(Arc::new(tb.build()));
+    starter.sdk_config.tuner = Arc::new(tb.build());
 
     let mut worker = starter.worker().await;
 
-    worker.register_activity(
-        "SlotSupplierActivity",
-        |_: temporalio_sdk::ActContext, _: ()| async move { Ok(()) },
-    );
-    worker.register_wf(
-        "SlotSupplierWorkflow".to_owned(),
-        |ctx: WfContext| async move {
+    #[workflow]
+    #[derive(Default)]
+    struct SlotSupplierWorkflow;
+
+    #[workflow_methods]
+    impl SlotSupplierWorkflow {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
             let _result = ctx
-                .activity(ActivityOptions {
-                    activity_type: "SlotSupplierActivity".to_string(),
-                    start_to_close_timeout: Some(Duration::from_secs(10)),
-                    ..Default::default()
-                })
+                .start_activity(
+                    StdActivities::no_op,
+                    (),
+                    ActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(10)),
+                        ..Default::default()
+                    },
+                )
                 .await;
             let _result = ctx
-                .local_activity(LocalActivityOptions {
-                    activity_type: "SlotSupplierActivity".to_string(),
-                    start_to_close_timeout: Some(Duration::from_secs(10)),
-                    ..Default::default()
-                })
+                .start_local_activity(
+                    StdActivities::no_op,
+                    (),
+                    LocalActivityOptions {
+                        start_to_close_timeout: Some(Duration::from_secs(10)),
+                        ..Default::default()
+                    },
+                )
                 .await;
-            Ok(().into())
-        },
-    );
+            Ok(())
+        }
+    }
 
+    worker.register_workflow::<SlotSupplierWorkflow>();
+
+    let task_queue = starter.get_task_queue().to_owned();
     worker
-        .submit_wf(
-            "test-wf".to_owned(),
-            "SlotSupplierWorkflow".to_owned(),
-            vec![],
-            Default::default(),
+        .submit_workflow(
+            SlotSupplierWorkflow::run,
+            (),
+            WorkflowStartOptions::new(task_queue, "test-wf".to_owned()).build(),
         )
         .await
         .unwrap();
@@ -823,7 +880,7 @@ async fn test_custom_slot_supplier_simple() {
                                     slot_type: "activity",
                                     activity_type: Some(act_type),
                                     ..
-                                } if act_type == "SlotSupplierActivity"))
+                                } if act_type.contains("no_op")))
     );
     assert!(
         local_activity_events
@@ -832,7 +889,7 @@ async fn test_custom_slot_supplier_simple() {
                                     slot_type: "local_activity",
                                     activity_type: Some(act_type),
                                     ..
-                                } if act_type == "SlotSupplierActivity"))
+                                } if act_type.contains("no_op")))
     );
     assert!(wf_events.iter().any(|e| matches!(
         e,
@@ -905,12 +962,13 @@ async fn shutdown_worker_not_retried() {
     .await;
 
     let mut opts = get_integ_server_options();
-    let uri = format!("http://localhost:{}", fs.addr.port())
-        .parse()
+    opts.target = format!("http://localhost:{}", fs.addr.port())
+        .parse::<url::Url>()
         .unwrap();
-    opts.target_url = uri;
-    opts.skip_get_system_info = true;
-    let client = opts.connect("ns", None).await.unwrap();
+    opts.set_skip_get_system_info(true);
+    let connection = Connection::connect(opts).await.unwrap();
+    let client_opts = temporalio_client::ClientOptions::new("ns").build();
+    let client = temporalio_client::Client::new(connection, client_opts).unwrap();
 
     let wf_type = "shutdown_worker_not_retried";
     let mut starter = CoreWfStarter::new_with_overrides(wf_type, None, Some(client));
@@ -918,3 +976,10 @@ async fn shutdown_worker_not_retried() {
     drain_pollers_and_shutdown(&worker).await;
     assert_eq!(shutdown_call_count.load(Ordering::Relaxed), 1);
 }
+
+#[test]
+fn test_default_build_id() {
+    let o = WorkerOptions::new("task_queue").build();
+    assert!(!o.deployment_options.version.build_id.is_empty());
+    assert_ne!(o.deployment_options.version.build_id, "undetermined");
+}