@temporalio/core-bridge 0.20.2 → 0.22.0

package/sdk-core/test-utils/src/lib.rs

@@ -6,12 +6,13 @@ extern crate tracing;
 
 pub mod canned_histories;
 
-use futures::{stream::FuturesUnordered, StreamExt};
+use crate::stream::TryStreamExt;
+use futures::{stream, stream::FuturesUnordered, StreamExt};
 use log::LevelFilter;
+use parking_lot::Mutex;
 use prost::Message;
 use rand::{distributions::Standard, Rng};
 use std::{
-    cell::RefCell,
     convert::TryFrom,
     env,
     future::Future,
@@ -23,7 +24,9 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{Client, RetryClient, WorkflowClientTrait, WorkflowOptions};
+use temporal_client::{
+    Client, RetryClient, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
+};
 use temporal_sdk::{interceptors::WorkerInterceptor, IntoActivityFunc, Worker, WorkflowFunction};
 use temporal_sdk_core::{
     init_replay_worker, init_worker, telemetry_init, ClientOptions, ClientOptionsBuilder,
@@ -251,25 +254,30 @@ impl CoreWfStarter {
     }
 }
 
-/// Provides conveniences for running integ tests with the SDK
+/// Provides conveniences for running integ tests with the SDK (against real server or mocks)
 pub struct TestWorker {
     inner: Worker,
-    client: Option<Arc<dyn WorkflowClientTrait>>,
+    pub orig_core_worker: Arc<dyn CoreWorker>,
+    client: Option<Arc<RetryClient<Client>>>,
+    /// Defaults true, and if set, auto-shutdown the worker once all workflows started via
+    /// `submit_wf` have completed (as determined by fetching their result with following runs).
+    pub auto_shutdown: bool,
+    started_workflows: Mutex<Vec<WorkflowExecutionInfo>>,
+    /// Used only for mocked testing, where fetching results to determine if a WF is finished is too
+    /// annoying to make work.
     incomplete_workflows: Arc<AtomicUsize>,
 }
 impl TestWorker {
     /// Create a new test worker
     pub fn new(core_worker: Arc<dyn CoreWorker>, task_queue: impl Into<String>) -> Self {
         let ct = Arc::new(AtomicUsize::new(0));
-        let mut inner = Worker::new_from_core(core_worker, task_queue);
-        let iceptor = WorkflowCompletionCountingInterceptor {
-            incomplete_workflows: ct.clone(),
-            shutdown_handle: Box::new(inner.shutdown_handle()),
-        };
-        inner.set_worker_interceptor(Box::new(iceptor));
+        let inner = Worker::new_from_core(core_worker.clone(), task_queue);
         Self {
             inner,
+            orig_core_worker: core_worker,
             client: None,
+            auto_shutdown: true,
+            started_workflows: Mutex::new(vec![]),
             incomplete_workflows: ct,
         }
     }
@@ -278,11 +286,6 @@ impl TestWorker {
         &mut self.inner
     }
 
-    pub fn incr_expected_run_count(&self, amount: usize) {
-        self.incomplete_workflows
-            .fetch_add(amount, Ordering::AcqRel);
-    }
-
     // TODO: Maybe trait-ify?
     pub fn register_wf<F: Into<WorkflowFunction>>(
         &mut self,
@@ -313,7 +316,6 @@ impl TestWorker {
         input: Vec<Payload>,
         options: WorkflowOptions,
     ) -> Result<String, anyhow::Error> {
-        self.incr_expected_run_count(1);
         if let Some(c) = self.client.as_ref() {
             let wfid = workflow_id.into();
             let res = c
@@ -325,6 +327,11 @@ impl TestWorker {
                     options,
                 )
                 .await?;
+            self.started_workflows.lock().push(WorkflowExecutionInfo {
+                namespace: c.namespace().to_string(),
+                workflow_id: wfid,
+                run_id: Some(res.run_id.clone()),
+            });
             Ok(res.run_id)
         } else {
             Ok("fake_run_id".to_string())
@@ -333,46 +340,80 @@ impl TestWorker {
 
     /// Runs until all expected workflows have completed
     pub async fn run_until_done(&mut self) -> Result<(), anyhow::Error> {
-        self.inner.run().await
+        self.run_until_done_intercepted(Option::<TestWorkerInterceptor>::None)
+            .await
     }
 
     /// See [Self::run_until_done], except calls the provided callback just before performing core
     /// shutdown.
-    pub async fn run_until_done_shutdown_hook(
+    pub async fn run_until_done_intercepted(
         &mut self,
-        before_shutdown: impl FnOnce() + 'static,
+        interceptor: Option<impl WorkerInterceptor + 'static>,
     ) -> Result<(), anyhow::Error> {
-        // Replace shutdown interceptor with one that calls the before hook first
-        let b4shut = RefCell::new(Some(before_shutdown));
-        let shutdown_handle = self.inner.shutdown_handle();
-        let iceptor = WorkflowCompletionCountingInterceptor {
+        let iceptor = TestWorkerInterceptor {
             incomplete_workflows: self.incomplete_workflows.clone(),
-            shutdown_handle: Box::new(move || {
-                if let Some(s) = b4shut.borrow_mut().take() {
-                    s();
-                }
-                shutdown_handle();
-            }),
+            // Only use counting-based shutdown in the interceptor in mocked tests
+            shutdown_handle: if self.auto_shutdown && self.client.is_none() {
+                Some(Box::new(self.inner.shutdown_handle()))
+            } else {
+                None
+            },
+            next: interceptor.map(|i| Box::new(i) as Box<dyn WorkerInterceptor>),
         };
         self.inner.set_worker_interceptor(Box::new(iceptor));
-        self.inner.run().await
+        let workflows_complete_fut = async {
+            if self.auto_shutdown && self.client.is_some() {
+                let wfs = std::mem::take(self.started_workflows.get_mut());
+                let client = self.client.clone().expect("Client must exist when running");
+                stream::iter(
+                    wfs.into_iter()
+                        .map(|info| info.bind_untyped((*client).clone())),
+                )
+                .map(Ok)
+                .try_for_each_concurrent(None, |wh| async move {
+                    wh.get_workflow_result(Default::default()).await?;
+                    Ok::<_, anyhow::Error>(())
+                })
+                .await?;
+                self.orig_core_worker.initiate_shutdown();
+            }
+            Ok::<_, anyhow::Error>(())
+        };
+        tokio::try_join!(self.inner.run(), workflows_complete_fut)?;
+        Ok(())
     }
 }
 
-struct WorkflowCompletionCountingInterceptor {
+/// Implements calling the shutdown handle when the expected number of test workflows has completed
+struct TestWorkerInterceptor {
     incomplete_workflows: Arc<AtomicUsize>,
-    shutdown_handle: Box<dyn Fn()>,
+    shutdown_handle: Option<Box<dyn Fn()>>,
+    next: Option<Box<dyn WorkerInterceptor>>,
 }
-impl WorkerInterceptor for WorkflowCompletionCountingInterceptor {
-    fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
+
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for TestWorkerInterceptor {
+    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
         if completion.has_execution_ending() {
             info!("Workflow {} says it's finishing", &completion.run_id);
             let prev = self.incomplete_workflows.fetch_sub(1, Ordering::SeqCst);
             if prev <= 1 {
-                // There are now zero, we just subtracted one
-                (self.shutdown_handle)()
+                if let Some(sh) = self.shutdown_handle.as_ref() {
+                    info!("Test worker calling shutdown");
+                    // There are now zero, we just subtracted one
+                    sh()
+                }
             }
         }
+        if let Some(n) = self.next.as_ref() {
+            n.on_workflow_activation_completion(completion).await;
+        }
+    }
+
+    fn on_shutdown(&self, sdk_worker: &Worker) {
+        if let Some(n) = self.next.as_ref() {
+            n.on_shutdown(sdk_worker);
+        }
     }
 }
 

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

@@ -1,7 +1,7 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{
@@ -44,13 +44,14 @@ async fn one_activity() {
     let wf_name = "one_activity";
     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(), one_activity_wf);
     worker.register_activity(
         "echo_activity",
-        |echo_me: String| async move { Ok(echo_me) },
+        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
     );
 
-    worker
+    let run_id = worker
         .submit_wf(
             wf_name.to_owned(),
             wf_name.to_owned(),
@@ -60,6 +61,12 @@ async fn one_activity() {
         .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]

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

@@ -36,7 +36,6 @@ async fn child_workflow_happy_path() {
 
     worker.register_wf(PARENT_WF_TYPE.to_string(), parent_wf);
     worker.register_wf(CHILD_WF_TYPE.to_string(), child_wf);
-    worker.incr_expected_run_count(1); // Expect another WF to be run as child
 
     worker
         .submit_wf(

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

@@ -33,8 +33,6 @@ async fn continue_as_new_happy_path() {
         )
         .await
         .unwrap();
-    // The four additional runs
-    worker.incr_expected_run_count(4);
     worker.run_until_done().await.unwrap();
 }
 
@@ -58,6 +56,5 @@ async fn continue_as_new_multiple_concurrent() {
             .await
             .unwrap();
     }
-    worker.incr_expected_run_count(20 * 4);
     worker.run_until_done().await.unwrap();
 }

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

@@ -3,16 +3,17 @@ use futures::future::join_all;
 use std::time::Duration;
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{
-    act_cancelled, act_is_cancelled, ActivityCancelledError, CancellableFuture,
+    interceptors::WorkerInterceptor, ActContext, ActivityCancelledError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
 };
 use temporal_sdk_core_protos::coresdk::{
-    common::RetryPolicy, workflow_commands::ActivityCancellationType, AsJsonPayloadExt,
+    common::RetryPolicy, workflow_commands::ActivityCancellationType,
+    workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
 };
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio_util::sync::CancellationToken;
 
-pub async fn echo(e: String) -> anyhow::Result<String> {
+pub async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
     Ok(e)
 }
 
@@ -119,7 +120,7 @@ async fn long_running_local_act_with_timer() {
     starter.wft_timeout(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
-    worker.register_activity("echo_activity", |str: String| async {
+    worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {
         tokio::time::sleep(Duration::from_secs(4)).await;
         Ok(str)
     });
@@ -199,7 +200,7 @@ async fn local_act_retry_timer_backoff() {
         assert!(res.failed());
         Ok(().into())
     });
-    worker.register_activity("echo", |_: String| async {
+    worker.register_activity("echo", |_: ActContext, _: String| async {
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
 
@@ -245,12 +246,12 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
     let manual_cancel = CancellationToken::new();
     let manual_cancel_act = manual_cancel.clone();
 
-    worker.register_activity("echo", move |_: String| {
+    worker.register_activity("echo", move |ctx: ActContext, _: String| {
         let manual_cancel_act = manual_cancel_act.clone();
         async move {
             tokio::select! {
                 _ = tokio::time::sleep(Duration::from_secs(10)) => {},
-                _ = act_cancelled() => {
+                _ = ctx.cancelled() => {
                     return Err(anyhow!(ActivityCancelledError::default()))
                 }
                 _ = manual_cancel_act.cancelled() => {}
@@ -269,11 +270,24 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
         .await
         .unwrap();
     worker
-        .run_until_done_shutdown_hook(move || manual_cancel.cancel())
+        .run_until_done_intercepted(Some(LACancellerInterceptor {
+            token: manual_cancel,
+        }))
         .await
         .unwrap();
 }
 
+struct LACancellerInterceptor {
+    token: CancellationToken,
+}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for LACancellerInterceptor {
+    async fn on_workflow_activation_completion(&self, _: &WorkflowActivationCompletion) {}
+    fn on_shutdown(&self, _: &temporal_sdk::Worker) {
+        self.token.cancel()
+    }
+}
+
 #[rstest::rstest]
 #[case::while_running(None)]
 #[case::while_backing_off(Some(Duration::from_millis(1500)))]
@@ -329,11 +343,11 @@ async fn cancel_after_act_starts(
     let manual_cancel = CancellationToken::new();
     let manual_cancel_act = manual_cancel.clone();
 
-    worker.register_activity("echo", move |_: String| {
+    worker.register_activity("echo", move |ctx: ActContext, _: String| {
         let manual_cancel_act = manual_cancel_act.clone();
         async move {
             if cancel_on_backoff.is_some() {
-                if act_is_cancelled() {
+                if ctx.is_cancelled() {
                     return Err(anyhow!(ActivityCancelledError::default()));
                 }
                 // Just fail constantly so we get stuck on the backoff timer
@@ -341,7 +355,7 @@ async fn cancel_after_act_starts(
             } else {
                 tokio::select! {
                     _ = tokio::time::sleep(Duration::from_secs(100)) => {},
-                    _ = act_cancelled() => {
+                    _ = ctx.cancelled() => {
                         return Err(anyhow!(ActivityCancelledError::default()))
                     }
                     _ = manual_cancel_act.cancelled() => {
@@ -363,7 +377,9 @@ async fn cancel_after_act_starts(
         .await
         .unwrap();
     worker
-        .run_until_done_shutdown_hook(move || manual_cancel.cancel())
+        .run_until_done_intercepted(Some(LACancellerInterceptor {
+            token: manual_cancel,
+        }))
         .await
         .unwrap();
 }
@@ -406,10 +422,10 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
         assert!(res.timed_out());
         Ok(().into())
     });
-    worker.register_activity("echo", |_: String| async {
+    worker.register_activity("echo", |ctx: ActContext, _: String| async move {
         tokio::select! {
             _ = tokio::time::sleep(Duration::from_secs(100)) => {},
-            _ = act_cancelled() => {
+            _ = ctx.cancelled() => {
                 return Err(anyhow!(ActivityCancelledError::default()))
             }
         };
@@ -462,7 +478,7 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
         assert!(res.timed_out());
         Ok(().into())
     });
-    worker.register_activity("echo", |_: String| async {
+    worker.register_activity("echo", |_: ActContext, _: String| async {
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
 
@@ -486,7 +502,7 @@ async fn eviction_wont_make_local_act_get_dropped() {
     starter.wft_timeout(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
-    worker.register_activity("echo_activity", |str: String| async {
+    worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {
         tokio::time::sleep(Duration::from_secs(4)).await;
         Ok(str)
     });
@@ -540,7 +556,7 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         assert!(r2.failed());
         Ok(().into())
     });
-    worker.register_activity("echo", |_: String| async {
+    worker.register_activity("echo", |_: ActContext, _: String| async {
         Result::<(), _>::Err(anyhow!("Oh no I failed!"))
     });
 

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

@@ -1,6 +1,6 @@
 use futures::StreamExt;
 use std::{sync::Arc, time::Duration};
-use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
 use temporal_sdk::WfContext;
 use temporal_sdk_core_protos::temporal::api::{
     common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
@@ -15,6 +15,7 @@ async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
     let mut worker = starter.worker().await;
+    worker.auto_shutdown = false;
     let notify = Arc::new(Notify::new());
 
     let wf_notify = notify.clone();
@@ -77,6 +78,14 @@ async fn reset_workflow() {
             )
             .await
             .unwrap();
+
+        // Wait for the now-reset workflow to finish
+        client
+            .get_untyped_workflow_handle(wf_name.to_owned(), "")
+            .get_workflow_result(Default::default())
+            .await
+            .unwrap();
+        starter.shutdown().await;
     };
     let run_fut = worker.run_until_done();
     let (_, rr) = tokio::join!(resetter_fut, run_fut);

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

@@ -107,7 +107,6 @@ async fn sends_signal_to_child() {
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);
 
-    worker.incr_expected_run_count(1); // Expect another WF to be run as child
     worker
         .submit_wf(
             "sends-signal-to-child",

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

@@ -24,7 +24,9 @@ use std::{
     time::Duration,
 };
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk::{
+    interceptors::WorkerInterceptor, ActContext, ActivityOptions, WfContext, WorkflowResult,
+};
 use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -32,7 +34,7 @@ use temporal_sdk_core_protos::{
         workflow_activation::{workflow_activation_job, WorkflowActivation, WorkflowActivationJob},
         workflow_commands::{ActivityCancellationType, FailWorkflowExecution, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
-        ActivityTaskCompletion, IntoCompletion,
+        ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
     temporal::api::failure::v1::Failure,
 };
@@ -128,7 +130,19 @@ async fn workflow_lru_cache_evictions() {
             .await
             .unwrap();
     }
-    worker.run_until_done().await.unwrap();
+    struct CacheAsserter;
+    #[async_trait::async_trait(?Send)]
+    impl WorkerInterceptor for CacheAsserter {
+        async fn on_workflow_activation_completion(&self, _: &WorkflowActivationCompletion) {}
+        fn on_shutdown(&self, sdk_worker: &temporal_sdk::Worker) {
+            // 0 since the sdk worker force-evicts and drains everything on shutdown.
+            assert_eq!(sdk_worker.cached_workflows(), 0);
+        }
+    }
+    worker
+        .run_until_done_intercepted(Some(CacheAsserter))
+        .await
+        .unwrap();
     // The wf must have started more than # workflows times, since all but one must experience
     // an eviction
     assert!(RUN_CT.load(Ordering::SeqCst) > n_workflows);
@@ -515,3 +529,57 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let wf_task = poll_sched_act_poll().await;
     core.complete_execution(&wf_task.run_id).await;
 }
+
+/// We had a bug related to polling being faster than completion causing issues with cache
+/// overflow. This test intentionally makes completes slower than polls to evaluate that.
+///
+/// It's expected that this test may generate some task timeouts.
+#[tokio::test]
+async fn slow_completes_with_small_cache() {
+    let wf_name = "slow_completes_with_small_cache";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_wft(5).max_cached_workflows(5);
+    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;
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    });
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
+    );
+    for i in 0..20 {
+        worker
+            .submit_wf(
+                format!("{}_{}", wf_name, i),
+                wf_name.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+    }
+
+    struct SlowCompleter {}
+    #[async_trait::async_trait(?Send)]
+    impl WorkerInterceptor for SlowCompleter {
+        async fn on_workflow_activation_completion(&self, _: &WorkflowActivationCompletion) {
+            // They don't need to be much slower
+            tokio::time::sleep(Duration::from_millis(100)).await;
+        }
+        fn on_shutdown(&self, _: &temporal_sdk::Worker) {}
+    }
+    worker
+        .run_until_done_intercepted(Some(SlowCompleter {}))
+        .await
+        .unwrap();
+}

package/sdk-core/tests/load_tests.rs

@@ -1,18 +1,18 @@
 use assert_matches::assert_matches;
-use futures::future::join_all;
+use futures::{future::join_all, sink, stream::FuturesUnordered, StreamExt};
 use std::time::{Duration, Instant};
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, WfContext};
+use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext};
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityExecutionResult, activity_task::activity_task as act_task,
-    workflow_commands::ActivityCancellationType, ActivityTaskCompletion,
+    workflow_commands::ActivityCancellationType, ActivityTaskCompletion, AsJsonPayloadExt,
 };
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
-const CONCURRENCY: usize = 1000;
-
 #[tokio::test]
 async fn activity_load() {
+    const CONCURRENCY: usize = 1000;
+
     let mut starter = CoreWfStarter::new("activity_load");
     starter
         .max_wft(CONCURRENCY)
@@ -109,3 +109,77 @@ async fn activity_load() {
     };
     dbg!(running.elapsed());
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn workflow_load() {
+    const SIGNAME: &str = "signame";
+    let wf_name = "workflow_load";
+    let mut starter = CoreWfStarter::new("workflow_load");
+    starter
+        .max_wft(5)
+        .max_cached_workflows(5)
+        .max_at_polls(10)
+        .max_at(100);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
+        let drained_fut = sigchan.forward(sink::drain());
+
+        let real_stuff = async move {
+            for _ in 0..20 {
+                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;
+                ctx.timer(Duration::from_secs(1)).await;
+            }
+        };
+        tokio::select! {
+            _ = drained_fut => {}
+            _ = real_stuff => {}
+        }
+
+        Ok(().into())
+    });
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move { Ok(echo_me) },
+    );
+    let client = starter.get_client().await;
+
+    let mut workflow_handles = vec![];
+    for i in 0..200 {
+        let wfid = format!("{}_{}", wf_name, i);
+        let rid = worker
+            .submit_wf(
+                wfid.clone(),
+                wf_name.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+        workflow_handles.push(client.get_untyped_workflow_handle(wfid, rid));
+    }
+
+    let sig_sender = async {
+        loop {
+            let sends: FuturesUnordered<_> = (0..200)
+                .map(|i| {
+                    client.signal_workflow_execution(
+                        format!("{}_{}", wf_name, i),
+                        "".to_string(),
+                        SIGNAME.to_string(),
+                        None,
+                    )
+                })
+                .collect();
+            sends.map(|_| Ok(())).forward(sink::drain()).await.unwrap();
+            tokio::time::sleep(Duration::from_secs(2)).await;
+        }
+    };
+    tokio::select! { r1 = worker.run_until_done() => {r1.unwrap()}, _ = sig_sender => {}};
+}