@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/tests/integ_tests/polling_tests.rs

@@ -1,294 +0,0 @@
-use crate::integ_tests::activity_functions::echo;
-use assert_matches::assert_matches;
-use std::{sync::Arc, time::Duration};
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActivityOptions, WfContext};
-use temporal_sdk_core::{
-    ClientOptionsBuilder, ephemeral_server::TemporalDevServerConfigBuilder, init_worker,
-};
-use temporal_sdk_core_api::{Worker, worker::PollerBehavior};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        AsJsonPayloadExt, IntoCompletion,
-        activity_task::activity_task as act_task,
-        workflow_activation::{FireTimer, WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::enums::v1::EventType,
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkerTestHelpers, default_cached_download, drain_pollers_and_shutdown,
-    init_core_and_create_wf, init_integ_telem, integ_worker_config, schedule_activity_cmd,
-};
-use tokio::time::timeout;
-use tracing::info;
-use url::Url;
-
-#[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, 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(_)));
-    // 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();
-}
-
-#[tokio::test]
-async fn switching_worker_client_changes_poll() {
-    // Start two servers
-    info!("Starting servers");
-    let server_config = TemporalDevServerConfigBuilder::default()
-        .exe(default_cached_download())
-        // We need to lower the poll timeout so the poll call rolls over
-        .extra_args(vec![
-            "--dynamic-config-value".to_string(),
-            "matching.longPollExpirationInterval=\"1s\"".to_string(),
-        ])
-        .build()
-        .unwrap();
-    let mut server1 = server_config.start_server().await.unwrap();
-    let mut server2 = server_config.start_server().await.unwrap();
-
-    // Connect clients to both servers
-    info!("Connecting clients");
-    let mut client_common_config = ClientOptionsBuilder::default();
-    client_common_config
-        .identity("integ_tester".to_owned())
-        .client_name("temporal-core".to_owned())
-        .client_version("0.1.0".to_owned());
-    let client1 = client_common_config
-        .clone()
-        .target_url(Url::parse(&format!("http://{}", server1.target)).unwrap())
-        .build()
-        .unwrap()
-        .connect("default", None)
-        .await
-        .unwrap();
-    let client2 = client_common_config
-        .clone()
-        .target_url(Url::parse(&format!("http://{}", server2.target)).unwrap())
-        .build()
-        .unwrap()
-        .connect("default", None)
-        .await
-        .unwrap();
-
-    // Start a workflow on both servers
-    info!("Starting workflows");
-    let wf1 = client1
-        .start_workflow(
-            vec![],
-            "my-task-queue".to_owned(),
-            "my-workflow-1".to_owned(),
-            "my-workflow-type".to_owned(),
-            None,
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let wf2 = client2
-        .start_workflow(
-            vec![],
-            "my-task-queue".to_owned(),
-            "my-workflow-2".to_owned(),
-            "my-workflow-type".to_owned(),
-            None,
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-
-    // Create a worker only on the first server
-    let worker = init_worker(
-        init_integ_telem().unwrap(),
-        integ_worker_config("my-task-queue")
-            // We want a cache so we don't get extra remove-job activations
-            .max_cached_workflows(100_usize)
-            .build()
-            .unwrap(),
-        client1.clone(),
-    )
-    .unwrap();
-
-    // Poll for first task, confirm it's first wf, complete, and wait for complete
-    info!("Doing initial poll");
-    let act1 = worker.poll_workflow_activation().await.unwrap();
-    assert_eq!(wf1.run_id, act1.run_id);
-    worker.complete_execution(&act1.run_id).await;
-    worker.handle_eviction().await;
-    info!("Waiting on first workflow complete");
-    client1
-        .get_untyped_workflow_handle("my-workflow-1", wf1.run_id)
-        .get_workflow_result(Default::default())
-        .await
-        .unwrap();
-
-    // Swap client, poll for next task, confirm it's second wf, and respond w/ empty
-    info!("Replacing client and polling again");
-    worker.replace_client(client2.get_client().inner().clone());
-    let act2 = worker.poll_workflow_activation().await.unwrap();
-    assert_eq!(wf2.run_id, act2.run_id);
-    worker.complete_execution(&act2.run_id).await;
-    worker.handle_eviction().await;
-    info!("Waiting on second workflow complete");
-    client2
-        .get_untyped_workflow_handle("my-workflow-2", wf2.run_id)
-        .get_workflow_result(Default::default())
-        .await
-        .unwrap();
-
-    // Shutdown workers and servers
-    drain_pollers_and_shutdown(&(Arc::new(worker) as Arc<dyn Worker>)).await;
-    server1.shutdown().await.unwrap();
-    server2.shutdown().await.unwrap();
-}
-
-#[rstest::rstest]
-#[tokio::test]
-async fn small_workflow_slots_and_pollers(#[values(false, true)] use_autoscaling: bool) {
-    let wf_name = "only_one_workflow_slot_and_two_pollers";
-    let mut starter = CoreWfStarter::new(wf_name);
-    if use_autoscaling {
-        starter
-            .worker_config
-            .workflow_task_poller_behavior(PollerBehavior::Autoscaling {
-                minimum: 1,
-                maximum: 5,
-                initial: 1,
-            });
-    } else {
-        starter
-            .worker_config
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2));
-    }
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(2_usize)
-        .max_outstanding_local_activities(1_usize)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1))
-        .max_outstanding_activities(1_usize);
-    let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        for _ in 0..3 {
-            ctx.activity(ActivityOptions {
-                activity_type: "echo_activity".to_string(),
-                start_to_close_timeout: Some(Duration::from_secs(5)),
-                input: "hi!".as_json_payload().expect("serializes fine"),
-                ..Default::default()
-            })
-            .await;
-        }
-        Ok(().into())
-    });
-    worker.register_activity("echo_activity", echo);
-    worker
-        .submit_wf(
-            starter.get_task_queue(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let wf2id = format!("{}-2", starter.get_task_queue());
-    worker
-        .submit_wf(
-            wf2id.clone(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    // If we don't fail the workflow on nondeterminism, we'll get stuck here retrying the WFT
-    worker.run_until_done().await.unwrap();
-    // Verify no task timeouts happened
-    let history = starter.get_history().await;
-    let any_task_timeouts = history
-        .events
-        .iter()
-        .any(|e| e.event_type() == EventType::WorkflowTaskTimedOut);
-    assert!(!any_task_timeouts);
-    let history = starter
-        .get_client()
-        .await
-        .get_workflow_execution_history(wf2id, None, vec![])
-        .await
-        .unwrap()
-        .history
-        .unwrap();
-    let any_task_timeouts = history
-        .events
-        .iter()
-        .any(|e| e.event_type() == EventType::WorkflowTaskTimedOut);
-    assert!(!any_task_timeouts);
-}

package/sdk-core/tests/integ_tests/worker_tests.rs

@@ -1,203 +0,0 @@
-use crate::shared_tests;
-use assert_matches::assert_matches;
-use std::{
-    cell::Cell,
-    sync::{
-        Arc,
-        atomic::{AtomicBool, Ordering::Relaxed},
-    },
-    time::Duration,
-};
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{WfContext, interceptors::WorkerInterceptor};
-use temporal_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions, init_worker};
-use temporal_sdk_core_api::{
-    Worker,
-    errors::WorkerValidationError,
-    worker::{PollerBehavior, WorkerConfigBuilder, WorkerVersioningStrategy},
-};
-use temporal_sdk_core_protos::{
-    coresdk::workflow_completion::{
-        Failure, WorkflowActivationCompletion, workflow_activation_completion::Status,
-    },
-    temporal::api::{
-        enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
-        failure::v1::Failure as InnerFailure,
-        history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
-    },
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, drain_pollers_and_shutdown, get_integ_server_options, get_integ_telem_options,
-};
-use tokio::sync::Notify;
-use uuid::Uuid;
-
-#[tokio::test]
-async fn worker_validation_fails_on_nonexistent_namespace() {
-    let opts = get_integ_server_options();
-    let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
-    let retrying_client = opts
-        .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter())
-        .await
-        .unwrap();
-
-    let worker = init_worker(
-        &runtime,
-        WorkerConfigBuilder::default()
-            .namespace("i_dont_exist")
-            .task_queue("Wheee!")
-            .versioning_strategy(WorkerVersioningStrategy::None {
-                build_id: "blah".to_owned(),
-            })
-            .build()
-            .unwrap(),
-        retrying_client,
-    )
-    .unwrap();
-
-    let res = worker.validate().await;
-    assert_matches!(
-        res,
-        Err(WorkerValidationError::NamespaceDescribeError { .. })
-    );
-}
-
-#[tokio::test]
-async fn worker_handles_unknown_workflow_types_gracefully() {
-    let wf_type = "worker_handles_unknown_workflow_types_gracefully";
-    let mut starter = CoreWfStarter::new(wf_type);
-    let mut worker = starter.worker().await;
-
-    let run_id = worker
-        .submit_wf(
-            format!("wce-{}", Uuid::new_v4()),
-            "unregistered".to_string(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-
-    struct GracefulAsserter {
-        notify: Arc<Notify>,
-        run_id: String,
-        unregistered_failure_seen: Cell<bool>,
-    }
-    #[async_trait::async_trait(?Send)]
-    impl WorkerInterceptor for GracefulAsserter {
-        async fn on_workflow_activation_completion(
-            &self,
-            completion: &WorkflowActivationCompletion,
-        ) {
-            if matches!(
-                completion,
-                WorkflowActivationCompletion {
-                    status: Some(Status::Failed(Failure {
-                        failure: Some(InnerFailure { message, .. }),
-                        ..
-                    })),
-                    run_id,
-                } if message == "Workflow type unregistered not found" && *run_id == self.run_id
-            ) {
-                self.unregistered_failure_seen.set(true);
-            }
-            // If we've seen the failure, and the completion is a success for the same run, we're done
-            if matches!(
-                completion,
-                WorkflowActivationCompletion {
-                    status: Some(Status::Successful(..)),
-                    run_id,
-                } if self.unregistered_failure_seen.get() && *run_id == self.run_id
-            ) {
-                // Shutdown the worker
-                self.notify.notify_one();
-            }
-        }
-        fn on_shutdown(&self, _: &temporal_sdk::Worker) {}
-    }
-
-    let inner = worker.inner_mut();
-    let notify = Arc::new(Notify::new());
-    inner.set_worker_interceptor(GracefulAsserter {
-        notify: notify.clone(),
-        run_id,
-        unregistered_failure_seen: Cell::new(false),
-    });
-    tokio::join!(async { inner.run().await.unwrap() }, async move {
-        notify.notified().await;
-        let worker = starter.get_worker().await.clone();
-        drain_pollers_and_shutdown(&worker).await;
-    });
-}
-
-#[tokio::test]
-async fn resource_based_few_pollers_guarantees_non_sticky_poll() {
-    let wf_name = "resource_based_few_pollers_guarantees_non_sticky_poll";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .clear_max_outstanding_opts()
-        .no_remote_activities(true)
-        // 3 pollers so the minimum slots of 2 can both be handed out to a sticky poller
-        .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(3_usize));
-    // Set the limits to zero so it's essentially unwilling to hand out slots
-    let mut tuner = ResourceBasedTuner::new(0.0, 0.0);
-    tuner.with_workflow_slots_options(ResourceSlotOptions::new(2, 10, Duration::from_millis(0)));
-    starter.worker_config.tuner(Arc::new(tuner));
-    let mut worker = starter.worker().await;
-
-    // Workflow doesn't actually need to do anything. We just need to see that we don't get stuck
-    // by assigning all slots to sticky pollers.
-    worker.register_wf(
-        wf_name.to_owned(),
-        |_: WfContext| async move { Ok(().into()) },
-    );
-    for i in 0..20 {
-        worker
-            .submit_wf(
-                format!("{wf_name}_{i}"),
-                wf_name.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-    }
-    worker.run_until_done().await.unwrap();
-}
-
-#[tokio::test]
-async fn oversize_grpc_message() {
-    let wf_name = "oversize_grpc_message";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
-    let mut core = starter.worker().await;
-
-    static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);
-    core.register_wf(wf_name.to_owned(), |_ctx: WfContext| async move {
-        if OVERSIZE_GRPC_MESSAGE_RUN.load(Relaxed) {
-            Ok(vec![].into())
-        } else {
-            OVERSIZE_GRPC_MESSAGE_RUN.store(true, Relaxed);
-            let result: Vec<u8> = vec![0; 5000000];
-            Ok(result.into())
-        }
-    });
-    starter.start_with_worker(wf_name, &mut core).await;
-    core.run_until_done().await.unwrap();
-
-    assert!(starter.get_history().await.events.iter().any(|e| {
-        e.event_type == EventType::WorkflowTaskFailed as i32
-            && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                attr.cause == GrpcMessageTooLarge as i32
-                    && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
-            } else {
-                false
-            }
-    }))
-}
-
-#[tokio::test]
-async fn grpc_message_too_large_test() {
-    shared_tests::grpc_message_too_large().await
-}

package/sdk-core/tests/integ_tests/workflow_tests/cancel_external.rs

@@ -1,74 +0,0 @@
-use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowOptions};
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution};
-use temporal_sdk_core_test_utils::CoreWfStarter;
-
-const RECEIVER_WFID: &str = "sends-cancel-receiver";
-
-async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
-    let run_id = std::str::from_utf8(&ctx.get_args()[0].data)?.to_owned();
-    let sigres = ctx
-        .cancel_external(
-            NamespacedWorkflowExecution {
-                workflow_id: RECEIVER_WFID.to_string(),
-                run_id,
-                namespace: ctx.namespace().to_string(),
-            },
-            "cancel-reason".to_string(),
-        )
-        .await;
-    if ctx.get_args().get(1).is_some() {
-        // We expect failure
-        assert!(sigres.is_err());
-    } else {
-        sigres.unwrap();
-    }
-    Ok(().into())
-}
-
-async fn cancel_receiver(ctx: WfContext) -> WorkflowResult<String> {
-    let r = ctx.cancelled().await;
-    Ok(r.into())
-}
-
-#[tokio::test]
-async fn sends_cancel_to_other_wf() {
-    let mut starter = CoreWfStarter::new("sends_cancel_to_other_wf");
-    starter.worker_config.no_remote_activities(true);
-    let mut worker = starter.worker().await;
-    worker.register_wf("sender", cancel_sender);
-    worker.register_wf("receiver", cancel_receiver);
-
-    let receiver_run_id = worker
-        .submit_wf(
-            RECEIVER_WFID,
-            "receiver",
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker
-        .submit_wf(
-            "sends-cancel-sender",
-            "sender",
-            vec![receiver_run_id.clone().into()],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-    let h = starter
-        .get_client()
-        .await
-        .get_untyped_workflow_handle(RECEIVER_WFID, receiver_run_id);
-    let res = String::from_json_payload(
-        &h.get_workflow_result(GetWorkflowResultOpts::default())
-            .await
-            .unwrap()
-            .unwrap_success()[0],
-    )
-    .unwrap();
-    assert!(res.contains("Cancel requested by workflow"));
-    assert!(res.contains("cancel-reason"));
-}

package/sdk-core/tests/integ_tests/workflow_tests/cancel_wf.rs

@@ -1,57 +0,0 @@
-use std::time::Duration;
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
-use temporal_sdk_core_test_utils::CoreWfStarter;
-
-async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
-    let mut reason = "".to_string();
-    let cancelled = tokio::select! {
-        _ = ctx.timer(Duration::from_secs(500)) => false,
-        r = ctx.cancelled() => {
-            reason = r;
-            true
-        }
-    };
-
-    assert_eq!(reason, "Dieee");
-
-    if cancelled {
-        Ok(WfExitValue::Cancelled)
-    } else {
-        panic!("Should have been cancelled")
-    }
-}
-
-#[tokio::test]
-async fn cancel_during_timer() {
-    let wf_name = "cancel_during_timer";
-    let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
-    let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_string(), cancelled_wf);
-    starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
-
-    let canceller = async {
-        tokio::time::sleep(Duration::from_millis(500)).await;
-        // Cancel the workflow externally
-        client
-            .cancel_workflow_execution(wf_id.clone(), None, "Dieee".to_string(), None)
-            .await
-            .unwrap();
-    };
-
-    let (_, res) = tokio::join!(canceller, worker.run_until_done());
-    res.unwrap();
-    let desc = client
-        .describe_workflow_execution(wf_id, None)
-        .await
-        .unwrap();
-
-    assert_eq!(
-        desc.workflow_execution_info.unwrap().status,
-        WorkflowExecutionStatus::Canceled as i32
-    );
-}