@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/tests/integ_tests/workflow_tests/resets.rs

@@ -1,4 +1,7 @@
-use crate::integ_tests::activity_functions::echo;
+use crate::{
+    common::{CoreWfStarter, NAMESPACE},
+    integ_tests::activity_functions::echo,
+};
 use futures_util::StreamExt;
 use std::{
     sync::{
@@ -15,8 +18,8 @@ use temporal_sdk_core_protos::{
         common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
     },
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
 use tokio::sync::Notify;
+use tonic::IntoRequest;
 
 const POST_RESET_SIG: &str = "post-reset";
 
@@ -63,17 +66,20 @@ async fn reset_workflow() {
         notify.notified().await;
         // Do the reset
         client
-            .reset_workflow_execution(ResetWorkflowExecutionRequest {
-                namespace: NAMESPACE.to_owned(),
-                workflow_execution: Some(WorkflowExecution {
-                    workflow_id: wf_name.to_owned(),
-                    run_id: run_id.clone(),
-                }),
-                // End of first WFT
-                workflow_task_finish_event_id: 4,
-                request_id: "test-req-id".to_owned(),
-                ..Default::default()
-            })
+            .reset_workflow_execution(
+                ResetWorkflowExecutionRequest {
+                    namespace: NAMESPACE.to_owned(),
+                    workflow_execution: Some(WorkflowExecution {
+                        workflow_id: wf_name.to_owned(),
+                        run_id: run_id.clone(),
+                    }),
+                    // End of first WFT
+                    workflow_task_finish_event_id: 4,
+                    request_id: "test-req-id".to_owned(),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 
@@ -189,16 +195,19 @@ async fn reset_randomseed() {
         notify.notified().await;
         // Reset the workflow to be after first timer has fired
         client
-            .reset_workflow_execution(ResetWorkflowExecutionRequest {
-                namespace: NAMESPACE.to_owned(),
-                workflow_execution: Some(WorkflowExecution {
-                    workflow_id: wf_name.to_owned(),
-                    run_id: run_id.clone(),
-                }),
-                workflow_task_finish_event_id: 14,
-                request_id: "test-req-id".to_owned(),
-                ..Default::default()
-            })
+            .reset_workflow_execution(
+                ResetWorkflowExecutionRequest {
+                    namespace: NAMESPACE.to_owned(),
+                    workflow_execution: Some(WorkflowExecution {
+                        workflow_id: wf_name.to_owned(),
+                        run_id: run_id.clone(),
+                    }),
+                    workflow_task_finish_event_id: 14,
+                    request_id: "test-req-id".to_owned(),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 

package/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -1,12 +1,26 @@
-use std::collections::HashMap;
-
+use crate::common::{ActivationAssertionsInterceptor, CoreWfStarter, build_fake_sdk};
 use futures_util::StreamExt;
+use std::collections::HashMap;
 use temporal_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
-    ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
+    CancellableFuture, ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext,
+    WorkflowResult,
+};
+use temporal_sdk_core::test_help::MockPollCfg;
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    coresdk::{
+        IntoPayloadsExt,
+        workflow_activation::{
+            ResolveSignalExternalWorkflow, WorkflowActivationJob, workflow_activation_job,
+        },
+    },
+    temporal::api::{
+        command::v1::{Command, command},
+        common::v1::Payload,
+        enums::v1::{CommandType, EventType},
+    },
 };
-use temporal_sdk_core_protos::{coresdk::IntoPayloadsExt, temporal::api::common::v1::Payload};
-use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
 const SIGNAME: &str = "signame";
@@ -162,3 +176,110 @@ async fn sends_signal_to_child() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+async fn signal_sender_canned(ctx: WfContext) -> WorkflowResult<()> {
+    let mut dat = SignalWorkflowOptions::new("fake_wid", "fake_rid", SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let res = ctx.signal_workflow(dat).await;
+    if res.is_err() {
+        Err(anyhow::anyhow!("Signal fail!"))
+    } else {
+        Ok(().into())
+    }
+}
+
+#[rstest::rstest]
+#[case::succeeds(false)]
+#[case::fails(true)]
+#[tokio::test]
+async fn sends_signal(#[case] fails: bool) {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let id = t.add_signal_wf(SIGNAME, "fake_wid", "fake_rid");
+    if fails {
+        t.add_external_signal_failed(id);
+    } else {
+        t.add_external_signal_completed(id);
+    }
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+            asserts.then(move |wft| {
+                assert_matches!(wft.commands.as_slice(),
+                    [Command { attributes: Some(
+                        command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(attrs)),..}] => {
+                        assert_eq!(attrs.signal_name, SIGNAME);
+                        assert_eq!(attrs.input.as_ref().unwrap().payloads[0], b"hi!".into());
+                        assert_eq!(*attrs.header.as_ref().unwrap().fields.get("tupac").unwrap(),
+                                   b"shakur".into());
+                    }
+                );
+            }).then(move |wft| {
+                let cmds = &wft.commands;
+                assert_eq!(cmds.len(), 1);
+                if fails {
+                    assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);
+                } else {
+                    assert_eq!(
+                        cmds[0].command_type(),
+                        CommandType::CompleteWorkflowExecution
+                    );
+                }
+            });
+        });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, signal_sender_canned);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn cancels_before_sending() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    let mut aai = ActivationAssertionsInterceptor::default();
+    aai.skip_one().then(move |act| {
+        assert_matches!(
+            &act.jobs[0],
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveSignalExternalWorkflow(
+                    ResolveSignalExternalWorkflow {
+                        failure: Some(c),
+                        ..
+                    }
+                ))
+            } => c.message == "Signal was cancelled before being sent"
+        );
+    });
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts.then(move |wft| {
+            assert_eq!(wft.commands.len(), 1);
+            assert_eq!(
+                wft.commands[0].command_type(),
+                CommandType::CompleteWorkflowExecution
+            );
+        });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.set_worker_interceptor(aai);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
+        let sig = ctx.signal_workflow(SignalWorkflowOptions::new(
+            "fake_wid",
+            "fake_rid",
+            SIGNAME,
+            [b"hi!"],
+        ));
+        sig.cancel(&ctx);
+        let _res = sig.await;
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}

package/sdk-core/tests/integ_tests/workflow_tests/stickyness.rs

@@ -1,4 +1,4 @@
-use crate::integ_tests::workflow_tests::timers::timer_wf;
+use crate::{common::CoreWfStarter, integ_tests::workflow_tests::timers::timer_wf};
 use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
@@ -6,7 +6,6 @@ use std::{
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_api::worker::PollerBehavior;
-use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio::sync::Barrier;
 
 #[tokio::test]

package/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -1,13 +1,20 @@
 use std::time::Duration;
 
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{
-    workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
-    workflow_completion::WorkflowActivationCompletion,
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf,
-    start_timer_cmd,
+use crate::common::{CoreWfStarter, build_fake_sdk, init_core_and_create_wf};
+use temporal_sdk::{CancellableFuture, WfContext, WorkflowResult};
+use temporal_sdk_core::test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown};
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
+    coresdk::{
+        workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    prost_dur,
+    temporal::api::{
+        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
+        failure::v1::Failure,
+    },
+    test_utils::start_timer_cmd,
 };
 
 pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -121,3 +128,112 @@ async fn parallel_timers() {
     starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
+
+async fn happy_timer(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.timer(Duration::from_secs(5)).await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn test_fire_happy_path_inc() {
+    let t = canned_histories::single_timer("1");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(
+                    wft.commands[0].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, happy_timer);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn mismatched_timer_ids_errors() {
+    let t = canned_histories::single_timer("badid");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.num_expected_fails = 1;
+    mock_cfg.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
+        matches!(cause, WorkflowTaskFailedCause::NonDeterministicError)
+            && matches!(f, Some(Failure {message, .. })
+        if message.contains("Timer fired event did not have expected timer id 1"))
+    });
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
+        ctx.timer(Duration::from_secs(5)).await;
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}
+
+async fn cancel_timer(ctx: WfContext) -> WorkflowResult<()> {
+    let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
+    ctx.timer(Duration::from_secs(5)).await;
+    // Cancel the first timer after having waited on the second
+    cancel_timer_fut.cancel(&ctx);
+    cancel_timer_fut.await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn incremental_cancellation() {
+    let t = canned_histories::cancel_timer("2", "1");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 2);
+                assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
+                assert_eq!(wft.commands[1].command_type(), CommandType::StartTimer);
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 2);
+                assert_eq!(wft.commands[0].command_type(), CommandType::CancelTimer);
+                assert_eq!(
+                    wft.commands[1].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_timer);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn cancel_before_sent_to_server() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts.then(move |wft| {
+            assert_eq!(wft.commands.len(), 1);
+            assert_matches!(
+                wft.commands[0].command_type(),
+                CommandType::CompleteWorkflowExecution
+            );
+        });
+    });
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
+        let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
+        // Immediately cancel the timer
+        cancel_timer_fut.cancel(&ctx);
+        cancel_timer_fut.await;
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}

package/sdk-core/tests/integ_tests/workflow_tests/upsert_search_attrs.rs

@@ -1,3 +1,4 @@
+use crate::common::{CoreWfStarter, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, build_fake_sdk};
 use assert_matches::assert_matches;
 use std::{collections::HashMap, time::Duration};
 use temporal_client::{
@@ -5,8 +6,16 @@ use temporal_client::{
     WorkflowOptions,
 };
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::{CoreWfStarter, SEARCH_ATTR_INT, SEARCH_ATTR_TXT};
+use temporal_sdk_core::test_help::MockPollCfg;
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    coresdk::{AsJsonPayloadExt, FromJsonPayloadExt},
+    temporal::api::{
+        command::v1::{Command, command},
+        common::v1::Payload,
+        enums::v1::EventType,
+    },
+};
 use uuid::Uuid;
 
 async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
@@ -87,3 +96,54 @@ async fn sends_upsert() {
         .unwrap();
     assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
 }
+
+#[tokio::test]
+async fn upsert_search_attrs_from_workflow() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let (k1, k2) = ("foo", "bar");
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts.then(|wft| {
+            assert_matches!(
+                wft.commands.as_slice(),
+                [Command { attributes: Some(
+                      command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(msg)
+                    ), .. }, ..] => {
+                    let fields = &msg.search_attributes.as_ref().unwrap().indexed_fields;
+                    let payload1 = fields.get(k1).unwrap();
+                    let payload2 = fields.get(k2).unwrap();
+                    assert_eq!(payload1.data[0], 0x01);
+                    assert_eq!(payload2.data[0], 0x02);
+                    assert_eq!(fields.len(), 2);
+                }
+            );
+        });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
+        ctx.upsert_search_attributes([
+            (
+                String::from(k1),
+                Payload {
+                    data: vec![0x01],
+                    ..Default::default()
+                },
+            ),
+            (
+                String::from(k2),
+                Payload {
+                    data: vec![0x02],
+                    ..Default::default()
+                },
+            ),
+        ]);
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -18,7 +18,13 @@ mod stickyness;
 mod timers;
 mod upsert_search_attrs;
 
-use crate::integ_tests::{activity_functions::echo, metrics_tests};
+use crate::{
+    common::{
+        CoreWfStarter, history_from_proto_binary, init_core_and_create_wf,
+        init_core_replay_preloaded, mock_sdk_cfg, prom_metrics,
+    },
+    integ_tests::{activity_functions::echo, metrics_tests},
+};
 use assert_matches::assert_matches;
 use std::{
     collections::{HashMap, HashSet},
@@ -26,9 +32,13 @@ use std::{
 };
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{
-    ActivityOptions, LocalActivityOptions, WfContext, interceptors::WorkerInterceptor,
+    ActivityOptions, LocalActivityOptions, TimerOptions, WfContext, interceptors::WorkerInterceptor,
+};
+use temporal_sdk_core::{
+    CoreRuntime,
+    replay::HistoryForReplay,
+    test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown},
 };
-use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay};
 use temporal_sdk_core_api::{
     errors::{PollError, WorkflowErrorType},
     worker::{
@@ -36,6 +46,7 @@ use temporal_sdk_core_api::{
     },
 };
 use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, canned_histories,
     coresdk::{
         ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
         activity_result::ActivityExecutionResult,
@@ -45,14 +56,15 @@ use temporal_sdk_core_protos::{
         },
         workflow_completion::WorkflowActivationCompletion,
     },
+    prost_dur,
     temporal::api::{
-        enums::v1::EventType, failure::v1::Failure, history::v1::history_event,
+        enums::v1::{CommandType, EventType},
+        failure::v1::Failure,
+        history::v1::history_event,
         query::v1::WorkflowQuery,
+        sdk::v1::UserMetadata,
     },
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, history_from_proto_binary,
-    init_core_and_create_wf, init_core_replay_preloaded, prom_metrics, schedule_activity_cmd,
+    test_utils::schedule_activity_cmd,
 };
 use tokio::{join, sync::Notify, time::sleep};
 
@@ -922,3 +934,50 @@ async fn history_out_of_order_on_restart() {
         .unwrap();
     assert_matches!(res, WorkflowExecutionResult::Failed(_));
 }
+
+#[tokio::test]
+async fn pass_timer_summary_to_metadata() {
+    let t = canned_histories::single_timer("1");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    let wf_id = mock_cfg.hists[0].wf_id.clone();
+    let wf_type = DEFAULT_WORKFLOW_TYPE;
+    let expected_user_metadata = Some(UserMetadata {
+        summary: Some(b"timer summary".into()),
+        details: None,
+    });
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
+                assert_eq!(wft.commands[0].user_metadata, expected_user_metadata)
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(
+                    wft.commands[0].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = mock_sdk_cfg(mock_cfg, |_| {});
+    worker.register_wf(wf_type, |ctx: WfContext| async move {
+        ctx.timer(TimerOptions {
+            duration: Duration::from_secs(1),
+            summary: Some("timer summary".to_string()),
+        })
+        .await;
+        Ok(().into())
+    });
+    worker
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

package/sdk-core/tests/main.rs

@@ -3,7 +3,9 @@
 #[macro_use]
 extern crate rstest;
 #[macro_use]
-extern crate temporal_sdk_core_test_utils;
+extern crate assert_matches;
+
+mod common;
 
 #[cfg(test)]
 mod shared_tests;
@@ -15,6 +17,7 @@ mod integ_tests {
     mod ephemeral_server_tests;
     mod heartbeat_tests;
     mod metrics_tests;
+    mod pagination_tests;
     mod polling_tests;
     mod queries_tests;
     mod update_tests;
@@ -23,6 +26,9 @@ mod integ_tests {
     mod worker_versioning_tests;
     mod workflow_tests;
 
+    use crate::common::{
+        CoreWfStarter, get_integ_server_options, get_integ_telem_options, rand_6_chars,
+    };
     use std::time::Duration;
     use temporal_client::{NamespacedClient, WorkflowService};
     use temporal_sdk_core::{CoreRuntime, init_worker};
@@ -32,9 +38,7 @@ mod integ_tests {
         operatorservice::v1::CreateNexusEndpointRequest,
         workflowservice::v1::ListNamespacesRequest,
     };
-    use temporal_sdk_core_test_utils::{
-        CoreWfStarter, get_integ_server_options, get_integ_telem_options, rand_6_chars,
-    };
+    use tonic::IntoRequest;
 
     // Create a worker like a bridge would (unwraps aside)
     #[tokio::test]
@@ -61,27 +65,32 @@ mod integ_tests {
 
         // Do things with worker or client
         let _ = retrying_client
-            .list_namespaces(ListNamespacesRequest::default())
+            .list_namespaces(ListNamespacesRequest::default().into_request())
             .await;
     }
 
     pub(crate) async fn mk_nexus_endpoint(starter: &mut CoreWfStarter) -> String {
         let client = starter.get_client().await;
         let endpoint = format!("mycoolendpoint-{}", rand_6_chars());
-        let mut op_client = client.get_client().inner().operator_svc().clone();
+        let mut op_client = client.get_client().inner().operator_svc();
         op_client
-            .create_nexus_endpoint(CreateNexusEndpointRequest {
-                spec: Some(EndpointSpec {
-                    name: endpoint.to_owned(),
-                    description: None,
-                    target: Some(EndpointTarget {
-                        variant: Some(endpoint_target::Variant::Worker(endpoint_target::Worker {
-                            namespace: client.namespace().to_owned(),
-                            task_queue: starter.get_task_queue().to_owned(),
-                        })),
+            .create_nexus_endpoint(
+                CreateNexusEndpointRequest {
+                    spec: Some(EndpointSpec {
+                        name: endpoint.to_owned(),
+                        description: None,
+                        target: Some(EndpointTarget {
+                            variant: Some(endpoint_target::Variant::Worker(
+                                endpoint_target::Worker {
+                                    namespace: client.namespace(),
+                                    task_queue: starter.get_task_queue().to_owned(),
+                                },
+                            )),
+                        }),
                     }),
-                }),
-            })
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
         // Endpoint creation can (as of server 1.25.2 at least) return before they are actually usable.

package/sdk-core/tests/manual_tests.rs

@@ -1,6 +1,11 @@
 //! These tests are expensive and meant to be run manually. Use them for things like perf and
 //! load testing.
 
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use common::{CoreWfStarter, prom_metrics, rand_6_chars};
 use futures_util::{
     StreamExt,
     future::{AbortHandle, Abortable},
@@ -18,7 +23,6 @@ use temporal_sdk::{ActContext, ActivityOptions, WfContext};
 use temporal_sdk_core::CoreRuntime;
 use temporal_sdk_core_api::{telemetry::PrometheusExporterOptionsBuilder, worker::PollerBehavior};
 use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
-use temporal_sdk_core_test_utils::{CoreWfStarter, prom_metrics, rand_6_chars};
 use tracing::info;
 
 #[tokio::test]