@temporalio/core-bridge 1.12.2 → 1.12.3

package/sdk-core/test-utils/src/lib.rs

@@ -24,6 +24,7 @@ use std::{
     future::Future,
     net::SocketAddr,
     path::PathBuf,
+    str::FromStr,
     sync::Arc,
     time::{Duration, Instant},
 };
@@ -69,8 +70,9 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::{
-        common::v1::Payload, history::v1::History,
-        workflowservice::v1::StartWorkflowExecutionResponse,
+        common::v1::Payload,
+        history::v1::History,
+        workflowservice::v1::{GetClusterInfoRequest, StartWorkflowExecutionResponse},
     },
 };
 use tokio::{sync::OnceCell, task::AbortHandle};
@@ -95,6 +97,7 @@ pub const OTEL_URL_ENV_VAR: &str = "TEMPORAL_INTEG_OTEL_URL";
 pub const PROM_ENABLE_ENV_VAR: &str = "TEMPORAL_INTEG_PROM_PORT";
 /// This should match the prometheus port exposed in docker-compose-ci.yaml
 pub const PROMETHEUS_QUERY_API: &str = "http://localhost:9090/api/v1/query";
+
 #[macro_export]
 macro_rules! prost_dur {
     ($dur_call:ident $args:tt) => {
@@ -192,6 +195,37 @@ pub fn init_integ_telem() -> Option<&'static CoreRuntime> {
     }))
 }
 
+pub async fn get_cloud_client() -> RetryClient<Client> {
+    let cloud_addr = env::var("TEMPORAL_CLOUD_ADDRESS").unwrap();
+    let cloud_key = env::var("TEMPORAL_CLIENT_KEY").unwrap();
+
+    let client_cert = env::var("TEMPORAL_CLIENT_CERT")
+        .expect("TEMPORAL_CLIENT_CERT must be set")
+        .replace("\\n", "\n")
+        .into_bytes();
+    let client_private_key = cloud_key.replace("\\n", "\n").into_bytes();
+    let sgo = ClientOptionsBuilder::default()
+        .target_url(Url::from_str(&cloud_addr).unwrap())
+        .client_name("sdk-core-integ-tests")
+        .client_version("clientver")
+        .identity("sdk-test-client")
+        .tls_cfg(TlsConfig {
+            client_tls_config: Some(ClientTlsConfig {
+                client_cert,
+                client_private_key,
+            }),
+            ..Default::default()
+        })
+        .build()
+        .unwrap();
+    sgo.connect(
+        env::var("TEMPORAL_NAMESPACE").expect("TEMPORAL_NAMESPACE must be set"),
+        None,
+    )
+    .await
+    .unwrap()
+}
+
 /// Implements a builder pattern to help integ tests initialize core and create workflows
 pub struct CoreWfStarter {
     /// Used for both the task queue and workflow id
@@ -202,6 +236,7 @@ pub struct CoreWfStarter {
     initted_worker: OnceCell<InitializedWorker>,
     runtime_override: Option<Arc<CoreRuntime>>,
     client_override: Option<Arc<RetryClient<Client>>>,
+    min_local_server_version: Option<String>,
 }
 struct InitializedWorker {
     worker: Arc<dyn CoreWorker>,
@@ -223,6 +258,51 @@ impl CoreWfStarter {
         Self::_new(test_name, None, Some(client))
     }
 
+    /// Targets cloud if the required env vars are present. Otherwise, local server (but only if
+    /// the minimum version requirement is met). Returns None if the local server is not new enough.
+    ///
+    /// An empty string means to skip the version check.
+    pub async fn new_cloud_or_local(test_name: &str, version_req: &str) -> Option<Self> {
+        init_integ_telem();
+        let mut check_mlsv = false;
+        let client = if env::var("TEMPORAL_CLOUD_ADDRESS").is_ok() {
+            Some(get_cloud_client().await)
+        } else {
+            check_mlsv = true;
+            None
+        };
+        let mut s = Self::_new(test_name, None, client);
+
+        if check_mlsv && !version_req.is_empty() {
+            let clustinfo = (*s.get_client().await)
+                .get_client()
+                .inner()
+                .workflow_svc()
+                .clone()
+                .get_cluster_info(GetClusterInfoRequest::default())
+                .await;
+            let srv_ver = semver::Version::parse(
+                &clustinfo
+                    .expect("must be able to get cluster info")
+                    .into_inner()
+                    .server_version,
+            )
+            .expect("must be able to parse server version");
+            let req = semver::VersionReq::parse(version_req)
+                .expect("must be able to parse server version requirement");
+
+            if !req.matches(&srv_ver) {
+                warn!(
+                    "Server version {} does not meet requirement {} for test {}",
+                    srv_ver, req, test_name
+                );
+                return None;
+            }
+        }
+
+        Some(s)
+    }
+
     fn _new(
         test_name: &str,
         runtime_override: Option<CoreRuntime>,
@@ -241,6 +321,7 @@ impl CoreWfStarter {
             workflow_options: Default::default(),
             runtime_override: runtime_override.map(Arc::new),
             client_override: client_override.map(Arc::new),
+            min_local_server_version: None,
         }
     }
 
@@ -253,6 +334,7 @@ impl CoreWfStarter {
             workflow_options: self.workflow_options.clone(),
             runtime_override: self.runtime_override.clone(),
             client_override: self.client_override.clone(),
+            min_local_server_version: self.min_local_server_version.clone(),
             initted_worker: Default::default(),
         }
     }
@@ -475,11 +557,16 @@ impl TestWorker {
         workflow_id: impl Into<String>,
         workflow_type: impl Into<String>,
         input: Vec<Payload>,
-        options: WorkflowOptions,
+        mut options: WorkflowOptions,
     ) -> Result<String, anyhow::Error> {
         if self.client.is_none() {
             return Ok("fake_run_id".to_string());
         }
+        // Fallback overall execution timeout to avoid leaving open workflows when testing against
+        // cloud
+        if options.execution_timeout.is_none() {
+            options.execution_timeout = Some(Duration::from_secs(60 * 5));
+        }
         self.get_submitter_handle()
             .submit_wf(workflow_id, workflow_type, input, options)
             .await

package/sdk-core/tests/cloud_tests.rs

@@ -1,53 +1,11 @@
-use std::{
-    env,
-    str::FromStr,
-    sync::atomic::{AtomicBool, Ordering::Relaxed},
-};
-use temporal_client::{
-    Client, ClientOptionsBuilder, ClientTlsConfig, RetryClient, TlsConfig, WorkflowClientTrait,
-};
-use temporal_sdk::WfContext;
-use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
-    history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
-};
-use temporal_sdk_core_test_utils::CoreWfStarter;
-use url::Url;
+use temporal_client::WorkflowClientTrait;
+use temporal_sdk_core_test_utils::get_cloud_client;
 
-async fn get_client(client_name: &str) -> RetryClient<Client> {
-    let cloud_addr = env::var("TEMPORAL_CLOUD_ADDRESS").unwrap();
-    let cloud_key = env::var("TEMPORAL_CLIENT_KEY").unwrap();
-
-    let client_cert = env::var("TEMPORAL_CLIENT_CERT")
-        .expect("TEMPORAL_CLIENT_CERT must be set")
-        .replace("\\n", "\n")
-        .into_bytes();
-    let client_private_key = cloud_key.replace("\\n", "\n").into_bytes();
-    let sgo = ClientOptionsBuilder::default()
-        .target_url(Url::from_str(&cloud_addr).unwrap())
-        .client_name(client_name)
-        .client_version("clientver")
-        .identity("sdk-test-client")
-        .tls_cfg(TlsConfig {
-            client_tls_config: Some(ClientTlsConfig {
-                client_cert,
-                client_private_key,
-            }),
-            ..Default::default()
-        })
-        .build()
-        .unwrap();
-    sgo.connect(
-        env::var("TEMPORAL_NAMESPACE").expect("TEMPORAL_NAMESPACE must be set"),
-        None,
-    )
-    .await
-    .unwrap()
-}
+mod shared_tests;
 
 #[tokio::test]
 async fn tls_test() {
-    let con = get_client("tls_tester").await;
+    let con = get_cloud_client().await;
     con.list_workflow_executions(100, vec![], "".to_string())
         .await
         .unwrap();
@@ -55,32 +13,11 @@ async fn tls_test() {
 
 #[tokio::test]
 async fn grpc_message_too_large_test() {
-    let wf_name = "oversize_grpc_message";
-    let mut starter =
-        CoreWfStarter::new_with_client(wf_name, get_client("grpc_message_too_large").await);
-    starter.worker_config.no_remote_activities(true);
-    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())
-        }
-    });
-    starter.start_with_worker(wf_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
-            }
-    }))
+    shared_tests::grpc_message_too_large().await
 }
+
+// Needs https://github.com/temporalio/temporal/pull/8143 to be rolled out in cloud to pass
+// #[tokio::test]
+// async fn priority_values_sent_to_server() {
+//     shared_tests::priority::priority_values_sent_to_server().await
+// }

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

@@ -110,7 +110,7 @@ struct GenericService<F> {
 }
 impl<F> Service<tonic::codegen::http::Request<Body>> for GenericService<F>
 where
-    F: FnMut() -> Response<Body>,
+    F: FnMut() -> BoxFuture<'static, Response<Body>>,
 {
     type Response = Response<Body>;
     type Error = Infallible;
@@ -133,7 +133,7 @@ where
             )
             .unwrap();
         let r = (self.response_maker)();
-        async move { Ok(r) }.boxed()
+        async move { Ok(r.await) }.boxed()
     }
 }
 impl<F> NamedService for GenericService<F> {
@@ -144,12 +144,12 @@ struct FakeServer {
     addr: std::net::SocketAddr,
     shutdown_tx: oneshot::Sender<()>,
     header_rx: tokio::sync::mpsc::UnboundedReceiver<String>,
-    server_handle: tokio::task::JoinHandle<()>,
+    pub server_handle: tokio::task::JoinHandle<()>,
 }
 
 async fn fake_server<F>(response_maker: F) -> FakeServer
 where
-    F: FnMut() -> Response<Body> + Clone + Send + Sync + 'static,
+    F: FnMut() -> BoxFuture<'static, Response<Body>> + Clone + Send + Sync + 'static,
 {
     let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
     let (header_tx, header_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -191,7 +191,7 @@ impl FakeServer {
 
 #[tokio::test]
 async fn timeouts_respected_one_call_fake_server() {
-    let mut fs = fake_server(|| Response::new(Body::empty())).await;
+    let mut fs = fake_server(|| async { Response::new(Body::empty()) }.boxed()).await;
     let header_rx = &mut fs.header_rx;
 
     let mut opts = get_integ_server_options();
@@ -260,7 +260,11 @@ async fn non_retryable_errors() {
         Code::Unauthenticated,
         Code::Unimplemented,
     ] {
-        let mut fs = fake_server(move || Status::new(code, "bla").into_http()).await;
+        let mut fs = fake_server(move || {
+            let s = Status::new(code, "bla").into_http();
+            async { s }.boxed()
+        })
+        .await;
 
         let mut opts = get_integ_server_options();
         let uri = format!("http://localhost:{}", fs.addr.port())
@@ -292,13 +296,13 @@ async fn retryable_errors() {
     {
         let count = Arc::new(AtomicUsize::new(0));
         let mut fs = fake_server(move || {
-            dbg!("Making resp");
             let prev = count.fetch_add(1, Ordering::Relaxed);
-            if prev < 3 {
+            let r = if prev < 3 {
                 Status::new(code, "bla").into_http()
             } else {
                 make_ok_response(RespondActivityTaskCanceledResponse::default())
-            }
+            };
+            async { r }.boxed()
         })
         .await;
 
@@ -335,7 +339,7 @@ async fn namespace_header_attached_to_relevant_calls() {
             .add_service(GenericService {
                 header_to_parse: "Temporal-Namespace",
                 header_tx,
-                response_maker: || Response::new(Body::empty()),
+                response_maker: || async { Response::new(Body::empty()) }.boxed(),
             })
             .serve_with_incoming_shutdown(
                 tokio_stream::wrappers::TcpListenerStream::new(listener),

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

@@ -1,3 +1,4 @@
+use crate::shared_tests;
 use assert_matches::assert_matches;
 use std::{
     cell::Cell,
@@ -15,13 +16,13 @@ use temporal_sdk_core_api::{
     errors::WorkerValidationError,
     worker::{PollerBehavior, WorkerConfigBuilder, WorkerVersioningStrategy},
 };
-use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowTaskFailedCause::GrpcMessageTooLarge;
 use temporal_sdk_core_protos::{
     coresdk::workflow_completion::{
         Failure, WorkflowActivationCompletion, workflow_activation_completion::Status,
     },
     temporal::api::{
-        enums::v1::EventType, failure::v1::Failure as InnerFailure,
+        enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
+        failure::v1::Failure as InnerFailure,
         history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
     },
 };
@@ -195,3 +196,8 @@ async fn oversize_grpc_message() {
             }
     }))
 }
+
+#[tokio::test]
+async fn grpc_message_too_large_test() {
+    shared_tests::grpc_message_too_large().await
+}

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

@@ -11,6 +11,7 @@ use temporal_sdk::{
     ActContext, ActExitValue, ActivityError, ActivityOptions, CancellableFuture, WfContext,
     WfExitValue, WorkflowResult,
 };
+use temporal_sdk_core_api::worker::PollerBehavior;
 use temporal_sdk_core_protos::{
     DEFAULT_ACTIVITY_TYPE, TaskToken,
     coresdk::{
@@ -1066,11 +1067,23 @@ async fn activity_can_be_cancelled_by_local_timeout() {
 
 #[tokio::test]
 #[ignore] // Runs forever, used to manually attempt to repro spurious activity completion rpc errs
+// Unfortunately there is no way to unit test this as tonic doesn't publicly expose the necessary
+// machinery to construct the right kind of error.
 async fn long_activity_timeout_repro() {
     let wf_name = "long_activity_timeout_repro";
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
+        .workflow_task_poller_behavior(PollerBehavior::Autoscaling {
+            minimum: 1,
+            maximum: 10,
+            initial: 5,
+        })
+        .activity_task_poller_behavior(PollerBehavior::Autoscaling {
+            minimum: 1,
+            maximum: 10,
+            initial: 5,
+        })
         .local_timeout_buffer_for_activities(Duration::from_secs(0));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {

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

@@ -1,112 +1,6 @@
-use std::time::Duration;
-use temporal_client::{Priority, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
-use temporal_sdk_core_protos::{
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{common, history::v1::history_event::Attributes},
-};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use crate::shared_tests;
 
 #[tokio::test]
 async fn priority_values_sent_to_server() {
-    let mut starter = CoreWfStarter::new("priority-values-sent-to-server");
-    starter.workflow_options.priority = Some(Priority { priority_key: 1 });
-    let mut worker = starter.worker().await;
-    let child_type = "child-wf";
-
-    worker.register_wf(starter.get_task_queue(), move |ctx: WfContext| async move {
-        let child = ctx.child_workflow(ChildWorkflowOptions {
-            workflow_id: format!("{}-child", ctx.task_queue()),
-            workflow_type: child_type.to_owned(),
-            options: WorkflowOptions {
-                priority: Some(Priority { priority_key: 4 }),
-                ..Default::default()
-            },
-            ..Default::default()
-        });
-
-        let started = child
-            .start(&ctx)
-            .await
-            .into_started()
-            .expect("Child should start OK");
-        let activity = ctx.activity(ActivityOptions {
-            activity_type: "echo".to_owned(),
-            input: "hello".as_json_payload().unwrap(),
-            start_to_close_timeout: Some(Duration::from_secs(5)),
-            priority: Some(Priority { priority_key: 5 }),
-            // Currently no priority info attached to eagerly run activities
-            do_not_eagerly_execute: true,
-            ..Default::default()
-        });
-        started.result().await;
-        activity.await.unwrap_ok_payload();
-        Ok(().into())
-    });
-    worker.register_wf(child_type.to_owned(), |ctx: WfContext| async move {
-        assert_eq!(
-            ctx.workflow_initial_info().priority,
-            Some(common::v1::Priority { priority_key: 4 })
-        );
-        Ok(().into())
-    });
-    worker.register_activity("echo", |ctx: ActContext, echo_me: String| async move {
-        assert_eq!(ctx.get_info().priority, Priority { priority_key: 5 });
-        Ok(echo_me)
-    });
-
-    starter
-        .start_with_worker(starter.get_task_queue(), &mut worker)
-        .await;
-    worker.run_until_done().await.unwrap();
-
-    let client = starter.get_client().await;
-    let history = client
-        .get_workflow_execution_history(starter.get_task_queue().to_owned(), None, vec![])
-        .await
-        .unwrap()
-        .history
-        .unwrap();
-    let workflow_init_event = history
-        .events
-        .iter()
-        .find_map(|e| {
-            if let Attributes::WorkflowExecutionStartedEventAttributes(e) =
-                e.attributes.as_ref().unwrap()
-            {
-                Some(e)
-            } else {
-                None
-            }
-        })
-        .unwrap();
-    assert_eq!(workflow_init_event.priority.unwrap().priority_key, 1);
-    let child_init_event = history
-        .events
-        .iter()
-        .find_map(|e| {
-            if let Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(e) =
-                e.attributes.as_ref().unwrap()
-            {
-                Some(e)
-            } else {
-                None
-            }
-        })
-        .unwrap();
-    assert_eq!(child_init_event.priority.unwrap().priority_key, 4);
-    let activity_sched_event = history
-        .events
-        .iter()
-        .find_map(|e| {
-            if let Attributes::ActivityTaskScheduledEventAttributes(e) =
-                e.attributes.as_ref().unwrap()
-            {
-                Some(e)
-            } else {
-                None
-            }
-        })
-        .unwrap();
-    assert_eq!(activity_sched_event.priority.unwrap().priority_key, 5);
+    shared_tests::priority::priority_values_sent_to_server().await
 }

package/sdk-core/tests/main.rs

@@ -5,6 +5,9 @@ extern crate rstest;
 #[macro_use]
 extern crate temporal_sdk_core_test_utils;
 
+#[cfg(test)]
+mod shared_tests;
+
 #[cfg(test)]
 mod integ_tests {
     mod activity_functions;

package/sdk-core/tests/shared_tests/mod.rs

@@ -0,0 +1,43 @@
+//! Shared tests that are meant to be run against both local dev server and cloud
+
+use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
+use temporal_sdk::WfContext;
+use temporal_sdk_core_protos::temporal::api::{
+    enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
+    history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+pub(crate) mod priority;
+
+pub(crate) async fn grpc_message_too_large() {
+    let wf_name = "oversize_grpc_message";
+    let mut starter = CoreWfStarter::new_cloud_or_local(wf_name, "")
+        .await
+        .unwrap();
+    starter.worker_config.no_remote_activities(true);
+    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())
+        }
+    });
+    starter.start_with_worker(wf_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
+            }
+    }))
+}