@temporalio/core-bridge 1.5.2 → 1.7.0

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

@@ -1,3 +1,4 @@
+use crate::integ_tests::workflow_tests::patches::changes_wf;
 use assert_matches::assert_matches;
 use parking_lot::Mutex;
 use std::{collections::HashSet, sync::Arc, time::Duration};
@@ -10,6 +11,7 @@ use temporal_sdk_core_protos::{
         workflow_commands::{ScheduleActivity, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
     },
+    temporal::api::enums::v1::EventType,
     TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
@@ -130,17 +132,39 @@ async fn replay_using_wf_function() {
 }
 
 #[tokio::test]
-async fn replay_ok_ending_with_terminated_or_timed_out() {
+async fn replay_ending_wft_complete_with_commands_but_no_scheduled_started() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+
+    for i in 1..=2 {
+        let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
+        t.add_timer_fired(timer_started_event_id, i.to_string());
+        t.add_full_wf_task();
+    }
+    let func = timers_wf(3);
+    let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker.run().await.unwrap();
+}
+
+async fn replay_abrupt_ending(t: TestHistoryBuilder) {
+    let func = timers_wf(1);
+    let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker.run().await.unwrap();
+}
+#[tokio::test]
+async fn replay_ok_ending_with_terminated() {
     let mut t1 = canned_histories::single_timer("1");
     t1.add_workflow_execution_terminated();
+    replay_abrupt_ending(t1).await;
+}
+#[tokio::test]
+async fn replay_ok_ending_with_timed_out() {
     let mut t2 = canned_histories::single_timer("1");
     t2.add_workflow_execution_timed_out();
-    for t in [t1, t2] {
-        let func = timers_wf(1);
-        let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
-        worker.run().await.unwrap();
-    }
+    replay_abrupt_ending(t2).await;
 }
 
 #[rstest::rstest]
@@ -200,6 +224,51 @@ async fn multiple_histories_can_handle_dupe_run_ids() {
     worker.run().await.unwrap();
 }
 
+// Verifies SDK can decode patch markers before changing them to use json encoding
+#[tokio::test]
+async fn replay_old_patch_format() {
+    let mut worker = replay_sdk_worker([HistoryForReplay::new(
+        history_from_proto_binary("histories/old_change_marker_format.bin")
+            .await
+            .unwrap(),
+        "fake".to_owned(),
+    )]);
+    worker.register_wf("writes_change_markers", changes_wf);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn replay_ends_with_empty_wft() {
+    let core = init_core_replay_preloaded(
+        "SayHelloWorkflow",
+        [HistoryForReplay::new(
+            history_from_proto_binary("histories/ends_empty_wft_complete.bin")
+                .await
+                .unwrap(),
+            "fake".to_owned(),
+        )],
+    );
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        task.run_id,
+        vec![ScheduleActivity {
+            seq: 1,
+            activity_id: "1".to_string(),
+            activity_type: "say_hello".to_string(),
+            ..Default::default()
+        }
+        .into()],
+    ))
+    .await
+    .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert!(task.eviction_reason().is_some());
+}
+
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
     WorkflowFunction::new(move |ctx: WfContext| async move {
         for _ in 1..=num_timers {

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

@@ -14,6 +14,7 @@ const POST_RESET_SIG: &str = "post-reset";
 async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());

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

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 
 use futures::StreamExt;
-use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions};
+use temporal_client::{
+    SignalWithStartOptions, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
+};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
 };
@@ -32,6 +34,7 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
 async fn sends_signal_to_missing_wf() {
     let wf_name = "sends_signal_to_missing_wf";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), signal_sender);
 
@@ -59,7 +62,6 @@ 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"),
@@ -71,6 +73,7 @@ async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("sender", signal_sender);
     worker.register_wf("receiver", signal_receiver);
@@ -99,24 +102,24 @@ async fn sends_signal_to_other_wf() {
 #[tokio::test]
 async fn sends_signal_with_create_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
-    worker.register_wf("receiversignal", signal_with_create_wf_receiver);
+    worker.register_wf("receiver_signal", 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 options = SignalWithStartOptions::builder()
+        .task_queue(worker.inner_mut().task_queue())
+        .workflow_id("sends_signal_with_create_wf")
+        .workflow_type("receiver_signal")
+        .signal_name(SIGNAME)
+        .signal_input(vec![b"tada".into()].into_payloads())
+        .signal_header(header.into())
+        .build()
+        .unwrap();
     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()),
-        )
+        .signal_with_start_workflow_execution(options, WorkflowOptions::default())
         .await
         .expect("request succeeds.qed");
 
@@ -150,6 +153,7 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_child() {
     let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);

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

@@ -12,19 +12,12 @@ use tokio::sync::Barrier;
 async fn timer_workflow_not_sticky() {
     let wf_name = "timer_wf_not_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     starter.max_cached_workflows(0);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -47,19 +40,12 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.wft_timeout(Duration::from_secs(2));
+    starter.no_remote_activities();
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
     // If it didn't run twice it didn't time out
     assert_eq!(RUN_CT.load(Ordering::SeqCst), 2);
@@ -69,7 +55,7 @@ async fn timer_workflow_timeout_on_sticky() {
 async fn cache_miss_ok() {
     let wf_name = "cache_miss_ok";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_wft(1);
+    starter.no_remote_activities().max_wft(1);
     let mut worker = starter.worker().await;
 
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));

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

@@ -1,12 +1,13 @@
 use std::time::Duration;
-use temporal_client::WorkflowOptions;
+
 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::{
-    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -18,18 +19,11 @@ pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -37,6 +31,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -50,13 +45,14 @@ async fn timer_workflow_manual() {
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&task.run_id).await;
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -115,17 +111,10 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }

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

@@ -1,9 +1,9 @@
-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, INTEG_TEMPORALITE_USED_ENV_VAR};
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR};
+use tracing::warn;
 use uuid::Uuid;
 
 // These are initialized on the server as part of the autosetup container which we
@@ -24,9 +24,11 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     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");
+    // TODO: this should be supported in server 1.20, remove this condition when CLI is upgraded.
+    if env::var(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR).is_ok() {
+        warn!("skipping sends_upsert -- does not work on temporal dev server");
         return;
     }
 
@@ -62,10 +64,7 @@ async fn sends_upsert() {
     let txt_attr_payload = search_attrs.get(TXT_ATTR).unwrap();
     let int_attr_payload = search_attrs.get(INT_ATTR).unwrap();
     for payload in [txt_attr_payload, int_attr_payload] {
-        assert_eq!(
-            &b"json/plain".to_vec(),
-            payload.metadata.get("encoding").unwrap()
-        );
+        assert!(payload.is_json_payload());
     }
     assert_eq!(
         "goodbye",

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

@@ -42,8 +42,8 @@ use temporal_sdk_core_protos::{
     temporal::api::{failure::v1::Failure, history::v1::history_event},
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
+    init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -58,8 +58,7 @@ async fn parallel_workflows_same_queue() {
     let num_workflows = 25usize;
 
     let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows)
-            .map(|i| starter.start_wf_with_id(format!("wf-id-{}", i), WorkflowOptions::default())),
+        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{i}"))),
     )
     .await;
 
@@ -104,7 +103,7 @@ async fn parallel_workflows_same_queue() {
     for handle in handles {
         handle.await.unwrap()
     }
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -118,7 +117,7 @@ pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn workflow_lru_cache_evictions() {
     let wf_type = "workflow_lru_cache_evictions";
     let mut starter = CoreWfStarter::new(wf_type);
-    starter.max_cached_workflows(1);
+    starter.no_remote_activities().max_cached_workflows(1);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_type.to_string(), cache_evictions_wf);
 
@@ -163,7 +162,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
         std::thread::sleep(Duration::from_millis(100));
-        tcore.shutdown().await;
+        drain_pollers_and_shutdown(&tcore).await;
     });
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
@@ -415,11 +414,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             res.jobs.as_slice(),
             [
                 WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
                 },
                 WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                }
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                },
             ]
         );
         core.complete_execution(&res.run_id).await;
@@ -435,8 +434,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     wf_starter
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0)
-        .max_wft(1)
-        .wft_timeout(Duration::from_secs(1));
+        .max_wft(1);
+    wf_starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;
     let task_q = wf_starter.get_task_queue();
@@ -460,7 +459,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .unwrap();
         wf_task
     };
-    wf_starter.start_wf().await;
+    wf_starter.start_wf_with_id(wf_id.to_string()).await;
 
     // Poll and schedule the activity
     let wf_task = poll_sched_act().await;
@@ -572,7 +571,7 @@ async fn slow_completes_with_small_cache() {
     for i in 0..20 {
         worker
             .submit_wf(
-                format!("{}_{}", wf_name, i),
+                format!("{wf_name}_{i}"),
                 wf_name.to_owned(),
                 vec![],
                 WorkflowOptions::default(),

package/sdk-core/tests/main.rs

@@ -1,22 +1,12 @@
 //! 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;
+#[macro_use]
+extern crate temporal_sdk_core_test_utils;
 
 #[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;
@@ -46,7 +36,7 @@ mod integ_tests {
         let opts = get_integ_server_options();
         let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(runtime.metric_meter(), None)
+            .connect_no_namespace(runtime.metric_meter().as_deref(), None)
             .await
             .unwrap();
 

package/sdk-core/tests/runner.rs

@@ -1,62 +1,101 @@
 use anyhow::{anyhow, bail};
+use clap::Parser;
 use std::{
     env,
-    env::args,
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{TemporaliteConfigBuilder, TestServerConfigBuilder};
+use temporal_sdk_core::ephemeral_server::{
+    TemporalDevServerConfigBuilder, TestServerConfigBuilder,
+};
 use temporal_sdk_core_test_utils::{
-    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORALITE_USED_ENV_VAR,
+    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
     INTEG_TEST_SERVER_USED_ENV_VAR,
 };
 use tokio::{self, process::Command};
 
+#[derive(clap::Parser)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    /// Test harness to run. Anything defined as a `[[test]]` in core's `Cargo.toml` is valid.
+    #[arg(short, long, default_value = "integ_tests")]
+    test_name: String,
+
+    /// What kind of server to auto-launch, if any
+    #[arg(short, long, value_enum, default_value = "temporal-cli")]
+    server_kind: ServerKind,
+
+    /// Arguments to pass through to the `cargo test` command. Ex: `--release`
+    #[arg(short, long, allow_hyphen_values(true))]
+    cargo_test_args: Vec<String>,
+
+    /// The rest of the arguments will be passed through to the test harness
+    harness_args: Vec<String>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum)]
+enum ServerKind {
+    /// Use Temporal-cli
+    TemporalCLI,
+    /// Use the Java test server
+    TestServer,
+    /// Do not automatically start any server
+    External,
+}
+
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
+    let Cli {
+        test_name,
+        server_kind,
+        cargo_test_args,
+        harness_args,
+    } = Cli::parse();
     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 test_args_preamble = ["test", "--test", &test_name]
+        .into_iter()
+        .map(ToString::to_string)
+        .chain(cargo_test_args)
+        .collect::<Vec<_>>();
     let status = Command::new(&cargo)
-        .args(["test", "--test", "integ_tests", "--no-run"])
+        .args([test_args_preamble.as_slice(), &["--no-run".to_string()]].concat())
         .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![])
+    let (server, envs) = match server_kind {
+        ServerKind::TemporalCLI => {
+            let config = TemporalDevServerConfigBuilder::default()
+                .exe(default_cached_download())
+                .build()?;
+            println!("Using temporal CLI");
+            (
+                Some(config.start_server_with_output(Stdio::null()).await?),
+                vec![(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR, "true")],
+            )
+        }
+        ServerKind::TestServer => {
+            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")],
+            )
+        }
+        ServerKind::External => {
+            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() {
+        println!("Running on {}", srv.target);
         cmd.env(
             INTEG_SERVER_TARGET_ENV_VAR,
             format!("http://{}", &srv.target),
@@ -66,10 +105,10 @@ async fn main() -> Result<(), anyhow::Error> {
         .envs(envs)
         .current_dir(project_root())
         .args(
-            ["test", "--test", "integ_tests"]
+            test_args_preamble
                 .into_iter()
-                .map(ToString::to_string)
-                .chain(args),
+                .chain(["--".to_string()])
+                .chain(harness_args),
         )
         .status()
         .await?;

package/sdk-core/tests/wf_input_replay.rs

@@ -0,0 +1,32 @@
+use anyhow::Context;
+use clap::Parser;
+use futures_util::StreamExt;
+use std::path::PathBuf;
+use temporal_sdk_core::replay_wf_state_inputs;
+use temporal_sdk_core_test_utils::{init_integ_telem, wf_input_saver::read_from_file};
+
+#[derive(clap::Parser)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    /// Path to file containing the saved wf input data
+    replay_data: PathBuf,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    init_integ_telem();
+    let Cli { replay_data } = Cli::parse();
+    let replay_dat = read_from_file(replay_data)
+        .await
+        .context("while reading replay data file")?;
+
+    replay_wf_state_inputs(
+        replay_dat.config,
+        replay_dat
+            .inputs
+            .map(|r| r.expect("Reading bytes from file works").to_vec()),
+    )
+    .await;
+
+    Ok(())
+}