temporalio 0.1.1 → 0.2.0

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

@@ -1,85 +0,0 @@
-use crate::integ_tests::workflow_tests::timers::timer_wf;
-use std::{
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
-    time::Duration,
-};
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_test_utils::CoreWfStarter;
-use tokio::sync::Barrier;
-
-#[tokio::test]
-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);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    worker.run_until_done().await.unwrap();
-}
-
-static TIMED_OUT_ONCE: AtomicBool = AtomicBool::new(false);
-static RUN_CT: AtomicUsize = AtomicUsize::new(0);
-async fn timer_timeout_wf(ctx: WfContext) -> WorkflowResult<()> {
-    RUN_CT.fetch_add(1, Ordering::SeqCst);
-    let t = ctx.timer(Duration::from_secs(1));
-    if !TIMED_OUT_ONCE.load(Ordering::SeqCst) {
-        ctx.force_task_fail(anyhow::anyhow!("I AM SLAIN!"));
-        TIMED_OUT_ONCE.store(true, Ordering::SeqCst);
-    }
-    t.await;
-    Ok(().into())
-}
-
-#[tokio::test]
-async fn timer_workflow_timeout_on_sticky() {
-    // This test intentionally times out a workflow task in order to make the next task be scheduled
-    // on a not-sticky queue
-    let wf_name = "timer_workflow_timeout_on_sticky";
-    let mut starter = CoreWfStarter::new(wf_name);
-    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);
-
-    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);
-}
-
-#[tokio::test]
-async fn cache_miss_ok() {
-    let wf_name = "cache_miss_ok";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities().max_wft(1);
-    let mut worker = starter.worker().await;
-
-    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
-        barr.wait().await;
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
-
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let core = starter.get_worker().await;
-    let (r1, _) = tokio::join!(worker.run_until_done(), async move {
-        barr.wait().await;
-        core.request_workflow_eviction(&run_id);
-        // We need to signal the barrier again since the wf gets evicted and will hit it again
-        barr.wait().await;
-    });
-    r1.unwrap();
-}

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

@@ -1,120 +0,0 @@
-use std::time::Duration;
-
-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::{
-    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
-    WorkerTestHelpers,
-};
-
-pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
-    command_sink.timer(Duration::from_secs(1)).await;
-    Ok(().into())
-}
-
-#[tokio::test]
-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);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    worker.run_until_done().await.unwrap();
-}
-
-#[tokio::test]
-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,
-        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();
-    core.complete_execution(&task.run_id).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,
-        vec![
-            StartTimer {
-                seq: 0,
-                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
-            }
-            .into(),
-            StartTimer {
-                seq: 1,
-                start_to_fire_timeout: Some(prost_dur!(from_secs(10))),
-            }
-            .into(),
-        ],
-    ))
-    .await
-    .unwrap();
-    let task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        vec![
-            CancelTimer { seq: 1 }.into(),
-            CompleteWorkflowExecution { result: None }.into(),
-        ],
-    ))
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn timer_immediate_cancel_workflow() {
-    let mut starter = init_core_and_create_wf("timer_immediate_cancel_workflow").await;
-    let core = starter.get_worker().await;
-    let task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id,
-        vec![
-            start_timer_cmd(0, Duration::from_secs(1)),
-            CancelTimer { seq: 0 }.into(),
-            CompleteWorkflowExecution { result: None }.into(),
-        ],
-    ))
-    .await
-    .unwrap();
-}
-
-async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
-    let t1 = command_sink.timer(Duration::from_secs(1));
-    let t2 = command_sink.timer(Duration::from_secs(1));
-    let _ = tokio::join!(t1, t2);
-    Ok(().into())
-}
-
-#[tokio::test]
-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);
-
-    starter.start_with_worker(wf_name, &mut worker).await;
-    worker.run_until_done().await.unwrap();
-}

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

@@ -1,77 +0,0 @@
-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_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
-// use for integration tests.
-static TXT_ATTR: &str = "CustomTextField";
-static INT_ATTR: &str = "CustomIntField";
-
-async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.upsert_search_attributes([
-        (TXT_ATTR.to_string(), "goodbye".as_json_payload().unwrap()),
-        (INT_ATTR.to_string(), 98.as_json_payload().unwrap()),
-    ]);
-    Ok(().into())
-}
-
-#[tokio::test]
-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;
-    // 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;
-    }
-
-    worker.register_wf(wf_name, search_attr_updater);
-    let run_id = worker
-        .submit_wf(
-            wf_id.to_string(),
-            wf_name,
-            vec![],
-            WorkflowOptions {
-                search_attributes: Some(HashMap::from([
-                    (TXT_ATTR.to_string(), "hello".as_json_payload().unwrap()),
-                    (INT_ATTR.to_string(), 1.as_json_payload().unwrap()),
-                ])),
-                ..Default::default()
-            },
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-
-    let search_attrs = starter
-        .get_client()
-        .await
-        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
-        .await
-        .unwrap()
-        .workflow_execution_info
-        .unwrap()
-        .search_attributes
-        .unwrap()
-        .indexed_fields;
-    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_eq!(
-        "goodbye",
-        String::from_json_payload(txt_attr_payload).unwrap()
-    );
-    assert_eq!(98, usize::from_json_payload(int_attr_payload).unwrap());
-}