temporalio 0.0.1 → 0.0.2

data/bridge/sdk-core/sdk-core-protos/src/lib.rs

@@ -66,7 +66,7 @@ pub mod coresdk {
                     "ActivityTaskCompletion(token: {}",
                     fmt_tt(&self.task_token),
                 )?;
-                if let Some(r) = self.result.as_ref() {
+                if let Some(r) = self.result.as_ref().and_then(|r| r.status.as_ref()) {
                     write!(f, ", {}", r)?;
                 } else {
                     write!(f, ", missing result")?;
@@ -120,21 +120,20 @@ pub mod coresdk {
             }
         }
 
-        impl Display for ActivityExecutionResult {
+        impl Display for aer::Status {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "ActivityExecutionResult(")?;
-                match self.status.as_ref() {
-                    None => write!(f, "missing result)"),
-                    Some(aer::Status::Completed(v)) => {
+                match self {
+                    aer::Status::Completed(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::Failed(v)) => {
+                    aer::Status::Failed(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::Cancelled(v)) => {
+                    aer::Status::Cancelled(v) => {
                         write!(f, "{})", v)
                     }
-                    Some(aer::Status::WillCompleteAsync(_)) => {
+                    aer::Status::WillCompleteAsync(_) => {
                         write!(f, "Will complete async)")
                     }
                 }
@@ -198,11 +197,15 @@ pub mod coresdk {
                 matches!(self.status, Some(activity_resolution::Status::Failed(_)))
             }
 
-            pub fn timed_out(&self) -> bool {
-                matches!(self.status, Some(activity_resolution::Status::Failed(Failure {
-                    failure: Some(ref f)
-                })) if f.is_timeout()
-                    || f.cause.as_ref().map(|c| c.is_timeout()).unwrap_or_default())
+            pub fn timed_out(&self) -> Option<crate::temporal::api::enums::v1::TimeoutType> {
+                match self.status {
+                    Some(activity_resolution::Status::Failed(Failure {
+                        failure: Some(ref f),
+                    })) => f
+                        .is_timeout()
+                        .or_else(|| f.cause.as_ref().and_then(|c| c.is_timeout())),
+                    _ => None,
+                }
             }
 
             pub fn cancelled(&self) -> bool {
@@ -244,10 +247,6 @@ pub mod coresdk {
         }
     }
 
-    pub mod bridge {
-        tonic::include_proto!("coresdk.bridge");
-    }
-
     pub mod common {
         tonic::include_proto!("coresdk.common");
         use super::external_data::LocalActivityMarkerData;
@@ -405,6 +404,7 @@ pub mod coresdk {
                 query::v1::WorkflowQuery,
             },
         };
+        use prost_types::Timestamp;
         use std::{
             collections::HashMap,
             fmt::{Display, Formatter},
@@ -600,6 +600,7 @@ pub mod coresdk {
             attrs: WorkflowExecutionStartedEventAttributes,
             workflow_id: String,
             randomness_seed: u64,
+            start_time: Timestamp,
         ) -> StartWorkflow {
             StartWorkflow {
                 workflow_type: attrs.workflow_type.map(|wt| wt.name).unwrap_or_default(),
@@ -633,6 +634,7 @@ pub mod coresdk {
                 cron_schedule_to_schedule_interval: attrs.first_workflow_task_backoff,
                 memo: attrs.memo,
                 search_attributes: attrs.search_attributes,
+                start_time: Some(start_time),
             }
         }
     }
@@ -800,6 +802,16 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ModifyWorkflowProperties {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "ModifyWorkflowProperties(upserted memo keys: {:?})",
+                    self.upserted_memo.as_ref().map(|m| m.fields.keys())
+                )
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -1095,8 +1107,11 @@ pub mod coresdk {
     }
 
     impl Failure {
-        pub fn is_timeout(&self) -> bool {
-            matches!(self.failure_info, Some(FailureInfo::TimeoutFailureInfo(_)))
+        pub fn is_timeout(&self) -> Option<crate::temporal::api::enums::v1::TimeoutType> {
+            match &self.failure_info {
+                Some(FailureInfo::TimeoutFailureInfo(ti)) => Some(ti.timeout_type()),
+                _ => None,
+            }
         }
 
         pub fn application_failure(message: String, non_retryable: bool) -> Self {
@@ -1182,7 +1197,22 @@ pub mod coresdk {
 
     impl From<anyhow::Error> for Failure {
         fn from(ae: anyhow::Error) -> Self {
-            Failure::application_failure(ae.to_string(), false)
+            Self {
+                failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                    ApplicationFailureInfo {
+                        ..Default::default()
+                    },
+                )),
+                ..ae.chain()
+                    .rfold(None, |cause, e| {
+                        Some(Self {
+                            message: e.to_string(),
+                            cause: cause.map(Box::new),
+                            ..Default::default()
+                        })
+                    })
+                    .unwrap_or_default()
+            }
         }
     }
 
@@ -1320,11 +1350,6 @@ pub mod coresdk {
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
-        pub mod cluster {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.cluster.v1");
-            }
-        }
         pub mod batch {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.batch.v1");
@@ -1414,6 +1439,16 @@ pub mod temporal {
                     }
                 }
 
+                impl From<workflow_commands::ModifyWorkflowProperties> for command::Attributes {
+                    fn from(s: workflow_commands::ModifyWorkflowProperties) -> Self {
+                        Self::ModifyWorkflowPropertiesCommandAttributes(
+                            ModifyWorkflowPropertiesCommandAttributes {
+                                upserted_memo: s.upserted_memo.map(Into::into),
+                            },
+                        )
+                    }
+                }
+
                 impl From<workflow_commands::CancelTimer> for command::Attributes {
                     fn from(s: workflow_commands::CancelTimer) -> Self {
                         Self::CancelTimerCommandAttributes(CancelTimerCommandAttributes {
@@ -1647,14 +1682,7 @@ pub mod temporal {
 
                 impl History {
                     pub fn extract_run_id_from_start(&self) -> Result<&str, anyhow::Error> {
-                        if let Some(
-                            history_event::Attributes::WorkflowExecutionStartedEventAttributes(wes),
-                        ) = self.events.get(0).and_then(|x| x.attributes.as_ref())
-                        {
-                            Ok(&wes.original_execution_run_id)
-                        } else {
-                            bail!("First event is not WorkflowExecutionStarted?!?")
-                        }
+                        extract_original_run_id_from_events(&self.events)
                     }
 
                     /// Returns the event id of the final event in the history. Will return 0 if
@@ -1664,6 +1692,18 @@ pub mod temporal {
                     }
                 }
 
+                pub fn extract_original_run_id_from_events(
+                    events: &[HistoryEvent],
+                ) -> Result<&str, anyhow::Error> {
+                    if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+                        events.get(0).and_then(|x| x.attributes.as_ref())
+                    {
+                        Ok(&wes.original_execution_run_id)
+                    } else {
+                        bail!("First event is not WorkflowExecutionStarted?!?")
+                    }
+                }
+
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
@@ -1749,6 +1789,11 @@ pub mod temporal {
                 }
             }
         }
+        pub mod interaction {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.interaction.v1");
+            }
+        }
         pub mod namespace {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.namespace.v1");
@@ -1794,11 +1839,6 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.testservice.v1");
             }
         }
-        pub mod update {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.update.v1");
-            }
-        }
         pub mod version {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.version.v1");
@@ -1820,12 +1860,12 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.workflowservice.v1");
 
                 macro_rules! sched_to_start_impl {
-                    () => {
-                        /// Return the duration of the task schedule time to its start time if both
-                        /// are set and time went forward.
+                    ($sched_field:ident) => {
+                        /// Return the duration of the task schedule time (current attempt) to its
+                        /// start time if both are set and time went forward.
                         pub fn sched_to_start(&self) -> Option<Duration> {
                             if let Some((sch, st)) =
-                                self.scheduled_time.clone().zip(self.started_time.clone())
+                                self.$sched_field.clone().zip(self.started_time.clone())
                             {
                                 let sch: Result<SystemTime, _> = sch.try_into();
                                 let st: Result<SystemTime, _> = st.try_into();
@@ -1839,7 +1879,7 @@ pub mod temporal {
                 }
 
                 impl PollWorkflowTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(scheduled_time);
                 }
 
                 impl Display for PollWorkflowTaskQueueResponse {
@@ -1881,7 +1921,7 @@ pub mod temporal {
                 }
 
                 impl PollActivityTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(current_attempt_scheduled_time);
                 }
 
                 impl QueryWorkflowResponse {
@@ -1908,3 +1948,23 @@ pub mod grpc {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::temporal::api::failure::v1::Failure;
+    use anyhow::anyhow;
+
+    #[test]
+    fn anyhow_to_failure_conversion() {
+        let no_causes: Failure = anyhow!("no causes").into();
+        assert_eq!(no_causes.cause, None);
+        assert_eq!(no_causes.message, "no causes");
+        let orig = anyhow!("fail 1");
+        let mid = orig.context("fail 2");
+        let top = mid.context("fail 3");
+        let as_fail: Failure = top.into();
+        assert_eq!(as_fail.message, "fail 3");
+        assert_eq!(as_fail.cause.as_ref().unwrap().message, "fail 2");
+        assert_eq!(as_fail.cause.unwrap().cause.unwrap().message, "fail 1");
+    }
+}

data/bridge/sdk-core/test-utils/Cargo.toml

@@ -11,9 +11,10 @@ path = "src/histfetch.rs"
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
-base64 = "0.13"
+base64 = "0.20"
 futures = "0.3"
 log = "0.4"
+once_cell = "1.16"
 parking_lot = "0.12"
 prost = "0.11"
 prost-types = "0.11"

data/bridge/sdk-core/test-utils/src/lib.rs

@@ -6,7 +6,7 @@ extern crate tracing;
 
 pub mod canned_histories;
 
-use crate::stream::TryStreamExt;
+use crate::stream::{Stream, TryStreamExt};
 use futures::{future, stream, stream::FuturesUnordered, StreamExt};
 use parking_lot::Mutex;
 use prost::Message;
@@ -18,14 +18,23 @@ use std::{
 use temporal_client::{
     Client, RetryClient, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
 };
-use temporal_sdk::{interceptors::WorkerInterceptor, IntoActivityFunc, Worker, WorkflowFunction};
+use temporal_sdk::{
+    interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor},
+    IntoActivityFunc, Worker, WorkflowFunction,
+};
 use temporal_sdk_core::{
     ephemeral_server::{EphemeralExe, EphemeralExeVersion},
-    init_replay_worker, init_worker, telemetry_init, ClientOptions, ClientOptionsBuilder, Logger,
-    MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
-    TraceExporter, WorkerConfig, WorkerConfigBuilder,
+    init_replay_worker, init_worker,
+    replay::HistoryForReplay,
+    ClientOptions, ClientOptionsBuilder, CoreRuntime, WorkerConfig, WorkerConfigBuilder,
+};
+use temporal_sdk_core_api::{
+    telemetry::{
+        Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
+        TraceExportConfig, TraceExporter,
+    },
+    Worker as CoreWorker,
 };
-use temporal_sdk_core_api::Worker as CoreWorker;
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_commands::{
@@ -61,21 +70,43 @@ pub async fn init_core_and_create_wf(test_name: &str) -> CoreWfStarter {
     starter
 }
 
-/// Create a worker replay instance preloaded with a provided history. Returns the worker impl
-/// and the task queue name as in [init_core_and_create_wf].
-pub fn init_core_replay_preloaded(
-    test_name: &str,
-    history: &History,
-) -> (Arc<dyn CoreWorker>, String) {
-    telemetry_init(&get_integ_telem_options()).expect("Telemetry inits cleanly");
+/// Create a worker replay instance preloaded with provided histories. Returns the worker impl.
+pub fn init_core_replay_preloaded<I>(test_name: &str, histories: I) -> Arc<dyn CoreWorker>
+where
+    I: IntoIterator<Item = HistoryForReplay> + 'static,
+    <I as IntoIterator>::IntoIter: Send,
+{
+    init_core_replay_stream(test_name, stream::iter(histories))
+}
+pub fn init_core_replay_stream<I>(test_name: &str, histories: I) -> Arc<dyn CoreWorker>
+where
+    I: Stream<Item = HistoryForReplay> + Send + 'static,
+{
     let worker_cfg = WorkerConfigBuilder::default()
         .namespace(NAMESPACE)
         .task_queue(test_name)
         .worker_build_id("test_bin_id")
         .build()
         .expect("Configuration options construct properly");
-    let worker = init_replay_worker(worker_cfg, history).expect("Replay worker must init properly");
-    (Arc::new(worker), test_name.to_string())
+    let worker =
+        init_replay_worker(worker_cfg, histories).expect("Replay worker must init properly");
+    Arc::new(worker)
+}
+pub fn replay_sdk_worker<I>(histories: I) -> Worker
+where
+    I: IntoIterator<Item = HistoryForReplay> + 'static,
+    <I as IntoIterator>::IntoIter: Send,
+{
+    replay_sdk_worker_stream(stream::iter(histories))
+}
+pub fn replay_sdk_worker_stream<I>(histories: I) -> Worker
+where
+    I: Stream<Item = HistoryForReplay> + Send + 'static,
+{
+    let core = init_core_replay_stream("replay_worker_test", histories);
+    let mut worker = Worker::new_from_core(core, "replay_q".to_string());
+    worker.set_worker_interceptor(Box::new(FailOnNondeterminismInterceptor {}));
+    worker
 }
 
 /// Load history from a file containing the protobuf serialization of it
@@ -87,11 +118,21 @@ pub async fn history_from_proto_binary(path_from_root: &str) -> Result<History,
     Ok(History::decode(&*bytes)?)
 }
 
+static INTEG_TESTS_RT: once_cell::sync::OnceCell<CoreRuntime> = once_cell::sync::OnceCell::new();
+pub fn init_integ_telem() {
+    INTEG_TESTS_RT.get_or_init(|| {
+        let telemetry_options = get_integ_telem_options();
+        let rt =
+            CoreRuntime::new_assume_tokio(telemetry_options).expect("Core runtime inits cleanly");
+        let _ = tracing::subscriber::set_global_default(rt.trace_subscriber());
+        rt
+    });
+}
+
 /// Implements a builder pattern to help integ tests initialize core and create workflows
 pub struct CoreWfStarter {
     /// Used for both the task queue and workflow id
     task_queue_name: String,
-    telemetry_options: TelemetryOptions,
     pub worker_config: WorkerConfig,
     wft_timeout: Option<Duration>,
     initted_worker: OnceCell<InitializedWorker>,
@@ -110,9 +151,9 @@ impl CoreWfStarter {
     }
 
     pub fn new_tq_name(task_queue: &str) -> Self {
+        init_integ_telem();
         Self {
             task_queue_name: task_queue.to_owned(),
-            telemetry_options: get_integ_telem_options(),
             worker_config: WorkerConfigBuilder::default()
                 .namespace(NAMESPACE)
                 .task_queue(task_queue)
@@ -181,19 +222,21 @@ impl CoreWfStarter {
         &mut self,
         wf_id: impl Into<String>,
         run_id: impl Into<String>,
-        // TODO: Need not be passed in
         worker: &mut Worker,
     ) -> Result<(), anyhow::Error> {
+        let wf_id = wf_id.into();
         // Fetch history and replay it
         let history = self
             .get_client()
             .await
-            .get_workflow_execution_history(wf_id.into(), Some(run_id.into()), vec![])
+            .get_workflow_execution_history(wf_id.clone(), Some(run_id.into()), vec![])
             .await?
             .history
             .expect("history field must be populated");
-        let (replay_worker, _) = init_core_replay_preloaded(worker.task_queue(), &history);
+        let with_id = HistoryForReplay::new(history, wf_id);
+        let replay_worker = init_core_replay_preloaded(worker.task_queue(), [with_id]);
         worker.with_new_core_worker(replay_worker);
+        worker.set_worker_interceptor(Box::new(FailOnNondeterminismInterceptor {}));
         worker.run().await.unwrap();
         Ok(())
     }
@@ -239,14 +282,18 @@ impl CoreWfStarter {
     async fn get_or_init(&mut self) -> &InitializedWorker {
         self.initted_worker
             .get_or_init(|| async {
-                telemetry_init(&self.telemetry_options).expect("Telemetry inits cleanly");
                 let client = Arc::new(
                     get_integ_server_options()
                         .connect(self.worker_config.namespace.clone(), None, None)
                         .await
                         .expect("Must connect"),
                 );
-                let worker = init_worker(self.worker_config.clone(), client.clone());
+                let worker = init_worker(
+                    INTEG_TESTS_RT.get().unwrap(),
+                    self.worker_config.clone(),
+                    client.clone(),
+                )
+                .expect("Worker inits cleanly");
                 InitializedWorker {
                     worker: Arc::new(worker),
                     client,
@@ -442,7 +489,6 @@ impl WorkerInterceptor for TestWorkerCompletionIceptor {
 
 /// Returns the client options used to connect to the server used for integration tests.
 pub fn get_integ_server_options() -> ClientOptions {
-    telemetry_init(&get_integ_telem_options()).expect("Telemetry inits cleanly");
     let temporal_server_address = match env::var(INTEG_SERVER_TARGET_ENV_VAR) {
         Ok(addr) => addr,
         Err(_) => "http://localhost:7233".to_owned(),
@@ -459,6 +505,8 @@ pub fn get_integ_server_options() -> ClientOptions {
 
 pub fn get_integ_telem_options() -> TelemetryOptions {
     let mut ob = TelemetryOptionsBuilder::default();
+    let filter_string =
+        env::var("RUST_LOG").unwrap_or_else(|_| "temporal_sdk_core=INFO".to_string());
     if let Some(url) = env::var(OTEL_URL_ENV_VAR)
         .ok()
         .map(|x| x.parse::<Url>().unwrap())
@@ -466,8 +514,12 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
         let opts = OtelCollectorOptions {
             url,
             headers: Default::default(),
+            metric_periodicity: None,
         };
-        ob.tracing(TraceExporter::Otel(opts.clone()));
+        ob.tracing(TraceExportConfig {
+            filter: filter_string.clone(),
+            exporter: TraceExporter::Otel(opts.clone()),
+        });
         ob.metrics(MetricsExporter::Otel(opts));
     }
     if let Some(addr) = env::var(PROM_ENABLE_ENV_VAR)
@@ -476,10 +528,11 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
     {
         ob.metrics(MetricsExporter::Prometheus(addr));
     }
-    ob.tracing_filter(env::var("RUST_LOG").unwrap_or_else(|_| "temporal_sdk_core=INFO".to_string()))
-        .logging(Logger::Console)
-        .build()
-        .unwrap()
+    ob.logging(Logger::Console {
+        filter: filter_string,
+    })
+    .build()
+    .unwrap()
 }
 
 pub fn default_cached_download() -> EphemeralExe {
@@ -504,7 +557,6 @@ pub fn schedule_activity_cmd(
         seq,
         activity_id: activity_id.to_string(),
         activity_type: "test_activity".to_string(),
-        namespace: NAMESPACE.to_owned(),
         task_queue: task_q.to_owned(),
         schedule_to_start_timeout: Some(activity_timeout.try_into().expect("duration fits")),
         start_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),

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

@@ -13,7 +13,10 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
         ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
-    temporal::api::common::v1::{Payload, RetryPolicy},
+    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,
@@ -196,7 +199,7 @@ async fn activity_doesnt_heartbeat_hits_timeout_then_completes() {
                 ..Default::default()
             })
             .await;
-        assert!(res.timed_out());
+        assert_eq!(res.timed_out(), Some(TimeoutType::Heartbeat));
         Ok(().into())
     });
 

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

@@ -3,7 +3,6 @@ use futures::future::join_all;
 use std::time::Duration;
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_api::errors::PollWfError;
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
     workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
@@ -132,15 +131,3 @@ async fn can_paginate_long_history() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
-
-// TODO: Takes ages now, fix somehow
-#[tokio::test]
-async fn poll_of_nonexistent_namespace_is_fatal() {
-    let mut starter = CoreWfStarter::new("whatever_yo");
-    starter.worker_config.namespace = "I do not exist".to_string();
-    let worker = starter.get_worker().await;
-    assert_matches!(
-        worker.poll_workflow_activation().await,
-        Err(PollWfError::TonicError(_))
-    );
-}