temporalio 0.1.1 → 0.3.0

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

@@ -1,54 +0,0 @@
-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);
-    starter.no_remote_activities();
-    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

@@ -1,92 +0,0 @@
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
-
-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);
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), changes_wf);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    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);
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), no_change_then_change_wf);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    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);
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), replay_with_change_marker_wf);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    worker.run_until_done().await.unwrap();
-}

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

@@ -1,228 +0,0 @@
-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();
-}
-
-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();
-    replay_abrupt_ending(t2).await;
-}
-
-#[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

@@ -1,94 +0,0 @@
-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);
-    starter.no_remote_activities();
-    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

@@ -1,171 +0,0 @@
-use std::collections::HashMap;
-
-use futures::StreamExt;
-use temporal_client::{
-    SignalWithStartOptions, 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);
-    starter.no_remote_activities();
-    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();
-    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");
-    starter.no_remote_activities();
-    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");
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-    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(options, WorkflowOptions::default())
-        .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");
-    starter.no_remote_activities();
-    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();
-}