temporalio 0.0.0 → 0.0.2

data/bridge/sdk-core/tests/integ_tests/workflow_tests/modify_wf_properties.rs

@@ -0,0 +1,53 @@
+use temporal_client::WorkflowClientTrait;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+static FIELD_A: &str = "cat_name";
+static FIELD_B: &str = "cute_level";
+
+async fn memo_upserter(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.upsert_memo([
+        (FIELD_A.to_string(), "enchi".as_json_payload().unwrap()),
+        (FIELD_B.to_string(), 9001.as_json_payload().unwrap()),
+    ]);
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_modify_wf_props() {
+    let wf_name = "can_upsert_memo";
+    let wf_id = Uuid::new_v4();
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name, memo_upserter);
+    let run_id = worker
+        .submit_wf(wf_id.to_string(), wf_name, vec![], Default::default())
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let memo = starter
+        .get_client()
+        .await
+        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+        .await
+        .unwrap()
+        .workflow_execution_info
+        .unwrap()
+        .memo
+        .unwrap()
+        .fields;
+    let catname = memo.get(FIELD_A).unwrap();
+    let cuteness = memo.get(FIELD_B).unwrap();
+    for payload in [catname, cuteness] {
+        assert_eq!(
+            &b"json/plain".to_vec(),
+            payload.metadata.get("encoding").unwrap()
+        );
+    }
+    assert_eq!("enchi", String::from_json_payload(catname).unwrap());
+    assert_eq!(9001, usize::from_json_payload(cuteness).unwrap());
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/patches.rs

@@ -0,0 +1,113 @@
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+const MY_PATCH_ID: &str = "integ_test_change_name";
+
+pub async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
+    if ctx.patched(MY_PATCH_ID) {
+        ctx.timer(Duration::from_millis(100)).await;
+    } else {
+        ctx.timer(Duration::from_millis(200)).await;
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+    if ctx.patched(MY_PATCH_ID) {
+        ctx.timer(Duration::from_millis(100)).await;
+    } else {
+        ctx.timer(Duration::from_millis(200)).await;
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn writes_change_markers() {
+    let wf_name = "writes_change_markers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), changes_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+/// This one simulates a run as if the worker had the "old" code, then it fails at the end as
+/// a cheapo way of being re-run, at which point it runs with change checks and the "new" code.
+static DID_DIE: AtomicBool = AtomicBool::new(false);
+pub async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<()> {
+    if DID_DIE.load(Ordering::Acquire) {
+        assert!(!ctx.patched(MY_PATCH_ID));
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+    ctx.timer(Duration::from_millis(200)).await;
+    if DID_DIE.load(Ordering::Acquire) {
+        assert!(!ctx.patched(MY_PATCH_ID));
+    }
+    ctx.timer(Duration::from_millis(200)).await;
+
+    if !DID_DIE.load(Ordering::Acquire) {
+        DID_DIE.store(true, Ordering::Release);
+        ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn can_add_change_markers() {
+    let wf_name = "can_add_change_markers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), no_change_then_change_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+static DID_DIE_2: AtomicBool = AtomicBool::new(false);
+pub async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResult<()> {
+    assert!(ctx.patched(MY_PATCH_ID));
+    ctx.timer(Duration::from_millis(200)).await;
+    if !DID_DIE_2.load(Ordering::Acquire) {
+        DID_DIE_2.store(true, Ordering::Release);
+        ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn replaying_with_patch_marker() {
+    let wf_name = "replaying_with_patch_marker";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), replay_with_change_marker_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/replay.rs

@@ -0,0 +1,223 @@
+use assert_matches::assert_matches;
+use parking_lot::Mutex;
+use std::{collections::HashSet, sync::Arc, time::Duration};
+use temporal_sdk::{interceptors::WorkerInterceptor, WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core::replay::{HistoryFeeder, HistoryForReplay};
+use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_activation::remove_from_cache::EvictionReason,
+        workflow_commands::{ScheduleActivity, StartTimer},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
+};
+use temporal_sdk_core_test_utils::{
+    canned_histories, history_from_proto_binary, init_core_replay_preloaded, replay_sdk_worker,
+    replay_sdk_worker_stream, WorkerTestHelpers,
+};
+use tokio::join;
+
+fn test_hist_to_replay(t: TestHistoryBuilder) -> HistoryForReplay {
+    let hi = t.get_full_history_info().unwrap().into();
+    HistoryForReplay::new(hi, "fake".to_string())
+}
+
+#[tokio::test]
+async fn timer_workflow_replay() {
+    let core = init_core_replay_preloaded(
+        "timer_workflow_replay",
+        [HistoryForReplay::new(
+            history_from_proto_binary("histories/timer_workflow_history.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![StartTimer {
+            seq: 0,
+            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
+        }
+        .into()],
+    ))
+    .await
+    .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    // Verify that an in-progress poll is interrupted by completion finishing processing history
+    let act_poll_fut = async {
+        assert_matches!(
+            core.poll_activity_task().await,
+            Err(PollActivityError::ShutDown)
+        );
+    };
+    let poll_fut = async {
+        let evict_task = core
+            .poll_workflow_activation()
+            .await
+            .expect("Should be an eviction activation");
+        assert!(evict_task.eviction_reason().is_some());
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(evict_task.run_id))
+            .await
+            .unwrap();
+        assert_matches!(
+            core.poll_workflow_activation().await,
+            Err(PollWfError::ShutDown)
+        );
+    };
+    let complete_fut = async {
+        core.complete_execution(&task.run_id).await;
+    };
+    join!(act_poll_fut, poll_fut, complete_fut);
+
+    // Subsequent polls should still return shutdown
+    assert_matches!(
+        core.poll_workflow_activation().await,
+        Err(PollWfError::ShutDown)
+    );
+
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn workflow_nondeterministic_replay() {
+    let core = init_core_replay_preloaded(
+        "timer_workflow_replay",
+        [HistoryForReplay::new(
+            history_from_proto_binary("histories/timer_workflow_history.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: 0,
+            activity_id: "0".to_string(),
+            activity_type: "fake_act".to_string(),
+            ..Default::default()
+        }
+        .into()],
+    ))
+    .await
+    .unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_eq!(task.eviction_reason(), Some(EvictionReason::Nondeterminism));
+    // Complete eviction
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+    // Call shutdown explicitly because we saw a nondeterminism eviction
+    core.shutdown().await;
+    assert_matches!(
+        core.poll_workflow_activation().await,
+        Err(PollWfError::ShutDown)
+    );
+}
+
+#[tokio::test]
+async fn replay_using_wf_function() {
+    let num_timers = 10;
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let func = timers_wf(num_timers);
+    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_or_timed_out() {
+    let mut t1 = canned_histories::single_timer("1");
+    t1.add_workflow_execution_terminated();
+    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();
+    }
+}
+
+#[rstest::rstest]
+#[tokio::test]
+async fn multiple_histories_replay(#[values(false, true)] use_feeder: bool) {
+    let num_timers = 10;
+    let seq_timer_wf = timers_wf(num_timers);
+    let one_timer_wf = timers_wf(1);
+    let mut one_timer_hist = canned_histories::single_timer("1");
+    one_timer_hist.set_wf_type("onetimer");
+    let mut seq_timer_hist = canned_histories::long_sequential_timers(num_timers as usize);
+    seq_timer_hist.set_wf_type("seqtimer");
+    let (feeder, stream) = HistoryFeeder::new(1);
+    let mut worker = if use_feeder {
+        replay_sdk_worker_stream(stream)
+    } else {
+        replay_sdk_worker([
+            test_hist_to_replay(one_timer_hist.clone()),
+            test_hist_to_replay(seq_timer_hist.clone()),
+        ])
+    };
+    let runs_ctr_i = UniqueRunsCounter::default();
+    let runs_ctr = runs_ctr_i.runs.clone();
+    worker.set_worker_interceptor(Box::new(runs_ctr_i));
+    worker.register_wf("onetimer", one_timer_wf);
+    worker.register_wf("seqtimer", seq_timer_wf);
+
+    if use_feeder {
+        let feed_fut = async move {
+            feeder
+                .feed(test_hist_to_replay(one_timer_hist))
+                .await
+                .unwrap();
+            feeder
+                .feed(test_hist_to_replay(seq_timer_hist))
+                .await
+                .unwrap();
+        };
+        let (_, runr) = join!(feed_fut, worker.run());
+        runr.unwrap();
+    } else {
+        worker.run().await.unwrap();
+    }
+    assert_eq!(runs_ctr.lock().len(), 2);
+}
+
+#[tokio::test]
+async fn multiple_histories_can_handle_dupe_run_ids() {
+    let mut hist1 = canned_histories::single_timer("1");
+    hist1.set_wf_type("onetimer");
+    let mut worker = replay_sdk_worker([
+        test_hist_to_replay(hist1.clone()),
+        test_hist_to_replay(hist1.clone()),
+        test_hist_to_replay(hist1),
+    ]);
+    worker.register_wf("onetimer", timers_wf(1));
+    worker.run().await.unwrap();
+}
+
+fn timers_wf(num_timers: u32) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        for _ in 1..=num_timers {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    })
+}
+
+#[derive(Default)]
+struct UniqueRunsCounter {
+    runs: Arc<Mutex<HashSet<String>>>,
+}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for UniqueRunsCounter {
+    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
+        self.runs.lock().insert(completion.run_id.clone());
+    }
+
+    fn on_shutdown(&self, _: &Worker) {}
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/resets.rs

@@ -0,0 +1,93 @@
+use futures::StreamExt;
+use std::{sync::Arc, time::Duration};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_sdk::WfContext;
+use temporal_sdk_core_protos::temporal::api::{
+    common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
+};
+use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
+use tokio::sync::Notify;
+
+const POST_RESET_SIG: &str = "post-reset";
+
+#[tokio::test]
+async fn reset_workflow() {
+    let wf_name = "reset_me_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.fetch_results = false;
+    let notify = Arc::new(Notify::new());
+
+    let wf_notify = notify.clone();
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+        let notify = wf_notify.clone();
+        async move {
+            // Make a couple workflow tasks
+            ctx.timer(Duration::from_secs(1)).await;
+            ctx.timer(Duration::from_secs(1)).await;
+            // Tell outer scope to send the reset
+            notify.notify_one();
+            let _ = ctx
+                .make_signal_channel(POST_RESET_SIG)
+                .next()
+                .await
+                .unwrap();
+            Ok(().into())
+        }
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    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
+            .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()
+            })
+            .await
+            .unwrap();
+
+        // Unblock the workflow by sending the signal. Run ID will have changed after reset so
+        // we use empty run id
+        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
+            .get_untyped_workflow_handle(wf_name.to_owned(), "")
+            .get_workflow_result(Default::default())
+            .await
+            .unwrap();
+        starter.shutdown().await;
+    };
+    let run_fut = worker.run_until_done();
+    let (_, rr) = tokio::join!(resetter_fut, run_fut);
+    rr.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -0,0 +1,167 @@
+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, temporal::api::common::v1::Payload};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+const SIGNAME: &str = "signame";
+const RECEIVER_WFID: &str = "sends-signal-signal-receiver";
+
+async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
+    let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
+        .unwrap()
+        .to_owned();
+    let mut dat = SignalWorkflowOptions::new(RECEIVER_WFID, run_id, SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let sigres = ctx.signal_workflow(dat).await;
+    if ctx.get_args().get(1).is_some() {
+        // We expect failure
+        assert!(sigres.is_err());
+    } else {
+        sigres.unwrap();
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_missing_wf() {
+    let wf_name = "sends_signal_to_missing_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), signal_sender);
+
+    worker
+        .submit_wf(
+            wf_name,
+            wf_name,
+            vec![Uuid::new_v4().to_string().into(), [1].into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    assert_eq!(&res.input, &[b"hi!".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
+    Ok(().into())
+}
+
+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())
+}
+
+#[tokio::test]
+async fn sends_signal_to_other_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    let mut worker = starter.worker().await;
+    worker.register_wf("sender", signal_sender);
+    worker.register_wf("receiver", signal_receiver);
+
+    let receiver_run_id = worker
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker
+        .submit_wf(
+            "sends-signal-sender",
+            "sender",
+            vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn sends_signal_with_create_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    let mut worker = starter.worker().await;
+    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");
+
+    worker.started_workflows.lock().push(WorkflowExecutionInfo {
+        namespace: client.namespace().to_string(),
+        workflow_id: "sends_signal_with_create_wf".to_owned(),
+        run_id: Some(res.run_id.clone()),
+    });
+
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
+    let started_child = ctx
+        .child_workflow(ChildWorkflowOptions {
+            workflow_id: "my_precious_child".to_string(),
+            workflow_type: "child_receiver".to_string(),
+            ..Default::default()
+        })
+        .start(&ctx)
+        .await
+        .into_started()
+        .expect("Must start ok");
+    let mut sig = Signal::new(SIGNAME, [b"hi!"]);
+    sig.data.with_header("tupac", b"shakur");
+    started_child.signal(&ctx, sig).await.unwrap();
+    started_child.result().await.status.unwrap();
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_child() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    let mut worker = starter.worker().await;
+    worker.register_wf("child_signaler", signals_child);
+    worker.register_wf("child_receiver", signal_receiver);
+
+    worker
+        .submit_wf(
+            "sends-signal-to-child",
+            "child_signaler",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}