@temporalio/core-bridge 0.14.0 → 0.16.4

package/sdk-core/src/workflow/workflow_tasks/cache_manager.rs

@@ -35,17 +35,13 @@ impl WorkflowCacheManager {
             // Blindly add a record into the cache, since it still has capacity.
             self.cache.put(run_id.to_owned(), ());
             None
-        } else if self.cache.cap() != 0 {
-            let maybe_got_evicted = self.cache.peek_lru().map(|r| r.0.to_owned());
-            let already_existed = self.cache.put(run_id.to_owned(), ()).is_some();
-            if !already_existed {
-                maybe_got_evicted
-            } else {
-                None
-            }
-        } else {
+        } else if self.cache.cap() == 0 {
             // Run id should be evicted right away as cache size is 0.
             Some(run_id.to_owned())
+        } else {
+            let maybe_got_evicted = self.cache.peek_lru().map(|r| r.0.clone());
+            let not_cached = self.cache.put(run_id.to_owned(), ()).is_none();
+            not_cached.then(|| maybe_got_evicted).flatten()
         };
 
         self.metrics.cache_size(self.cache.len() as u64);
@@ -75,7 +71,7 @@ mod tests {
         assert_matches!(wcm.insert("1"), None);
         assert_matches!(wcm.insert("2"), None);
         assert_matches!(wcm.insert("3"), Some(run_id) => {
-            assert_eq!(run_id, "1")
+            assert_eq!(run_id, "1");
         });
     }
 
@@ -88,7 +84,7 @@ mod tests {
         wcm.remove("1");
         assert_matches!(wcm.insert("2"), None);
         assert_matches!(wcm.insert("3"), Some(run_id) => {
-            assert_eq!(run_id, "2")
+            assert_eq!(run_id, "2");
         });
     }
 
@@ -110,7 +106,7 @@ mod tests {
         assert_matches!(wcm.insert("2"), None);
         wcm.touch("1");
         assert_matches!(wcm.insert("3"), Some(run_id) => {
-            assert_eq!(run_id, "2")
+            assert_eq!(run_id, "2");
         });
     }
 
@@ -123,7 +119,7 @@ mod tests {
         assert_matches!(wcm.insert("1"), None);
         assert_matches!(wcm.insert("2"), None);
         assert_matches!(wcm.insert("3"), Some(run_id) => {
-            assert_eq!(run_id, "1")
+            assert_eq!(run_id, "1");
         });
     }
 
@@ -133,10 +129,10 @@ mod tests {
             max_cached_workflows: 0,
         });
         assert_matches!(wcm.insert("1"), Some(run_id) => {
-            assert_eq!(run_id, "1")
+            assert_eq!(run_id, "1");
         });
         assert_matches!(wcm.insert("2"), Some(run_id) => {
-            assert_eq!(run_id, "2")
+            assert_eq!(run_id, "2");
         });
     }
 
@@ -144,10 +140,10 @@ mod tests {
     fn non_sticky_always_pending_eviction() {
         let mut wcm = WorkflowCacheManager::new_test(WorkflowCachingPolicy::NonSticky);
         assert_matches!(wcm.insert("1"), Some(run_id) => {
-            assert_eq!(run_id, "1")
+            assert_eq!(run_id, "1");
         });
         assert_matches!(wcm.insert("2"), Some(run_id) => {
-            assert_eq!(run_id, "2")
+            assert_eq!(run_id, "2");
         });
     }
 }

package/sdk-core/src/workflow/workflow_tasks/concurrency_manager.rs

@@ -1,5 +1,5 @@
 use crate::{
-    errors::WorkflowUpdateError,
+    errors::WorkflowMissingError,
     protosext::ValidPollWFTQResponse,
     telemetry::metrics::{workflow_type, MetricsContext},
     workflow::{
@@ -89,7 +89,7 @@ impl WorkflowConcurrencyManager {
     pub(crate) fn get_task_mut(
         &self,
         run_id: &str,
-    ) -> Result<impl DerefMut<Target = Option<OutstandingTask>> + '_, WorkflowUpdateError> {
+    ) -> Result<impl DerefMut<Target = Option<OutstandingTask>> + '_, WorkflowMissingError> {
         let writelock = self.runs.write();
         if writelock.contains_key(run_id) {
             Ok(RwLockWriteGuard::map(writelock, |hm| {
@@ -97,10 +97,8 @@ impl WorkflowConcurrencyManager {
                 &mut hm.get_mut(run_id).unwrap().wft
             }))
         } else {
-            Err(WorkflowUpdateError {
-                source: WFMachinesError::Fatal("Workflow machines not found".to_string()),
+            Err(WorkflowMissingError {
                 run_id: run_id.to_owned(),
-                task_token: None,
             })
         }
     }
@@ -146,7 +144,7 @@ impl WorkflowConcurrencyManager {
         &self,
         run_id: &str,
         task: OutstandingTask,
-    ) -> Result<(), WorkflowUpdateError> {
+    ) -> Result<(), WorkflowMissingError> {
         let mut dereffer = self.get_task_mut(run_id)?;
         *dereffer = Some(task);
         Ok(())
@@ -171,16 +169,14 @@ impl WorkflowConcurrencyManager {
         &self,
         run_id: &str,
         activation: OutstandingActivation,
-    ) -> Result<Option<OutstandingActivation>, WorkflowUpdateError> {
+    ) -> Result<Option<OutstandingActivation>, WorkflowMissingError> {
         let mut writelock = self.runs.write();
         let machine_ref = writelock.get_mut(run_id);
         if let Some(run) = machine_ref {
             Ok(run.activation.replace(activation))
         } else {
-            Err(WorkflowUpdateError {
-                source: WFMachinesError::Fatal("Workflow machines not found".to_string()),
+            Err(WorkflowMissingError {
                 run_id: run_id.to_owned(),
-                task_token: None,
             })
         }
     }
@@ -188,11 +184,7 @@ impl WorkflowConcurrencyManager {
     pub fn delete_activation(&self, run_id: &str) -> Option<OutstandingActivation> {
         let mut writelock = self.runs.write();
         let machine_ref = writelock.get_mut(run_id);
-        if let Some(run) = machine_ref {
-            run.activation.take()
-        } else {
-            None
-        }
+        machine_ref.and_then(|run| run.activation.take())
     }
 
     pub fn exists(&self, run_id: &str) -> bool {
@@ -274,14 +266,14 @@ impl WorkflowConcurrencyManager {
     /// Remove the workflow with the provided run id from management
     pub fn evict(&self, run_id: &str) -> Option<ValidPollWFTQResponse> {
         let val = self.runs.write().remove(run_id);
-        val.map(|v| v.buffered_resp).flatten()
+        val.and_then(|v| v.buffered_resp)
     }
 
     /// Clear and return any buffered polling response for this run ID
     pub fn take_buffered_poll(&self, run_id: &str) -> Option<ValidPollWFTQResponse> {
         let mut writelock = self.runs.write();
         let val = writelock.get_mut(run_id);
-        val.map(|v| v.buffered_resp.take()).flatten()
+        val.and_then(|v| v.buffered_resp.take())
     }
 
     pub fn outstanding_wft(&self) -> usize {
@@ -315,6 +307,6 @@ mod tests {
             )
             .await;
         // Should whine that the machines have nothing to do (history empty)
-        assert_matches!(res.unwrap_err(), WFMachinesError::Fatal { .. })
+        assert_matches!(res.unwrap_err(), WFMachinesError::Fatal { .. });
     }
 }

package/sdk-core/src/workflow/workflow_tasks/mod.rs

@@ -4,7 +4,7 @@ mod cache_manager;
 mod concurrency_manager;
 
 use crate::{
-    errors::WorkflowUpdateError,
+    errors::{WorkflowMissingError, WorkflowUpdateError},
     machines::{ProtoCommand, WFCommand, WFMachinesError},
     pending_activations::PendingActivations,
     pollers::GatewayRef,
@@ -21,7 +21,7 @@ use crate::{
 use crossbeam::queue::SegQueue;
 use futures::FutureExt;
 use parking_lot::Mutex;
-use std::{fmt::Debug, ops::DerefMut, time::Instant};
+use std::{fmt::Debug, time::Instant};
 use temporal_sdk_core_protos::coresdk::{
     workflow_activation::{
         create_evict_activation, create_query_activation, wf_activation_job, QueryWorkflow,
@@ -77,9 +77,9 @@ pub(crate) enum OutstandingActivation {
 }
 
 impl OutstandingActivation {
-    fn has_eviction(&self) -> bool {
+    const fn has_eviction(self) -> bool {
         matches!(
-            &self,
+            self,
             OutstandingActivation::Normal {
                 contains_eviction: true
             }
@@ -96,7 +96,7 @@ pub struct WorkflowTaskInfo {
 }
 
 #[derive(Debug, derive_more::From)]
-pub enum NewWfTaskOutcome {
+pub(crate) enum NewWfTaskOutcome {
     /// A new activation for the workflow should be issued to lang
     IssueActivation(WfActivation),
     /// The poll loop should be restarted, there is nothing to do
@@ -106,6 +106,8 @@ pub enum NewWfTaskOutcome {
     Autocomplete,
     /// Workflow task had partial history and workflow was not present in the cache.
     CacheMiss,
+    /// The workflow task ran into problems while being applied and we must now evict the workflow
+    Evict(WorkflowUpdateError),
 }
 
 #[derive(Debug)]
@@ -162,9 +164,7 @@ impl WorkflowTaskManager {
         }
     }
 
-    pub(crate) fn next_pending_activation(
-        &self,
-    ) -> Result<Option<WfActivation>, WorkflowUpdateError> {
+    pub(crate) fn next_pending_activation(&self) -> Option<WfActivation> {
         // It is important that we do not issue pending activations for any workflows which already
         // have an outstanding activation. If we did, it can result in races where an in-progress
         // completion may appear to be the last in a task (no more pending activations) because
@@ -174,10 +174,14 @@ impl WorkflowTaskManager {
             .pending_activations
             .pop_first_matching(|rid| self.workflow_machines.get_activation(rid).is_none());
         if let Some(act) = maybe_act.as_ref() {
-            self.insert_outstanding_activation(act)?;
+            if let Err(WorkflowMissingError { run_id }) = self.insert_outstanding_activation(act) {
+                self.request_eviction(&run_id, "Pending activation present for missing run");
+                // Continue trying to return a valid pending activation
+                return self.next_pending_activation();
+            }
             self.cache_manager.lock().touch(&act.run_id);
         }
-        Ok(maybe_act)
+        maybe_act
     }
 
     pub fn next_buffered_poll(&self) -> Option<ValidPollWFTQResponse> {
@@ -192,13 +196,13 @@ impl WorkflowTaskManager {
     /// the lang side. Workflow will not *actually* be evicted until lang replies to that activation
     ///
     /// Returns, if found, the number of attempts on the current workflow task
-    pub fn request_eviction(&self, run_id: &str) -> Option<u32> {
+    pub fn request_eviction(&self, run_id: &str, reason: impl Into<String>) -> Option<u32> {
         if self.workflow_machines.exists(run_id) {
             if !self.activation_has_eviction(run_id) {
                 debug!(%run_id, "Eviction requested");
                 // Queue up an eviction activation
                 self.pending_activations
-                    .push(create_evict_activation(run_id.to_string()));
+                    .push(create_evict_activation(run_id.to_string(), reason.into()));
                 let _ = self.pending_activations_notifier.send(true);
             }
             self.workflow_machines
@@ -241,12 +245,12 @@ impl WorkflowTaskManager {
         &self,
         work: ValidPollWFTQResponse,
         gateway: &GatewayRef,
-    ) -> Result<NewWfTaskOutcome, WorkflowUpdateError> {
+    ) -> NewWfTaskOutcome {
         let mut work = if let Some(w) = self.workflow_machines.buffer_resp_if_outstanding_work(work)
         {
             w
         } else {
-            return Ok(NewWfTaskOutcome::TaskBuffered);
+            return NewWfTaskOutcome::TaskBuffered;
         };
 
         debug!(
@@ -269,9 +273,9 @@ impl WorkflowTaskManager {
                 Ok((info, next_activation)) => (info, next_activation),
                 Err(e) => {
                     if let WFMachinesError::CacheMiss = e.source {
-                        return Ok(NewWfTaskOutcome::CacheMiss);
+                        return NewWfTaskOutcome::CacheMiss;
                     }
-                    return Err(e);
+                    return NewWfTaskOutcome::Evict(e);
                 }
             };
 
@@ -288,20 +292,24 @@ impl WorkflowTaskManager {
             legacy_query
         };
 
-        self.workflow_machines.insert_wft(
-            &next_activation.run_id,
-            OutstandingTask {
-                info,
-                legacy_query,
-                start_time: task_start_time,
-            },
-        )?;
-
-        if !next_activation.jobs.is_empty() {
-            self.insert_outstanding_activation(&next_activation)?;
-            Ok(NewWfTaskOutcome::IssueActivation(next_activation))
+        self.workflow_machines
+            .insert_wft(
+                &next_activation.run_id,
+                OutstandingTask {
+                    info,
+                    legacy_query,
+                    start_time: task_start_time,
+                },
+            )
+            .expect("Workflow machines must exist, we just created/updated them");
+
+        if next_activation.jobs.is_empty() {
+            NewWfTaskOutcome::Autocomplete
         } else {
-            Ok(NewWfTaskOutcome::Autocomplete)
+            if let Err(wme) = self.insert_outstanding_activation(&next_activation) {
+                return NewWfTaskOutcome::Evict(wme.into());
+            }
+            NewWfTaskOutcome::IssueActivation(next_activation)
         }
     }
 
@@ -398,7 +406,9 @@ impl WorkflowTaskManager {
                         query_responses,
                     },
                 })
-            } else if !query_responses.is_empty() {
+            } else if query_responses.is_empty() {
+                None
+            } else {
                 Some(ServerCommandsWithWorkflowInfo {
                     task_token,
                     action: ActivationAction::WftComplete {
@@ -406,8 +416,6 @@ impl WorkflowTaskManager {
                         query_responses,
                     },
                 })
-            } else {
-                None
             }
         };
         Ok(ret)
@@ -439,12 +447,9 @@ impl WorkflowTaskManager {
             FailedActivationOutcome::ReportLegacyQueryFailure(tt)
         } else {
             // Blow up any cached data associated with the workflow
-            let should_report = if let Some(attempt) = self.request_eviction(run_id) {
-                // Only report to server if the last task wasn't also a failure (avoid spam)
-                attempt <= 1
-            } else {
-                true
-            };
+            let should_report = self
+                .request_eviction(run_id, "Activation failed by lang")
+                .map_or(true, |attempt| attempt <= 1);
             if should_report {
                 FailedActivationOutcome::Report(tt)
             } else {
@@ -516,7 +521,7 @@ impl WorkflowTaskManager {
     /// if this is called too early.
     ///
     /// Returns true if WFT is complete
-    pub(crate) fn after_wft_report(&self, run_id: &str) -> Result<bool, WorkflowUpdateError> {
+    pub(crate) fn after_wft_report(&self, run_id: &str) -> bool {
         let mut just_evicted = false;
 
         if let Some(OutstandingActivation::Normal {
@@ -532,19 +537,23 @@ impl WorkflowTaskManager {
             if !just_evicted {
                 // Check if there was a legacy query which must be fulfilled, and if there is create
                 // a new pending activation for it.
-                if let Some(ref mut ot) = self.workflow_machines.get_task_mut(run_id)?.deref_mut() {
+                if let Some(ref mut ot) = &mut *self
+                    .workflow_machines
+                    .get_task_mut(run_id)
+                    .expect("Machine must exist")
+                {
                     if let Some(query) = ot.legacy_query.take() {
                         let na = create_query_activation(run_id.to_string(), [query]);
                         self.pending_activations.push(na);
                         let _ = self.pending_activations_notifier.send(true);
-                        return Ok(false);
+                        return false;
                     }
                 }
 
                 // Evict run id if cache is full. Non-sticky will always evict.
                 let maybe_evicted = self.cache_manager.lock().insert(run_id);
                 if let Some(evicted_run_id) = maybe_evicted {
-                    self.request_eviction(&evicted_run_id);
+                    self.request_eviction(&evicted_run_id, "Workflow cache full");
                 }
 
                 // If there was a buffered poll response from the server, it is now ready to
@@ -556,9 +565,9 @@ impl WorkflowTaskManager {
 
             // The evict may or may not have already done this, but even when we aren't evicting
             // we want to clear the outstanding workflow task since it's now complete.
-            return Ok(self.workflow_machines.complete_wft(run_id).is_some());
+            return self.workflow_machines.complete_wft(run_id).is_some();
         }
-        Ok(false)
+        false
     }
 
     /// Must be called after *every* activation is replied to, regardless of whether or not we
@@ -577,7 +586,10 @@ impl WorkflowTaskManager {
         self.ready_buffered_wft.push(buffd);
     }
 
-    fn insert_outstanding_activation(&self, act: &WfActivation) -> Result<(), WorkflowUpdateError> {
+    fn insert_outstanding_activation(
+        &self,
+        act: &WfActivation,
+    ) -> Result<(), WorkflowMissingError> {
         let act_type = if act.is_legacy_query() {
             OutstandingActivation::LegacyQuery
         } else {
@@ -585,25 +597,28 @@ impl WorkflowTaskManager {
                 contains_eviction: act.eviction_index().is_some(),
             }
         };
-        let previous = self
+        match self
             .workflow_machines
-            .insert_activation(&act.run_id, act_type)?;
-        if let Some(previous) = previous {
-            // This isn't a panic because we have screwed up core logic if this is violated. It
-            // must be upheld.
-            panic!(
-                "Attempted to insert a new outstanding activation {}, but there already was one \
-                 outstanding: {:?}",
-                act, previous
-            );
+            .insert_activation(&act.run_id, act_type)
+        {
+            Ok(None) => Ok(()),
+            Ok(Some(previous)) => {
+                // This is a panic because we have screwed up core logic if this is violated. It
+                // must be upheld.
+                panic!(
+                    "Attempted to insert a new outstanding activation {}, but there already was \
+                     one outstanding: {:?}",
+                    act, previous
+                );
+            }
+            Err(e) => Err(e),
         }
-        Ok(())
     }
 
     fn activation_has_eviction(&self, run_id: &str) -> bool {
         self.workflow_machines
             .get_activation(run_id)
-            .map(|oa| oa.has_eviction())
+            .map(OutstandingActivation::has_eviction)
             .unwrap_or_default()
     }
 }

package/sdk-core/test_utils/Cargo.toml

@@ -2,7 +2,7 @@
 name = "test_utils"
 version = "0.1.0"
 authors = ["Spencer Judge <spencer@temporal.io>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

package/sdk-core/test_utils/src/lib.rs

@@ -46,7 +46,7 @@ impl CoreWfStarter {
                 .unwrap(),
             worker_config: WorkerConfigBuilder::default()
                 .task_queue(task_queue)
-                .max_cached_workflows(1000usize)
+                .max_cached_workflows(1000_usize)
                 .build()
                 .unwrap(),
             wft_timeout: None,
@@ -63,7 +63,7 @@ impl CoreWfStarter {
     }
 
     pub async fn shutdown(&mut self) {
-        self.get_core().await.shutdown().await
+        self.get_core().await.shutdown().await;
     }
 
     pub async fn get_core(&mut self) -> Arc<dyn Core> {

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

@@ -8,7 +8,7 @@ use temporal_sdk_core_protos::{
         workflow_activation::{wf_activation_job, FireTimer, ResolveActivity, WfActivationJob},
         workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
         workflow_completion::WfActivationCompletion,
-        ActivityTaskCompletion, IntoCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
     },
     temporal::api::{
         common::v1::{ActivityType, Payloads},
@@ -647,3 +647,63 @@ async fn async_activity_completion_workflow() {
     );
     core.complete_execution(&task_q, &task.run_id).await;
 }
+
+#[tokio::test]
+async fn activity_cancelled_after_heartbeat_times_out() {
+    let test_name = "activity_cancelled_after_heartbeat_times_out";
+    let (core, task_q) = init_core_and_create_wf(test_name).await;
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    // Complete workflow task and schedule activity
+    core.complete_workflow_activation(
+        schedule_activity_cmd(
+            0,
+            &task_q,
+            activity_id,
+            ActivityCancellationType::WaitCancellationCompleted,
+            Duration::from_secs(60),
+            Duration::from_secs(1),
+        )
+        .into_completion(task_q.clone(), task.run_id),
+    )
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled with correct parameters
+    let task = core.poll_activity_task(&task_q).await.unwrap();
+    assert_matches!(
+        task.variant,
+        Some(act_task::Variant::Start(start_activity)) => {
+            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+        }
+    );
+    // Delay the heartbeat
+    sleep(Duration::from_secs(2)).await;
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: task.task_token.clone(),
+        task_queue: task_q.to_string(),
+        details: vec![],
+    });
+
+    // Verify activity got cancelled
+    let cancel_task = core.poll_activity_task(&task_q).await.unwrap();
+    assert_eq!(cancel_task.task_token, task.task_token.clone());
+    assert_matches!(cancel_task.variant, Some(act_task::Variant::Cancel(_)));
+
+    // Complete activity with cancelled result
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: task.task_token.clone(),
+        task_queue: task_q.to_string(),
+        result: Some(ActivityResult::cancel_from_details(None)),
+    })
+    .await
+    .unwrap();
+
+    // Verify shutdown completes
+    core.shutdown_worker(task_q.as_str()).await;
+    core.shutdown().await;
+    // Cleanup just in case
+    core.server_gateway()
+        .terminate_workflow_execution(test_name.to_string(), None)
+        .await
+        .unwrap();
+}

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

@@ -20,9 +20,9 @@ async fn parent_wf(mut ctx: WfContext) -> WorkflowResult<()> {
     let started = child
         .start(&mut ctx)
         .await
-        .as_started()
+        .into_started()
         .expect("Child chould start OK");
-    match started.result(&mut ctx).await.status {
+    match started.result().await.status {
         Some(child_workflow_result::Status::Completed(Success { .. })) => Ok(().into()),
         _ => Err(anyhow!("Unexpected child WF status")),
     }

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

@@ -0,0 +1,49 @@
+use std::{
+    sync::atomic::{AtomicUsize, Ordering},
+    time::Duration,
+};
+use temporal_sdk_core::prototype_rust_sdk::{ActivityOptions, WfContext, WorkflowResult};
+use test_utils::CoreWfStarter;
+
+static RUN_CT: AtomicUsize = AtomicUsize::new(1);
+pub async fn timer_wf_nondeterministic(mut ctx: WfContext) -> WorkflowResult<()> {
+    let run_ct = RUN_CT.fetch_add(1, Ordering::Relaxed);
+
+    match run_ct {
+        1 | 3 => {
+            // If we have not run yet or are on the third attempt, schedule a timer
+            ctx.timer(Duration::from_secs(1)).await;
+            if run_ct == 1 {
+                // on first attempt we need to blow up after the timer fires so we will replay
+                panic!("dying on purpose");
+            }
+        }
+        2 => {
+            // On the second attempt we should cause a nondeterminism error
+            ctx.activity(ActivityOptions {
+                activity_type: "whatever".to_string(),
+                ..Default::default()
+            })
+            .await;
+        }
+        _ => panic!("Ran too many times"),
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn test_determinism_error_then_recovers() {
+    let wf_name = "test_determinism_error_then_recovers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
+    worker
+        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    starter.shutdown().await;
+    // 4 because we still add on the 3rd and final attempt
+    assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);
+}

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

@@ -78,13 +78,13 @@ async fn signals_child(mut ctx: WfContext) -> WorkflowResult<()> {
         })
         .start(&mut ctx)
         .await
-        .as_started()
+        .into_started()
         .expect("Must start ok");
     started_child
         .signal(&mut ctx, SIGNAME, b"hiya!")
         .await
         .unwrap();
-    started_child.result(&mut ctx).await.status.unwrap();
+    started_child.result().await.status.unwrap();
     Ok(().into())
 }
 

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

@@ -3,6 +3,7 @@ mod cancel_external;
 mod cancel_wf;
 mod child_workflows;
 mod continue_as_new;
+mod determinism;
 mod patches;
 mod signals;
 mod stickyness;