temporalio 0.0.0 → 0.0.2

data/bridge/sdk-core/tests/integ_tests/client_tests.rs

@@ -0,0 +1,36 @@
+use std::time::Duration;
+use temporal_client::{RetryClient, WorkflowClientTrait, WorkflowService};
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
+
+#[tokio::test]
+async fn can_use_retry_client() {
+    // Not terribly interesting by itself but can be useful for manually inspecting metrics etc
+    let mut core = CoreWfStarter::new("retry_client");
+    let retry_client = core.get_client().await;
+    for _ in 0..10 {
+        retry_client.list_namespaces().await.unwrap();
+        tokio::time::sleep(Duration::from_millis(10)).await;
+    }
+}
+
+#[tokio::test]
+async fn can_use_retry_raw_client() {
+    let opts = get_integ_server_options();
+    let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
+    let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
+    retry_client
+        .describe_namespace(DescribeNamespaceRequest {
+            namespace: NAMESPACE.to_string(),
+            ..Default::default()
+        })
+        .await
+        .unwrap();
+}
+
+#[tokio::test]
+async fn calls_get_system_info() {
+    let opts = get_integ_server_options();
+    let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
+    assert!(raw_client.get_client().capabilities().is_some());
+}

data/bridge/sdk-core/tests/integ_tests/ephemeral_server_tests.rs

@@ -0,0 +1,128 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
+use temporal_sdk_core::ephemeral_server::{
+    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
+    TestServerConfigBuilder,
+};
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use temporal_sdk_core_test_utils::{default_cached_download, NAMESPACE};
+use url::Url;
+
+#[tokio::test]
+async fn temporalite_default() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn temporalite_fixed() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(fixed_cached_download("v0.1.1"))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn temporalite_shutdown_port_reuse() {
+    // Start, test shutdown, do again immediately on same port to ensure we can
+    // reuse after shutdown
+    let config = TemporaliteConfigBuilder::default()
+        .exe(default_cached_download())
+        .port(Some(10123))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_default() {
+    let config = TestServerConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_fixed() {
+    let config = TestServerConfigBuilder::default()
+        .exe(fixed_cached_download("v1.16.0"))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_shutdown_port_reuse() {
+    // Start, test shutdown, do again immediately on same port to ensure we can
+    // reuse after shutdown
+    let config = TestServerConfigBuilder::default()
+        .exe(default_cached_download())
+        .port(Some(10124))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+fn fixed_cached_download(version: &str) -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Fixed(version.to_string()),
+        dest_dir: None,
+    }
+}
+
+async fn assert_ephemeral_server(server: &EphemeralServer) {
+    // Connect and describe namespace
+    let mut client = ClientOptionsBuilder::default()
+        .identity("integ_tester".to_string())
+        .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
+        .client_name("temporal-core".to_string())
+        .client_version("0.1.0".to_string())
+        .build()
+        .unwrap()
+        .connect_no_namespace(None, None)
+        .await
+        .unwrap();
+    let resp = client
+        .describe_namespace(DescribeNamespaceRequest {
+            namespace: NAMESPACE.to_string(),
+            ..Default::default()
+        })
+        .await
+        .unwrap();
+    assert!(resp.into_inner().namespace_info.unwrap().name == "default");
+
+    // If it has test service, make sure we can use it too
+    if server.has_test_service {
+        let resp = client.get_current_time(()).await.unwrap();
+        // Make sure it's within 5 mins of now
+        let resp_seconds = resp.get_ref().time.as_ref().unwrap().seconds as u64;
+        let curr_seconds = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        assert!(curr_seconds - 300 < resp_seconds && curr_seconds + 300 > resp_seconds);
+    }
+}

data/bridge/sdk-core/tests/integ_tests/heartbeat_tests.rs

@@ -0,0 +1,221 @@
+use assert_matches::assert_matches;
+use std::time::Duration;
+use temporal_client::{WfClientExt, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_result::{
+            self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
+        },
+        activity_task::activity_task,
+        workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
+        workflow_commands::{ActivityCancellationType, ScheduleActivity},
+        workflow_completion::WorkflowActivationCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
+    },
+    temporal::api::{
+        common::v1::{Payload, RetryPolicy},
+        enums::v1::TimeoutType,
+    },
+};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+};
+use tokio::time::sleep;
+
+#[tokio::test]
+async fn activity_heartbeat() {
+    let mut starter = init_core_and_create_wf("activity_heartbeat").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation().await.unwrap();
+    // Complete workflow task and schedule activity
+    core.complete_workflow_activation(
+        schedule_activity_cmd(
+            0,
+            task_q,
+            activity_id,
+            ActivityCancellationType::TryCancel,
+            Duration::from_secs(60),
+            Duration::from_secs(1),
+        )
+        .into_completion(task.run_id),
+    )
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled with correct parameters
+    let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(
+        task.variant,
+        Some(activity_task::Variant::Start(start_activity)) => {
+            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+        }
+    );
+    // Heartbeat timeout is set to 1 second, this loop is going to send heartbeat every 100ms.
+    // Activity shouldn't timeout since we are sending heartbeats regularly, however if we didn't
+    // send heartbeats activity would have timed out as it takes 2 sec to execute this loop.
+    for _ in 0u8..20 {
+        sleep(Duration::from_millis(100)).await;
+        core.record_activity_heartbeat(ActivityHeartbeat {
+            task_token: task.task_token.clone(),
+            details: vec![],
+        });
+    }
+
+    let response_payload = Payload {
+        data: b"hello ".to_vec(),
+        metadata: Default::default(),
+    };
+    // Complete activity successfully.
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: task.task_token,
+        result: Some(ActivityExecutionResult::ok(response_payload.clone())),
+    })
+    .await
+    .unwrap();
+    // Poll workflow task and verify that activity has succeeded.
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution {
+                    status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
+                     ..})}
+                )),
+            },
+        ] => {
+            assert_eq!(*seq, 0);
+            assert_eq!(r, &response_payload);
+        }
+    );
+    core.complete_execution(&task.run_id).await;
+}
+
+#[tokio::test]
+async fn many_act_fails_with_heartbeats() {
+    let mut starter = init_core_and_create_wf("many_act_fails_with_heartbeats").await;
+    let core = starter.get_worker().await;
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation().await.unwrap();
+    // Complete workflow task and schedule activity
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        ScheduleActivity {
+            seq: 0,
+            activity_id: activity_id.to_string(),
+            activity_type: "test_act".to_string(),
+            task_queue: starter.get_task_queue().to_string(),
+            start_to_close_timeout: Some(prost_dur!(from_secs(30))),
+            retry_policy: Some(RetryPolicy {
+                initial_interval: Some(prost_dur!(from_millis(10))),
+                backoff_coefficient: 1.0,
+                maximum_attempts: 4,
+                ..Default::default()
+            }),
+            heartbeat_timeout: Some(prost_dur!(from_secs(1))),
+            ..Default::default()
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+
+    // Multiple times, poll for the activity, heartbeat, and then immediately fail
+    // Poll activity and verify that it's been scheduled with correct parameters
+    for i in 0u8..=3 {
+        let task = core.poll_activity_task().await.unwrap();
+        let start_t = assert_matches!(task.variant, Some(activity_task::Variant::Start(s)) => s);
+
+        core.record_activity_heartbeat(ActivityHeartbeat {
+            task_token: task.task_token.clone(),
+            details: vec![[i].into()],
+        });
+
+        let compl = if i == 3 {
+            // Verify last hb was recorded
+            assert_eq!(start_t.heartbeat_details, [[2].into()]);
+            ActivityTaskCompletion {
+                task_token: task.task_token,
+                result: Some(ActivityExecutionResult::ok("passed".into())),
+            }
+        } else {
+            if i != 0 {
+                assert_eq!(start_t.heartbeat_details, [[i - 1].into()]);
+            }
+            ActivityTaskCompletion {
+                task_token: task.task_token,
+                result: Some(ActivityExecutionResult::fail(format!("Die on {i}").into())),
+            }
+        };
+        core.complete_activity_task(compl).await.unwrap();
+    }
+    let task = core.poll_workflow_activation().await.unwrap();
+
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                ResolveActivity {
+                    result: Some(ActivityResolution {
+                        status: Some(act_res::Status::Completed(activity_result::Success { .. })),
+                        ..
+                    }),
+                    ..
+                }
+            )),
+        },]
+    );
+    core.complete_execution(&task.run_id).await;
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn activity_doesnt_heartbeat_hits_timeout_then_completes() {
+    let wf_name = "activity_doesnt_heartbeat_hits_timeout_then_completes";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move {
+            sleep(Duration::from_secs(4)).await;
+            Ok(echo_me)
+        },
+    );
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let res = ctx
+            .activity(ActivityOptions {
+                activity_type: "echo_activity".to_string(),
+                input: "hi!".as_json_payload().expect("serializes fine"),
+                start_to_close_timeout: Some(Duration::from_secs(10)),
+                heartbeat_timeout: Some(Duration::from_secs(2)),
+                retry_policy: Some(RetryPolicy {
+                    maximum_attempts: 1,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            })
+            .await;
+        assert_eq!(res.timed_out(), Some(TimeoutType::Heartbeat));
+        Ok(().into())
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    let handle = client.get_untyped_workflow_handle(wf_name, run_id);
+    handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/metrics_tests.rs

@@ -0,0 +1,37 @@
+use temporal_client::WorkflowService;
+use temporal_sdk_core::CoreRuntime;
+use temporal_sdk_core_api::telemetry::MetricsExporter;
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
+use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options};
+
+#[tokio::test]
+async fn prometheus_metrics_exported() {
+    let mut telemopts = get_integ_telem_options();
+    let addr = "127.0.0.1:10919";
+    telemopts.metrics = Some(MetricsExporter::Prometheus(addr.parse().unwrap()));
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let opts = get_integ_server_options();
+    let mut raw_client = opts
+        .connect_no_namespace(rt.metric_meter(), None)
+        .await
+        .unwrap();
+    assert!(raw_client.get_client().capabilities().is_some());
+
+    let _ = raw_client
+        .list_namespaces(ListNamespacesRequest::default())
+        .await
+        .unwrap();
+
+    let body = reqwest::get(format!("http://{}/metrics", addr))
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+    assert!(body.contains(
+        "request_latency_count{operation=\"ListNamespaces\",service_name=\"temporal-core-sdk\"} 1"
+    ));
+    assert!(body.contains(
+        "request_latency_count{operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\"} 1"
+    ));
+}

data/bridge/sdk-core/tests/integ_tests/polling_tests.rs

@@ -0,0 +1,133 @@
+use assert_matches::assert_matches;
+use futures::future::join_all;
+use std::time::Duration;
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::{
+    activity_task::activity_task as act_task,
+    workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
+    workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
+    workflow_completion::WorkflowActivationCompletion,
+    IntoCompletion,
+};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+};
+use tokio::time::timeout;
+
+#[tokio::test]
+async fn out_of_order_completion_doesnt_hang() {
+    let mut starter = init_core_and_create_wf("out_of_order_completion_doesnt_hang").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation().await.unwrap();
+    // Complete workflow task and schedule activity and a timer that fires immediately
+    core.complete_workflow_activation(
+        vec![
+            schedule_activity_cmd(
+                0,
+                task_q,
+                activity_id,
+                ActivityCancellationType::TryCancel,
+                Duration::from_secs(60),
+                Duration::from_secs(60),
+            ),
+            StartTimer {
+                seq: 1,
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
+            }
+            .into(),
+        ]
+        .into_completion(task.run_id),
+    )
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
+    // complete it in this test as activity is try-cancelled.
+    let activity_task = core.poll_activity_task().await.unwrap();
+    assert_matches!(
+        activity_task.variant,
+        Some(act_task::Variant::Start(start_activity)) => {
+            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+        }
+    );
+    // Poll workflow task and verify that activity has failed.
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(
+                    FireTimer { seq: t_seq }
+                )),
+            },
+        ] => {
+            assert_eq!(*t_seq, 1);
+        }
+    );
+
+    // Start polling again *before* we complete the WFT
+    let cc = core.clone();
+    let jh = tokio::spawn(async move {
+        // We want to fail the test if this takes too long -- we should not hit long poll timeout
+        let task = timeout(Duration::from_secs(1), cc.poll_workflow_activation())
+            .await
+            .expect("Poll should come back right away")
+            .unwrap();
+        assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
+            }]
+        );
+        cc.complete_execution(&task.run_id).await;
+    });
+
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    // Then complete the (last) WFT with a request to cancel the AT, which should produce a
+    // pending activation, unblocking the (already started) poll
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        task.run_id,
+        vec![RequestCancelActivity { seq: 0 }.into()],
+    ))
+    .await
+    .unwrap();
+
+    jh.await.unwrap();
+}
+
+pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()> {
+    for _ in 0..20 {
+        let mut futs = vec![];
+        for _ in 0..1000 {
+            futs.push(ctx.timer(Duration::from_millis(100)));
+        }
+        join_all(futs).await;
+    }
+    Ok(().into())
+}
+
+// Ignored for now because I can't actually get this to produce pages. Need to generate some
+// large payloads I think.
+#[tokio::test]
+#[ignore]
+async fn can_paginate_long_history() {
+    let wf_name = "can_paginate_long_history";
+    let mut starter = CoreWfStarter::new(wf_name);
+    // Do not use sticky queues so we are forced to paginate once history gets long
+    starter.max_cached_workflows(0);
+
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), many_parallel_timers_longhist);
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}