temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/tests/{load_tests.rs → heavy_tests.rs}

@@ -1,17 +1,17 @@
-use assert_matches::assert_matches;
 use futures::{future::join_all, sink, stream::FuturesUnordered, StreamExt};
 use std::time::{Duration, Instant};
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
-    activity_result::ActivityExecutionResult, activity_task::activity_task as act_task,
-    workflow_commands::ActivityCancellationType, ActivityTaskCompletion, AsJsonPayloadExt,
+    workflow_commands::ActivityCancellationType, AsJsonPayloadExt,
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::{workflows::la_problem_workflow, CoreWfStarter};
+
+mod fuzzy_workflow;
 
 #[tokio::test]
 async fn activity_load() {
-    const CONCURRENCY: usize = 1000;
+    const CONCURRENCY: usize = 512;
 
     let mut starter = CoreWfStarter::new("activity_load");
     starter
@@ -23,18 +23,16 @@ async fn activity_load() {
 
     let activity_id = "act-1";
     let activity_timeout = Duration::from_secs(8);
-    let payload_dat = b"hello".to_vec();
     let task_queue = starter.get_task_queue().to_owned();
 
-    let pd = payload_dat.clone();
     let wf_fn = move |ctx: WfContext| {
         let task_queue = task_queue.clone();
-        let payload_dat = pd.clone();
-
+        let payload = "yo".as_json_payload().unwrap();
         async move {
             let activity = ActivityOptions {
                 activity_id: Some(activity_id.to_string()),
                 activity_type: "test_activity".to_string(),
+                input: payload.clone(),
                 task_queue,
                 schedule_to_start_timeout: Some(activity_timeout),
                 start_to_close_timeout: Some(activity_timeout),
@@ -44,7 +42,7 @@ async fn activity_load() {
                 ..Default::default()
             };
             let res = ctx.activity(activity).await.unwrap_ok_payload();
-            assert_eq!(res.data, payload_dat);
+            assert_eq!(res.data, payload.data);
             Ok(().into())
         }
     };
@@ -52,9 +50,13 @@ async fn activity_load() {
     let starting = Instant::now();
     let wf_type = "activity_load";
     worker.register_wf(wf_type.to_owned(), wf_fn);
+    worker.register_activity(
+        "test_activity",
+        |_ctx: ActContext, echo: String| async move { Ok(echo) },
+    );
     join_all((0..CONCURRENCY).map(|i| {
         let worker = &worker;
-        let wf_id = format!("activity_load_{}", i);
+        let wf_id = format!("activity_load_{i}");
         async move {
             worker
                 .submit_wf(
@@ -71,42 +73,8 @@ async fn activity_load() {
     dbg!(starting.elapsed());
 
     let running = Instant::now();
-    let core = starter.get_worker().await;
-
-    // Poll for and complete all activities
-    let c2 = core.clone();
-    let all_acts = async move {
-        let mut act_complete_futs = vec![];
-        for _ in 0..CONCURRENCY {
-            let task = c2.poll_activity_task().await.unwrap();
-            assert_matches!(
-                task.variant,
-                Some(act_task::Variant::Start(ref start_activity)) => {
-                    assert_eq!(start_activity.activity_type, "test_activity")
-                }
-            );
-            let pd = payload_dat.clone();
-            let core = c2.clone();
-            act_complete_futs.push(tokio::spawn(async move {
-                core.complete_activity_task(ActivityTaskCompletion {
-                    task_token: task.task_token,
-                    result: Some(ActivityExecutionResult::ok(pd.into())),
-                })
-                .await
-                .unwrap()
-            }));
-        }
-        join_all(act_complete_futs)
-            .await
-            .into_iter()
-            .for_each(|h| h.unwrap());
-    };
-    tokio::join! {
-        async {
-            worker.run_until_done().await.unwrap();
-        },
-        all_acts
-    };
+
+    worker.run_until_done().await.unwrap();
     dbg!(running.elapsed());
 }
 
@@ -153,7 +121,7 @@ async fn workflow_load() {
 
     let mut workflow_handles = vec![];
     for i in 0..num_workflows {
-        let wfid = format!("{}_{}", wf_name, i);
+        let wfid = format!("{wf_name}_{i}");
         let rid = worker
             .submit_wf(
                 wfid.clone(),
@@ -171,7 +139,7 @@ async fn workflow_load() {
             let sends: FuturesUnordered<_> = (0..num_workflows)
                 .map(|i| {
                     client.signal_workflow_execution(
-                        format!("{}_{}", wf_name, i),
+                        format!("{wf_name}_{i}"),
                         "".to_string(),
                         SIGNAME.to_string(),
                         None,
@@ -187,5 +155,111 @@ async fn workflow_load() {
             tokio::time::sleep(Duration::from_secs(2)).await;
         }
     };
-    tokio::select! { r1 = worker.run_until_done() => {r1.unwrap()}, _ = sig_sender => {}};
+    tokio::select! { r1 = worker.run_until_done() => {r1.unwrap()}, _ = sig_sender => {}}
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn evict_while_la_running_no_interference() {
+    let wf_name = "evict_while_la_running_no_interference";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_local_at(20);
+    starter.max_cached_workflows(20);
+    // Though it doesn't make sense to set wft higher than cached workflows, leaving this commented
+    // introduces more instability that can be useful in the test.
+    // starter.max_wft(20);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), la_problem_workflow);
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(15)).await;
+        Ok(())
+    });
+
+    let client = starter.get_client().await;
+    let subfs = FuturesUnordered::new();
+    for i in 1..100 {
+        let wf_id = format!("{wf_name}-{i}");
+        let run_id = worker
+            .submit_wf(
+                &wf_id,
+                wf_name.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+        let cw = worker.core_worker.clone();
+        let client = client.clone();
+        subfs.push(async move {
+            // Evict the workflow
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            cw.request_workflow_eviction(&run_id);
+            // Wake up workflow by sending signal
+            client
+                .signal_workflow_execution(
+                    wf_id,
+                    run_id.clone(),
+                    "whaatever".to_string(),
+                    None,
+                    None,
+                )
+                .await
+                .unwrap();
+        });
+    }
+    let runf = async {
+        worker.run_until_done().await.unwrap();
+    };
+    tokio::join!(subfs.collect::<Vec<_>>(), runf);
+}
+
+pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()> {
+    for _ in 0..120 {
+        let mut futs = vec![];
+        for _ in 0..100 {
+            futs.push(ctx.timer(Duration::from_millis(100)));
+        }
+        join_all(futs).await;
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn can_paginate_long_history() {
+    let wf_name = "can_paginate_long_history";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
+    // 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);
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    let client = starter.get_client().await;
+    tokio::spawn(async move {
+        loop {
+            for _ in 0..10 {
+                client
+                    .signal_workflow_execution(
+                        wf_name.to_owned(),
+                        run_id.clone(),
+                        "sig".to_string(),
+                        None,
+                        None,
+                    )
+                    .await
+                    .unwrap();
+            }
+            tokio::time::sleep(Duration::from_secs(3)).await;
+        }
+    });
+    worker.run_until_done().await.unwrap();
 }

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

@@ -1,13 +1,35 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
 use temporal_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
-    TestServerConfigBuilder,
+    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
+    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 temporal_cli_default() {
+    let config = TemporalDevServerConfigBuilder::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 temporal_cli_fixed() {
+    let config = TemporalDevServerConfigBuilder::default()
+        .exe(fixed_cached_download("v0.4.0"))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
 #[tokio::test]
 async fn temporalite_default() {
     let config = TemporaliteConfigBuilder::default()
@@ -22,7 +44,7 @@ async fn temporalite_default() {
 #[tokio::test]
 async fn temporalite_fixed() {
     let config = TemporaliteConfigBuilder::default()
-        .exe(fixed_cached_download("v0.1.1"))
+        .exe(fixed_cached_download("v0.2.0"))
         .build()
         .unwrap();
     let mut server = config.start_server().await.unwrap();

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

@@ -13,10 +13,15 @@ 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,
+    },
+    DEFAULT_ACTIVITY_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 use tokio::time::sleep;
 
@@ -46,7 +51,7 @@ async fn activity_heartbeat() {
     assert_matches!(
         task.variant,
         Some(activity_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string())
         }
     );
     // Heartbeat timeout is set to 1 second, this loop is going to send heartbeat every 100ms.
@@ -166,7 +171,7 @@ async fn many_act_fails_with_heartbeats() {
         },]
     );
     core.complete_execution(&task.run_id).await;
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 #[tokio::test]
@@ -196,7 +201,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,239 @@
+use std::{sync::Arc, time::Duration};
+use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_sdk_core::{init_worker, CoreRuntime};
+use temporal_sdk_core_api::{telemetry::MetricsExporter, worker::WorkerConfigBuilder, Worker};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_result::ActivityExecutionResult,
+        workflow_commands::{ScheduleActivity, ScheduleLocalActivity},
+        workflow_completion::WorkflowActivationCompletion,
+        ActivityTaskCompletion,
+    },
+    temporal::api::{enums::v1::WorkflowIdReusePolicy, workflowservice::v1::ListNamespacesRequest},
+};
+use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options, NAMESPACE};
+use tokio::sync::Barrier;
+
+static ANY_PORT: &str = "127.0.0.1:0";
+
+async fn get_text(endpoint: String) -> String {
+    reqwest::get(endpoint).await.unwrap().text().await.unwrap()
+}
+
+#[tokio::test]
+async fn prometheus_metrics_exported() {
+    let mut telemopts = get_integ_telem_options();
+    telemopts.metrics = Some(MetricsExporter::Prometheus(ANY_PORT.parse().unwrap()));
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let addr = rt.telemetry().prom_port().unwrap();
+    let opts = get_integ_server_options();
+    let mut raw_client = opts
+        .connect_no_namespace(rt.metric_meter().as_deref(), None)
+        .await
+        .unwrap();
+    assert!(raw_client.get_client().capabilities().is_some());
+
+    let _ = raw_client
+        .list_namespaces(ListNamespacesRequest::default())
+        .await
+        .unwrap();
+
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    assert!(body.contains(
+        "temporal_request_latency_count{operation=\"ListNamespaces\",service_name=\"temporal-core-sdk\"} 1"
+    ));
+    assert!(body.contains(
+        "temporal_request_latency_count{operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\"} 1"
+    ));
+}
+
+#[tokio::test]
+async fn one_slot_worker_reports_available_slot() {
+    let mut telemopts = get_integ_telem_options();
+    let tq = "one_slot_worker_tq";
+    telemopts.metrics = Some(MetricsExporter::Prometheus(ANY_PORT.parse().unwrap()));
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let addr = rt.telemetry().prom_port().unwrap();
+
+    let worker_cfg = WorkerConfigBuilder::default()
+        .namespace(NAMESPACE)
+        .task_queue(tq)
+        .worker_build_id("test_build_id")
+        .max_cached_workflows(1_usize)
+        .max_outstanding_activities(1_usize)
+        .max_outstanding_local_activities(1_usize)
+        .max_outstanding_workflow_tasks(1_usize)
+        .build()
+        .unwrap();
+
+    let client = Arc::new(
+        get_integ_server_options()
+            .connect(worker_cfg.namespace.clone(), None, None)
+            .await
+            .expect("Must connect"),
+    );
+    let worker = init_worker(&rt, worker_cfg, client.clone()).expect("Worker inits cleanly");
+    let wf_task_barr = Barrier::new(2);
+    let act_task_barr = Barrier::new(2);
+
+    let wf_polling = async {
+        let task = worker.poll_workflow_activation().await.unwrap();
+        wf_task_barr.wait().await;
+        wf_task_barr.wait().await;
+        worker
+            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                task.run_id,
+                ScheduleActivity {
+                    seq: 1,
+                    activity_id: "1".to_string(),
+                    activity_type: "test_act".to_string(),
+                    task_queue: tq.to_string(),
+                    start_to_close_timeout: Some(prost_dur!(from_secs(30))),
+                    ..Default::default()
+                }
+                .into(),
+            ))
+            .await
+            .unwrap();
+        wf_task_barr.wait().await;
+
+        let task = worker.poll_workflow_activation().await.unwrap();
+        worker
+            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                task.run_id,
+                ScheduleLocalActivity {
+                    seq: 2,
+                    activity_id: "2".to_string(),
+                    activity_type: "test_act".to_string(),
+                    start_to_close_timeout: Some(prost_dur!(from_secs(30))),
+                    ..Default::default()
+                }
+                .into(),
+            ))
+            .await
+            .unwrap();
+    };
+
+    let act_polling = async {
+        let task = worker.poll_activity_task().await.unwrap();
+        act_task_barr.wait().await;
+        worker
+            .complete_activity_task(ActivityTaskCompletion {
+                task_token: task.task_token,
+                result: Some(ActivityExecutionResult::ok(vec![1].into())),
+            })
+            .await
+            .unwrap();
+        act_task_barr.wait().await;
+
+        let task = worker.poll_activity_task().await.unwrap();
+        act_task_barr.wait().await;
+        act_task_barr.wait().await;
+        worker
+            .complete_activity_task(ActivityTaskCompletion {
+                task_token: task.task_token,
+                result: Some(ActivityExecutionResult::ok(vec![1].into())),
+            })
+            .await
+            .unwrap();
+        act_task_barr.wait().await;
+    };
+
+    let testing = async {
+        // Wait just a beat for the poller to initiate
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"WorkflowWorker\"}} 1"
+        )));
+
+        // Start a workflow so that a task will get delivered
+        client
+            .start_workflow(
+                vec![],
+                tq.to_owned(),
+                "one_slot_metric_test".to_owned(),
+                "whatever".to_string(),
+                None,
+                WorkflowOptions {
+                    id_reuse_policy: WorkflowIdReusePolicy::TerminateIfRunning,
+                    execution_timeout: Some(Duration::from_secs(5)),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap();
+
+        wf_task_barr.wait().await;
+
+        // At this point the workflow task is outstanding, so there should be 0 slots, and
+        // the activities haven't started, so there should be 1 each.
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"WorkflowWorker\"}} 0"
+        )));
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"ActivityWorker\"}} 1"
+        )));
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"LocalActivityWorker\"}} 1"
+        )));
+
+        // Now we allow the complete to proceed. Once it goes through, there should be 1 WFT slot
+        // open but 0 activity slots
+        wf_task_barr.wait().await;
+        wf_task_barr.wait().await;
+        // Sometimes the recording takes an extra bit. 🤷
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"WorkflowWorker\"}} 1"
+        )));
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"ActivityWorker\"}} 0"
+        )));
+
+        // Now complete the activity and watch it go up
+        act_task_barr.wait().await;
+        // Wait for completion to finish
+        act_task_barr.wait().await;
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"ActivityWorker\"}} 1"
+        )));
+
+        // Proceed to local activity command
+        act_task_barr.wait().await;
+        // Ensure that, once we have the LA task, slots are 0
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"LocalActivityWorker\"}} 0"
+        )));
+        // When completion is done, we have 1 again
+        act_task_barr.wait().await;
+        act_task_barr.wait().await;
+        let body = get_text(format!("http://{addr}/metrics")).await;
+        assert!(body.contains(&format!(
+            "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
+             worker_type=\"LocalActivityWorker\"}} 1"
+        )));
+    };
+    tokio::join!(wf_polling, act_polling, testing);
+}

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

@@ -1,9 +1,5 @@
 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_api::errors::PollWfError;
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
     workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
@@ -12,7 +8,7 @@ use temporal_sdk_core_protos::coresdk::{
     IntoCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    init_core_and_create_wf, schedule_activity_cmd, WorkerTestHelpers,
 };
 use tokio::time::timeout;
 
@@ -44,15 +40,10 @@ async fn out_of_order_completion_doesnt_hang() {
     )
     .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.
+    // 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(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    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!(
@@ -97,50 +88,3 @@ async fn out_of_order_completion_doesnt_hang() {
 
     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();
-}
-
-// 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(_))
-    );
-}