@temporalio/core-bridge 1.1.0 → 1.4.0

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

@@ -189,10 +189,10 @@ async fn local_act_retry_timer_backoff() {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     // We want two local backoffs that are short. Third backoff will use timer
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 4,
                     non_retryable_error_types: vec![],
                 },
@@ -318,9 +318,9 @@ async fn cancel_after_act_starts(
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(bo_dur.into()),
+                initial_interval: Some(bo_dur.try_into().unwrap()),
                 backoff_coefficient: 1.,
-                maximum_interval: Some(bo_dur.into()),
+                maximum_interval: Some(bo_dur.try_into().unwrap()),
                 // Retry forever until cancelled
                 ..Default::default()
             },
@@ -410,9 +410,9 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 4,
                     non_retryable_error_types: vec![],
                 },
@@ -467,9 +467,9 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 40,
                     non_retryable_error_types: vec![],
                 },
@@ -538,9 +538,9 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_micros(15).into()),
+                initial_interval: Some(prost_dur!(from_micros(15))),
                 backoff_coefficient: 1_000.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },
@@ -551,9 +551,9 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_millis(15).into()),
+                initial_interval: Some(prost_dur!(from_millis(15))),
                 backoff_coefficient: 10.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },
@@ -593,9 +593,9 @@ async fn repro_nondeterminism_with_timer_bug() {
             activity_type: "delay".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_micros(15).into()),
+                initial_interval: Some(prost_dur!(from_micros(15))),
                 backoff_coefficient: 1_000.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },

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

@@ -1,7 +1,6 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_sdk::{WfContext, Worker, WorkflowFunction};
-use temporal_sdk_core::telemetry_init;
 use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -12,8 +11,7 @@ use temporal_sdk_core_protos::{
     DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    canned_histories, get_integ_telem_options, history_from_proto_binary,
-    init_core_replay_preloaded, WorkerTestHelpers,
+    canned_histories, history_from_proto_binary, init_core_replay_preloaded, WorkerTestHelpers,
 };
 use tokio::join;
 
@@ -30,7 +28,7 @@ async fn timer_workflow_replay() {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_secs(1).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
         }
         .into()],
     ))
@@ -101,7 +99,6 @@ async fn workflow_nondeterministic_replay() {
 
 #[tokio::test]
 async fn replay_using_wf_function() {
-    telemetry_init(&get_integ_telem_options()).unwrap();
     let num_timers = 10;
     let t = canned_histories::long_sequential_timers(num_timers as usize);
     let func = timers_wf(num_timers);
@@ -118,7 +115,6 @@ async fn replay_ok_ending_with_terminated_or_timed_out() {
     t1.add_workflow_execution_terminated();
     let mut t2 = canned_histories::single_timer("1");
     t2.add_workflow_execution_timed_out();
-    telemetry_init(&get_integ_telem_options()).unwrap();
     for t in [t1, t2] {
         let func = timers_wf(1);
         let (worker, _) = init_core_replay_preloaded(

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

@@ -46,13 +46,12 @@ async fn reset_workflow() {
         .await
         .unwrap();
 
-    let client = starter.get_client().await;
+    let mut client = starter.get_client().await;
+    let client = Arc::make_mut(&mut client);
     let resetter_fut = async {
         notify.notified().await;
         // Do the reset
         client
-            .get_client()
-            .raw_retry_client()
             .reset_workflow_execution(ResetWorkflowExecutionRequest {
                 namespace: NAMESPACE.to_owned(),
                 workflow_execution: Some(WorkflowExecution {
@@ -69,15 +68,16 @@ async fn reset_workflow() {
 
         // Unblock the workflow by sending the signal. Run ID will have changed after reset so
         // we use empty run id
-        client
-            .signal_workflow_execution(
-                wf_name.to_owned(),
-                "".to_owned(),
-                POST_RESET_SIG.to_owned(),
-                None,
-            )
-            .await
-            .unwrap();
+        WorkflowClientTrait::signal_workflow_execution(
+            client,
+            wf_name.to_owned(),
+            "".to_owned(),
+            POST_RESET_SIG.to_owned(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
 
         // Wait for the now-reset workflow to finish
         client

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

@@ -1,9 +1,11 @@
+use std::collections::HashMap;
+
 use futures::StreamExt;
 use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
 };
-use temporal_sdk_core_protos::coresdk::IntoPayloadsExt;
+use temporal_sdk_core_protos::{coresdk::IntoPayloadsExt, temporal::api::common::v1::Payload};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
@@ -57,7 +59,12 @@ async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
 
 async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
     let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    println!("HEADER: {:?}", res.headers);
     assert_eq!(&res.input, &[b"tada".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
     Ok(().into())
 }
 
@@ -96,15 +103,19 @@ async fn sends_signal_with_create_wf() {
     worker.register_wf("receiversignal", signal_with_create_wf_receiver);
 
     let client = starter.get_client().await;
+    let mut header: HashMap<String, Payload> = HashMap::new();
+    header.insert("tupac".into(), "shakur".into());
     let res = client
         .signal_with_start_workflow_execution(
             None,
             worker.inner_mut().task_queue().to_owned(),
             "sends_signal_with_create_wf".to_owned(),
             "receiversignal".to_owned(),
+            None,
             WorkflowOptions::default(),
             SIGNAME.to_owned(),
             vec![b"tada".into()].into_payloads(),
+            Some(header.into()),
         )
         .await
         .expect("request succeeds.qed");

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

@@ -42,7 +42,7 @@ async fn timer_workflow_manual() {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_secs(1).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
         }
         .into()],
     ))
@@ -63,12 +63,12 @@ async fn timer_cancel_workflow() {
         vec![
             StartTimer {
                 seq: 0,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_secs(10).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_secs(10))),
             }
             .into(),
         ],

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

@@ -1,8 +1,9 @@
-use std::collections::HashMap;
+use log::warn;
+use std::{collections::HashMap, env};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORALITE_USED_ENV_VAR};
 use uuid::Uuid;
 
 // These are initialized on the server as part of the autosetup container which we
@@ -24,6 +25,11 @@ async fn sends_upsert() {
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
     let mut worker = starter.worker().await;
+    if env::var(INTEG_TEMPORALITE_USED_ENV_VAR).is_ok() {
+        warn!("skipping sends_upsert -- does not work on temporalite");
+        return;
+    }
+
     worker.register_wf(wf_name, search_attr_updater);
     let run_id = worker
         .submit_wf(

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

@@ -223,7 +223,7 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_millis(200).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_millis(200))),
         }
         .into()],
     ))
@@ -279,6 +279,7 @@ async fn signal_workflow() {
             res.run_id.to_string(),
             signal_id_1.to_string(),
             None,
+            None,
         )
         .await
         .unwrap();
@@ -288,6 +289,7 @@ async fn signal_workflow() {
             res.run_id.to_string(),
             signal_id_2.to_string(),
             None,
+            None,
         )
         .await
         .unwrap();
@@ -345,7 +347,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             res.run_id,
             vec![StartTimer {
                 seq: 0,
-                start_to_fire_timeout: Some(Duration::from_millis(10).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(10))),
             }
             .into()],
         ))
@@ -374,6 +376,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
                     res.run_id.to_string(),
                     signal_id_1.to_string(),
                     None,
+                    None,
                 )
                 .await
                 .unwrap();
@@ -458,7 +461,13 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     // Send the signals to the server & resolve activity -- sometimes this happens too fast
     sleep(Duration::from_millis(200)).await;
     client
-        .signal_workflow_execution(wf_id.to_string(), rid, signal_at_start.to_string(), None)
+        .signal_workflow_execution(
+            wf_id.to_string(),
+            rid,
+            signal_at_start.to_string(),
+            None,
+            None,
+        )
         .await
         .unwrap();
     // Complete activity successfully.
@@ -470,7 +479,13 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     .unwrap();
     let rid = wf_task.run_id.clone();
     client
-        .signal_workflow_execution(wf_id.to_string(), rid, signal_at_complete.to_string(), None)
+        .signal_workflow_execution(
+            wf_id.to_string(),
+            rid,
+            signal_at_complete.to_string(),
+            None,
+            None,
+        )
         .await
         .unwrap();
     // Now poll again, it will be an eviction b/c non-sticky mode.

package/sdk-core/tests/load_tests.rs

@@ -35,13 +35,13 @@ async fn activity_load() {
             let activity = ActivityOptions {
                 activity_id: Some(activity_id.to_string()),
                 activity_type: "test_activity".to_string(),
-                input: Default::default(),
                 task_queue,
                 schedule_to_start_timeout: Some(activity_timeout),
                 start_to_close_timeout: Some(activity_timeout),
                 schedule_to_close_timeout: Some(activity_timeout),
                 heartbeat_timeout: Some(activity_timeout),
                 cancellation_type: ActivityCancellationType::TryCancel,
+                ..Default::default()
             };
             let res = ctx.activity(activity).await.unwrap_ok_payload();
             assert_eq!(res.data, payload_dat);
@@ -175,6 +175,7 @@ async fn workflow_load() {
                         "".to_string(),
                         SIGNAME.to_string(),
                         None,
+                        None,
                     )
                 })
                 .collect();

package/sdk-core/tests/main.rs

@@ -1,11 +1,28 @@
 //! Integration tests
+//!
+//! Note that integ tests which want to use the server (nearly all of them) *need* to use the
+//! `#[rstest]` macro and accept the TODO fixture to support auto setup & teardown of ephemeral
+//! local servers.
+
+#[macro_use]
+extern crate rstest;
 
 #[cfg(test)]
 mod integ_tests {
+    #[macro_export]
+    macro_rules! prost_dur {
+        ($dur_call:ident $args:tt) => {
+            std::time::Duration::$dur_call$args
+                .try_into()
+                .expect("test duration fits")
+        };
+    }
     mod client_tests;
+    mod ephemeral_server_tests;
     mod heartbeat_tests;
     mod polling_tests;
     mod queries_tests;
+    mod visibility_tests;
     mod workflow_tests;
 
     use std::str::FromStr;

package/sdk-core/tests/runner.rs

@@ -0,0 +1,93 @@
+use anyhow::{anyhow, bail};
+use std::{
+    env,
+    env::args,
+    path::{Path, PathBuf},
+    process::Stdio,
+};
+use temporal_sdk_core::ephemeral_server::{TemporaliteConfigBuilder, TestServerConfigBuilder};
+use temporal_sdk_core_test_utils::{
+    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORALITE_USED_ENV_VAR,
+    INTEG_TEST_SERVER_USED_ENV_VAR,
+};
+use tokio::{self, process::Command};
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+    let server_type = env::var("INTEG_SERVER_TYPE")
+        .unwrap_or_else(|_| "temporalite".to_string())
+        .to_lowercase();
+    // Try building first, so that we error early on build failures & don't start server
+    let status = Command::new(&cargo)
+        .args(["test", "--test", "integ_tests", "--no-run"])
+        .status()
+        .await?;
+    if !status.success() {
+        bail!("Building integration tests failed!");
+    }
+
+    // Move to clap if we start doing any more complicated input
+    let (server, envs) = if server_type == "test-server" {
+        let config = TestServerConfigBuilder::default()
+            .exe(default_cached_download())
+            .build()?;
+        println!("Using java test server");
+        (
+            Some(config.start_server_with_output(Stdio::null()).await?),
+            vec![(INTEG_TEST_SERVER_USED_ENV_VAR, "true")],
+        )
+    } else if server_type == "temporalite" {
+        let config = TemporaliteConfigBuilder::default()
+            .exe(default_cached_download())
+            .build()?;
+        println!("Using temporalite");
+        (
+            Some(config.start_server_with_output(Stdio::null()).await?),
+            vec![(INTEG_TEMPORALITE_USED_ENV_VAR, "true")],
+        )
+    } else {
+        println!("Not starting up a server. One should be running already.");
+        (None, vec![])
+    };
+
+    // Run the integ tests, passing through arguments
+    let mut args = args();
+    // Shift off binary name
+    args.next();
+    let mut cmd = Command::new(&cargo);
+    if let Some(srv) = server.as_ref() {
+        cmd.env(
+            INTEG_SERVER_TARGET_ENV_VAR,
+            format!("http://{}", &srv.target),
+        );
+    }
+    let status = cmd
+        .envs(envs)
+        .current_dir(project_root())
+        .args(
+            ["test", "--test", "integ_tests"]
+                .into_iter()
+                .map(ToString::to_string)
+                .chain(args),
+        )
+        .status()
+        .await?;
+
+    if let Some(mut srv) = server {
+        srv.shutdown().await?;
+    }
+    if status.success() {
+        Ok(())
+    } else {
+        Err(anyhow!("Integ tests failed!"))
+    }
+}
+
+fn project_root() -> PathBuf {
+    Path::new(&env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(1)
+        .unwrap()
+        .to_path_buf()
+}