@temporalio/core-bridge 1.10.2 → 1.11.0

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

@@ -1,7 +1,25 @@
-use std::time::Duration;
-use temporal_client::{RetryClient, WorkflowClientTrait, WorkflowService};
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use assert_matches::assert_matches;
+use futures_util::{future::BoxFuture, FutureExt};
+use std::{
+    collections::HashMap,
+    convert::Infallible,
+    env,
+    task::{Context, Poll},
+    time::Duration,
+};
+use temporal_client::{Namespace, RetryConfig, WorkflowClientTrait, WorkflowService};
+use temporal_sdk_core_protos::temporal::api::{
+    cloud::cloudservice::v1::GetNamespaceRequest, workflowservice::v1::DescribeNamespaceRequest,
+};
 use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
+use tokio::{
+    net::TcpListener,
+    sync::{mpsc::UnboundedSender, oneshot},
+};
+use tonic::{
+    body::BoxBody, codegen::Service, server::NamedService, transport::Server, Code, Request,
+};
+use tracing::info;
 
 #[tokio::test]
 async fn can_use_retry_client() {
@@ -17,9 +35,8 @@ async fn can_use_retry_client() {
 #[tokio::test]
 async fn can_use_retry_raw_client() {
     let opts = get_integ_server_options();
-    let raw_client = opts.connect_no_namespace(None).await.unwrap();
-    let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
-    retry_client
+    let mut client = opts.connect_no_namespace(None).await.unwrap();
+    client
         .describe_namespace(DescribeNamespaceRequest {
             namespace: NAMESPACE.to_string(),
             ..Default::default()
@@ -34,3 +51,214 @@ async fn calls_get_system_info() {
     let raw_client = opts.connect_no_namespace(None).await.unwrap();
     assert!(raw_client.get_client().capabilities().is_some());
 }
+
+#[tokio::test]
+async fn per_call_timeout_respected_whole_client() {
+    let opts = get_integ_server_options();
+    let mut raw_client = opts.connect_no_namespace(None).await.unwrap();
+    let mut hm = HashMap::new();
+    hm.insert("grpc-timeout".to_string(), "0S".to_string());
+    raw_client.get_client().set_headers(hm);
+    let err = raw_client
+        .describe_namespace(DescribeNamespaceRequest {
+            namespace: NAMESPACE.to_string(),
+            ..Default::default()
+        })
+        .await
+        .unwrap_err();
+    assert_matches!(err.code(), Code::DeadlineExceeded | Code::Cancelled);
+}
+
+#[tokio::test]
+async fn per_call_timeout_respected_one_call() {
+    let opts = get_integ_server_options();
+    let mut client = opts.connect_no_namespace(None).await.unwrap();
+
+    let mut req = Request::new(DescribeNamespaceRequest {
+        namespace: NAMESPACE.to_string(),
+        ..Default::default()
+    });
+    req.set_timeout(Duration::from_millis(0));
+    let res = client.describe_namespace(req).await;
+    assert_matches!(
+        res.unwrap_err().code(),
+        Code::DeadlineExceeded | Code::Cancelled
+    );
+}
+
+#[derive(Clone)]
+struct GenericService {
+    header_to_parse: &'static str,
+    header_tx: UnboundedSender<String>,
+}
+impl Service<tonic::codegen::http::Request<BoxBody>> for GenericService {
+    type Response = tonic::codegen::http::Response<BoxBody>;
+    type Error = Infallible;
+    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: tonic::codegen::http::Request<BoxBody>) -> Self::Future {
+        self.header_tx
+            .send(
+                String::from_utf8_lossy(
+                    req.headers()
+                        .get(self.header_to_parse)
+                        .map(|hv| hv.as_bytes())
+                        .unwrap_or_default(),
+                )
+                .to_string(),
+            )
+            .unwrap();
+        async move { Ok(Self::Response::new(tonic::codegen::empty_body())) }.boxed()
+    }
+}
+impl NamedService for GenericService {
+    const NAME: &'static str = "temporal.api.workflowservice.v1.WorkflowService";
+}
+
+#[tokio::test]
+async fn timeouts_respected_one_call_fake_server() {
+    let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
+    let (header_tx, mut header_rx) = tokio::sync::mpsc::unbounded_channel();
+
+    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    let server_handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(GenericService {
+                header_to_parse: "grpc-timeout",
+                header_tx,
+            })
+            .serve_with_incoming_shutdown(
+                tokio_stream::wrappers::TcpListenerStream::new(listener),
+                async {
+                    shutdown_rx.await.ok();
+                },
+            )
+            .await
+            .unwrap();
+    });
+
+    let mut opts = get_integ_server_options();
+    let uri = format!("http://localhost:{}", addr.port()).parse().unwrap();
+    opts.target_url = uri;
+    opts.skip_get_system_info = true;
+    opts.retry_config = RetryConfig {
+        max_retries: 1,
+        ..Default::default()
+    };
+
+    let mut client = opts.connect_no_namespace(None).await.unwrap();
+
+    macro_rules! call_client {
+        ($client:ident, $trx:ident, $client_fn:ident) => {
+            let mut req = Request::new(Default::default());
+            req.set_timeout(Duration::from_millis(100));
+            // Response is always error b/c empty body
+            let _ = $client.$client_fn(req).await;
+            let timeout = $trx.recv().await.unwrap();
+            assert_eq!("100000u", timeout);
+        };
+    }
+
+    call_client!(client, header_rx, get_workflow_execution_history);
+    call_client!(client, header_rx, update_workflow_execution);
+    call_client!(client, header_rx, poll_workflow_execution_update);
+
+    // Shutdown the server
+    shutdown_tx.send(()).unwrap();
+    server_handle.await.unwrap();
+}
+
+#[tokio::test]
+async fn namespace_header_attached_to_relevant_calls() {
+    let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
+    let (header_tx, mut header_rx) = tokio::sync::mpsc::unbounded_channel();
+
+    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    let server_handle = tokio::spawn(async move {
+        Server::builder()
+            .add_service(GenericService {
+                header_to_parse: "Temporal-Namespace",
+                header_tx,
+            })
+            .serve_with_incoming_shutdown(
+                tokio_stream::wrappers::TcpListenerStream::new(listener),
+                async {
+                    shutdown_rx.await.ok();
+                },
+            )
+            .await
+            .unwrap();
+    });
+
+    let mut opts = get_integ_server_options();
+    let uri = format!("http://localhost:{}", addr.port()).parse().unwrap();
+    opts.target_url = uri;
+    opts.skip_get_system_info = true;
+    opts.retry_config = RetryConfig {
+        max_retries: 1,
+        ..Default::default()
+    };
+
+    let namespace = "namespace";
+    let client = opts.connect(namespace, None).await.unwrap();
+
+    let _ = client
+        .get_workflow_execution_history("hi".to_string(), None, vec![])
+        .await;
+    let val = header_rx.recv().await.unwrap();
+    assert_eq!(namespace, val);
+    let _ = client.list_namespaces().await;
+    let val = header_rx.recv().await.unwrap();
+    // List namespaces is not namespace-specific
+    assert_eq!("", val);
+    let _ = client
+        .describe_namespace(Namespace::Name("Other".to_string()))
+        .await;
+    let val = header_rx.recv().await.unwrap();
+    assert_eq!("Other", val);
+
+    // Shutdown the server
+    shutdown_tx.send(()).unwrap();
+    server_handle.await.unwrap();
+}
+
+#[tokio::test]
+async fn cloud_ops_test() {
+    let api_key = match env::var("TEMPORAL_CLIENT_CLOUD_API_KEY") {
+        Ok(k) => k,
+        Err(_) => {
+            // skip test
+            info!("Skipped cloud operations client test");
+            return;
+        }
+    };
+    let api_version =
+        env::var("TEMPORAL_CLIENT_CLOUD_API_VERSION").expect("version env var must exist");
+    let namespace =
+        env::var("TEMPORAL_CLIENT_CLOUD_NAMESPACE").expect("namespace env var must exist");
+    let mut opts = get_integ_server_options();
+    opts.target_url = "saas-api.tmprl.cloud:443".parse().unwrap();
+    opts.api_key = Some(api_key);
+    opts.headers = Some({
+        let mut hm = HashMap::new();
+        hm.insert("temporal-cloud-api-version".to_string(), api_version);
+        hm
+    });
+    let mut client = opts.connect_no_namespace(None).await.unwrap().into_inner();
+    let cloud_client = client.cloud_svc_mut();
+    let res = cloud_client
+        .get_namespace(GetNamespaceRequest {
+            namespace: namespace.clone(),
+        })
+        .await
+        .unwrap();
+    assert_eq!(res.into_inner().namespace.unwrap().namespace, namespace);
+}

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

@@ -1,12 +1,15 @@
-use anyhow::{anyhow, bail};
+use anyhow::anyhow;
 use assert_matches::assert_matches;
 use futures_util::{future, future::join_all, StreamExt};
 use once_cell::sync::Lazy;
 use std::{
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        Arc,
+    },
     time::Duration,
 };
-use temporal_client::WorkflowClientTrait;
+use temporal_client::{Client, RetryClient, WorkflowClientTrait, WorkflowService};
 use temporal_sdk::{ActContext, ActivityOptions, LocalActivityOptions, UpdateContext, WfContext};
 use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_api::Worker;
@@ -23,29 +26,159 @@ use temporal_sdk_core_protos::{
         ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt,
     },
     temporal::api::{
-        enums::v1::{EventType, UpdateWorkflowExecutionLifecycleStage},
-        update,
-        update::v1::WaitPolicy,
+        common::v1::WorkflowExecution,
+        enums::v1::{EventType, ResetReapplyType, UpdateWorkflowExecutionLifecycleStage},
+        update::{self, v1::WaitPolicy},
+        workflowservice::v1::ResetWorkflowExecutionRequest,
     },
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, init_core_replay_preloaded, start_timer_cmd, CoreWfStarter,
-    WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, init_core_replay_preloaded,
+    start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::{join, sync::Barrier};
+use uuid::Uuid;
+
+#[derive(Clone, Copy)]
+enum FailUpdate {
+    Yes,
+    No,
+}
+
+#[derive(Clone, Copy)]
+enum CompleteWorkflow {
+    Yes,
+    No,
+}
 
 #[rstest::rstest]
 #[tokio::test]
-async fn update_workflow(#[values(true, false)] will_fail: bool) {
+async fn update_workflow(#[values(FailUpdate::Yes, FailUpdate::No)] will_fail: FailUpdate) {
     let mut starter = init_core_and_create_wf("update_workflow").await;
     let core = starter.get_worker().await;
     let client = starter.get_client().await;
-    let workflow_id = starter.get_task_queue().to_string();
-
+    let workflow_id = starter.get_task_queue();
     let update_id = "some_update";
-    // Task is completed with no commands
-    let res = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id.clone()))
+    send_and_handle_update(
+        workflow_id,
+        update_id,
+        will_fail,
+        CompleteWorkflow::Yes,
+        core.as_ref(),
+        client.as_ref(),
+    )
+    .await;
+
+    // Make sure replay works
+    let history = client
+        .get_workflow_execution_history(workflow_id.to_string(), None, vec![])
+        .await
+        .unwrap()
+        .history
+        .unwrap();
+    let with_id = HistoryForReplay::new(history, workflow_id.to_string());
+    let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
+    handle_update(will_fail, CompleteWorkflow::Yes, replay_worker.as_ref()).await;
+}
+
+#[rstest::rstest]
+#[tokio::test]
+async fn reapplied_updates_due_to_reset() {
+    let mut starter = init_core_and_create_wf("update_workflow").await;
+    let core = starter.get_worker().await;
+    let client = starter.get_client().await;
+    let workflow_id = starter.get_task_queue();
+    let pre_reset_run_id = send_and_handle_update(
+        workflow_id,
+        "first-update",
+        FailUpdate::No,
+        CompleteWorkflow::Yes,
+        core.as_ref(),
+        client.as_ref(),
+    )
+    .await;
+
+    // Reset to before the update was accepted
+    let workflow_task_finish_event_id = 4;
+
+    let mut client_mut = client.clone();
+    let reset_response = WorkflowService::reset_workflow_execution(
+        Arc::make_mut(&mut client_mut),
+        ResetWorkflowExecutionRequest {
+            namespace: client.namespace().into(),
+            workflow_execution: Some(WorkflowExecution {
+                workflow_id: workflow_id.into(),
+                run_id: pre_reset_run_id.clone(),
+            }),
+            workflow_task_finish_event_id,
+            reset_reapply_type: ResetReapplyType::AllEligible as i32,
+            request_id: Uuid::new_v4().to_string(),
+            ..Default::default()
+        },
+    )
+    .await
+    .unwrap()
+    .into_inner();
+
+    // Accept and complete the reapplied update
+    handle_update(FailUpdate::No, CompleteWorkflow::No, core.as_ref()).await;
+
+    // Send a second update and complete the workflow
+    let post_reset_run_id = send_and_handle_update(
+        workflow_id,
+        "second-update",
+        FailUpdate::No,
+        CompleteWorkflow::Yes,
+        core.as_ref(),
+        client.as_ref(),
+    )
+    .await;
+
+    assert_eq!(post_reset_run_id, reset_response.run_id);
+
+    // Make sure replay works
+    let history = client
+        .get_workflow_execution_history(workflow_id.to_string(), Some(post_reset_run_id), vec![])
+        .await
+        .unwrap()
+        .history
+        .unwrap();
+    let with_id = HistoryForReplay::new(history, workflow_id.to_string());
+
+    let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
+    // We now recapitulate the actions that the worker took on first execution above, pretending
+    // that we always followed the post-reset history.
+    // First, we handled the post-reset reapplied update and did not complete the workflow.
+    handle_update(FailUpdate::No, CompleteWorkflow::No, replay_worker.as_ref()).await;
+    // Then the client sent a second update; we handled it and completed the workflow.
+    handle_update(
+        FailUpdate::No,
+        CompleteWorkflow::Yes,
+        replay_worker.as_ref(),
+    )
+    .await;
+
+    // This is a replay worker and there is a remaining activation containing a RemoveFromCache job.
+    let act = replay_worker.poll_workflow_activation().await.unwrap();
+    replay_worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
+        .await
+        .unwrap();
+    drain_pollers_and_shutdown(&replay_worker).await;
+}
+
+// Start a workflow, send an update, accept the update, complete the update, complete the workflow.
+async fn send_and_handle_update(
+    workflow_id: &str,
+    update_id: &str,
+    fail_update: FailUpdate,
+    complete_workflow: CompleteWorkflow,
+    core: &dyn Worker,
+    client: &RetryClient<Client>,
+) -> String {
+    // Complete first task with no commands
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id.clone()))
         .await
         .unwrap();
 
@@ -54,7 +187,7 @@ async fn update_workflow(#[values(true, false)] will_fail: bool) {
         client
             .update_workflow_execution(
                 workflow_id.to_string(),
-                res.run_id.to_string(),
+                act.run_id.to_string(),
                 update_id.to_string(),
                 WaitPolicy {
                     lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
@@ -65,40 +198,38 @@ async fn update_workflow(#[values(true, false)] will_fail: bool) {
             .unwrap()
     };
 
-    let processing_task = _do_update_workflow(will_fail, core.as_ref());
+    // Accept update, complete update and complete workflow
+    let processing_task = handle_update(fail_update, complete_workflow, core);
     let (ur, _) = join!(update_task, processing_task);
 
     let v = ur.outcome.unwrap().value.unwrap();
-    if will_fail {
-        assert_matches!(v, update::v1::outcome::Value::Failure(_));
-    } else {
-        assert_matches!(v, update::v1::outcome::Value::Success(_));
+    match fail_update {
+        FailUpdate::Yes => assert_matches!(v, update::v1::outcome::Value::Failure(_)),
+        FailUpdate::No => assert_matches!(v, update::v1::outcome::Value::Success(_)),
     }
-
-    // Make sure replay works
-    let history = client
-        .get_workflow_execution_history(workflow_id.clone(), None, vec![])
-        .await
-        .unwrap()
-        .history
-        .unwrap();
-    let with_id = HistoryForReplay::new(history, workflow_id.clone());
-    let replay_worker = init_core_replay_preloaded(&workflow_id, [with_id]);
-    _do_update_workflow(will_fail, replay_worker.as_ref()).await;
+    act.run_id
 }
 
-async fn _do_update_workflow(will_fail: bool, core: &dyn Worker) {
-    let res = core.poll_workflow_activation().await.unwrap();
+// Accept and then complete update. If `FailUpdate::Yes` then complete the update as a failure; if
+// `CompleteWorkflow::Yes` then additionally complete the workflow. Timers are created when further
+// activations are required (i.e., on accepting-but-not-completing the update, and on completing the
+// update if not also completing the workflow).
+async fn handle_update(
+    fail_update: FailUpdate,
+    complete_workflow: CompleteWorkflow,
+    core: &dyn Worker,
+) {
+    let act = core.poll_workflow_activation().await.unwrap();
     // On replay, the first activation has update & start workflow, but on first execution, it does
     // not - can happen if update is waiting on some condition.
     let pid = assert_matches!(
-        &res.jobs[0],
+        &act.jobs[0],
         WorkflowActivationJob {
             variant: Some(workflow_activation_job::Variant::DoUpdate(d)),
         } => &d.protocol_instance_id
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        res.run_id,
+        act.run_id,
         vec![
             UpdateResponse {
                 protocol_instance_id: pid.to_string(),
@@ -111,26 +242,28 @@ async fn _do_update_workflow(will_fail: bool, core: &dyn Worker) {
     .await
     .unwrap();
 
-    let response = if will_fail {
-        UpdateResponse {
+    // Timer fires
+    let act = core.poll_workflow_activation().await.unwrap();
+    let update_response = match fail_update {
+        FailUpdate::Yes => UpdateResponse {
             protocol_instance_id: pid.to_string(),
             response: Some(update_response::Response::Rejected(
                 "uh oh spaghettios!".into(),
             )),
-        }
-    } else {
-        UpdateResponse {
+        },
+        FailUpdate::No => UpdateResponse {
             protocol_instance_id: pid.to_string(),
             response: Some(update_response::Response::Completed("done!".into())),
-        }
+        },
     };
-    let res = core.poll_workflow_activation().await.unwrap();
-    // Timer fires
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        res.run_id,
+        act.run_id,
         vec![
-            response.into(),
-            CompleteWorkflowExecution { result: None }.into(),
+            update_response.into(),
+            match complete_workflow {
+                CompleteWorkflow::Yes => CompleteWorkflowExecution { result: None }.into(),
+                CompleteWorkflow::No => start_timer_cmd(1, Duration::from_millis(1)),
+            },
         ],
     ))
     .await
@@ -843,7 +976,7 @@ async fn worker_restarted_in_middle_of_update() {
         BARR.wait().await;
         if !ACT_RAN.fetch_or(true, Ordering::Relaxed) {
             // On first run fail the task so we'll get retried on the new worker
-            bail!("Fail first time");
+            return Err(anyhow!("Fail first time").into());
         }
         Ok(echo_me)
     });

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

@@ -0,0 +1,32 @@
+use assert_matches::assert_matches;
+use temporal_sdk_core::{init_worker, CoreRuntime};
+use temporal_sdk_core_api::{errors::WorkerValidationError, worker::WorkerConfigBuilder, Worker};
+use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options};
+
+#[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!")
+            .worker_build_id("blah")
+            .build()
+            .unwrap(),
+        retrying_client,
+    )
+    .unwrap();
+
+    let res = worker.validate().await;
+    assert_matches!(
+        res,
+        Err(WorkerValidationError::NamespaceDescribeError { .. })
+    );
+}

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

@@ -8,8 +8,8 @@ use std::{
 };
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{
-    ActContext, ActExitValue, ActivityCancelledError, ActivityOptions, CancellableFuture,
-    WfContext, WorkflowResult,
+    ActContext, ActExitValue, ActivityError, ActivityOptions, CancellableFuture, WfContext,
+    WorkflowResult,
 };
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -787,6 +787,50 @@ async fn activity_cancelled_after_heartbeat_times_out() {
         .unwrap();
 }
 
+#[tokio::test]
+async fn one_activity_abandon_cancelled_before_started() {
+    let wf_name = "one_activity_abandon_cancelled_before_started";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let act_fut = 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"),
+            cancellation_type: ActivityCancellationType::Abandon,
+            ..Default::default()
+        });
+        act_fut.cancel(&ctx);
+        act_fut.await;
+        Ok(().into())
+    });
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move {
+            sleep(Duration::from_secs(2)).await;
+            Ok(echo_me)
+        },
+    );
+
+    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);
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
+}
+
 #[tokio::test]
 async fn one_activity_abandon_cancelled_after_complete() {
     let wf_name = "one_activity_abandon_cancelled_after_complete";
@@ -946,7 +990,7 @@ async fn graceful_shutdown() {
         // just wait to be cancelled
         ctx.cancelled().await;
         ACTS_DONE.add_permits(1);
-        Result::<(), _>::Err(ActivityCancelledError::default().into())
+        Result::<(), _>::Err(ActivityError::cancelled())
     });
 
     worker