temporalio 0.0.0 → 0.0.1

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

@@ -0,0 +1,131 @@
+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,
+};
+
+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);
+    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();
+    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;
+    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;
+    core.shutdown().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;
+    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);
+    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();
+    worker.run_until_done().await.unwrap();
+}

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

@@ -0,0 +1,75 @@
+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 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);
+    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(
+            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());
+}