@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/{src/prototype_rust_sdk → sdk/src}/workflow_future.rs

@@ -1,9 +1,6 @@
 use crate::{
-    prototype_rust_sdk::{
-        conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID,
-        RustWfCmd, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
-    },
-    workflow::CommandID,
+    conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID, RustWfCmd,
+    TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -21,20 +18,22 @@ use temporal_sdk_core_protos::{
     coresdk::{
         common::Payload,
         workflow_activation::{
-            wf_activation_job::Variant, FireTimer, NotifyHasPatch, ResolveActivity,
-            ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, WfActivation,
-            WfActivationJob,
+            workflow_activation_job::Variant, FireTimer, NotifyHasPatch, ResolveActivity,
+            ResolveChildWorkflowExecution, ResolveChildWorkflowExecutionStart, WorkflowActivation,
+            WorkflowActivationJob,
         },
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we, workflow_command,
             CancelSignalWorkflow, CancelTimer, CancelUnstartedChildWorkflowExecution,
             CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
-            RequestCancelActivity, RequestCancelExternalWorkflowExecution, ScheduleActivity,
+            RequestCancelActivity, RequestCancelExternalWorkflowExecution,
+            RequestCancelLocalActivity, ScheduleActivity, ScheduleLocalActivity,
             StartChildWorkflowExecution, StartTimer,
         },
-        workflow_completion::WfActivationCompletion,
+        workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::failure::v1::Failure,
+    utilities::TryIntoOrNone,
 };
 use tokio::sync::{
     mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
@@ -42,18 +41,22 @@ use tokio::sync::{
 };
 
 impl WorkflowFunction {
-    pub(crate) fn start_workflow(
+    /// Start a workflow function, returning a future that will resolve when the workflow does,
+    /// and a channel that can be used to send it activations.
+    #[doc(hidden)]
+    pub fn start_workflow(
         &self,
         namespace: String,
         task_queue: String,
         args: Vec<Payload>,
-        outgoing_completions: UnboundedSender<WfActivationCompletion>,
+        outgoing_completions: UnboundedSender<WorkflowActivationCompletion>,
     ) -> (
         impl Future<Output = WorkflowResult<()>>,
-        UnboundedSender<WfActivation>,
+        UnboundedSender<WorkflowActivation>,
     ) {
         let (cancel_tx, cancel_rx) = watch::channel(false);
-        let (wf_context, cmd_receiver) = WfContext::new(namespace, args, cancel_rx);
+        let (wf_context, cmd_receiver) =
+            WfContext::new(namespace, task_queue.clone(), args, cancel_rx);
         let (tx, incoming_activations) = unbounded_channel();
         (
             WorkflowFuture {
@@ -97,9 +100,9 @@ pub struct WorkflowFuture {
     /// Commands produced inside user's wf code
     incoming_commands: Receiver<RustWfCmd>,
     /// Once blocked or the workflow has finished or errored out, the result is sent here
-    outgoing_completions: UnboundedSender<WfActivationCompletion>,
+    outgoing_completions: UnboundedSender<WorkflowActivationCompletion>,
     /// Activations from core
-    incoming_activations: UnboundedReceiver<WfActivation>,
+    incoming_activations: UnboundedReceiver<WorkflowActivation>,
     /// Commands by ID -> blocked status
     command_status: HashMap<CommandID, WFCommandFutInfo>,
     /// Use to notify workflow code of cancellation
@@ -115,7 +118,7 @@ pub struct WorkflowFuture {
 impl WorkflowFuture {
     fn unblock(&mut self, event: UnblockEvent) -> Result<(), Error> {
         let cmd_id = match event {
-            UnblockEvent::Timer(seq) => CommandID::Timer(seq),
+            UnblockEvent::Timer(seq, _) => CommandID::Timer(seq),
             UnblockEvent::Activity(seq, _) => CommandID::Activity(seq),
             UnblockEvent::WorkflowStart(seq, _) => CommandID::ChildWorkflowStart(seq),
             UnblockEvent::WorkflowComplete(seq, _) => CommandID::ChildWorkflowComplete(seq),
@@ -134,7 +137,7 @@ impl WorkflowFuture {
     fn fail_wft(&self, run_id: String, fail: Error) {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
-            .send(WfActivationCompletion::fail(
+            .send(WorkflowActivationCompletion::fail(
                 &self.task_queue,
                 run_id,
                 anyhow_to_fail(fail),
@@ -144,7 +147,7 @@ impl WorkflowFuture {
 
     fn send_completion(&self, run_id: String, activation_cmds: Vec<workflow_command::Variant>) {
         self.outgoing_completions
-            .send(WfActivationCompletion::from_cmds(
+            .send(WorkflowActivationCompletion::from_cmds(
                 &self.task_queue,
                 run_id,
                 activation_cmds,
@@ -164,7 +167,9 @@ impl WorkflowFuture {
                 Variant::StartWorkflow(_) => {
                     // TODO: Can assign randomness seed whenever needed
                 }
-                Variant::FireTimer(FireTimer { seq }) => self.unblock(UnblockEvent::Timer(seq))?,
+                Variant::FireTimer(FireTimer { seq }) => {
+                    self.unblock(UnblockEvent::Timer(seq, TimerResult::Fired))?
+                }
                 Variant::ResolveActivity(ResolveActivity { seq, result }) => {
                     self.unblock(UnblockEvent::Activity(
                         seq,
@@ -240,10 +245,14 @@ impl Future for WorkflowFuture {
 
             let is_only_eviction = activation.is_only_eviction();
             let run_id = activation.run_id;
-            self.ctx_shared.write().is_replaying = activation.is_replaying;
+            {
+                let mut wlock = self.ctx_shared.write();
+                wlock.is_replaying = activation.is_replaying;
+                wlock.wf_time = activation.timestamp.try_into_or_none();
+            }
 
             let mut die_of_eviction_when_done = false;
-            for WfActivationJob { variant } in activation.jobs {
+            for WorkflowActivationJob { variant } in activation.jobs {
                 match self.handle_job(variant) {
                     Ok(true) => {
                         die_of_eviction_when_done = true;
@@ -259,7 +268,7 @@ impl Future for WorkflowFuture {
             if is_only_eviction {
                 // No need to do anything with the workflow code in this case
                 self.outgoing_completions
-                    .send(WfActivationCompletion::from_cmds(
+                    .send(WorkflowActivationCompletion::from_cmds(
                         &self.task_queue,
                         run_id,
                         vec![],
@@ -274,12 +283,18 @@ impl Future for WorkflowFuture {
                 .poll_unpin(cx)
             {
                 Poll::Ready(Err(e)) => {
+                    let errmsg = format!(
+                        "Workflow function panicked: {:?}",
+                        // Panics are typically strings
+                        e.downcast::<String>()
+                    );
+                    warn!("{}", errmsg);
                     self.outgoing_completions
-                        .send(WfActivationCompletion::fail(
+                        .send(WorkflowActivationCompletion::fail(
                             &self.task_queue,
                             run_id,
                             Failure {
-                                message: format!("Workflow function panicked: {:?}", e),
+                                message: errmsg,
                                 ..Default::default()
                             },
                         ))
@@ -300,9 +315,7 @@ impl Future for WorkflowFuture {
                                 activation_cmds.push(workflow_command::Variant::CancelTimer(
                                     CancelTimer { seq },
                                 ));
-                                // TODO: cancelled timer should not simply be unblocked, in the
-                                //   other SDKs this returns an error
-                                self.unblock(UnblockEvent::Timer(seq))?;
+                                self.unblock(UnblockEvent::Timer(seq, TimerResult::Cancelled))?;
                                 // Re-poll wf future since a timer is now unblocked
                                 res = self.inner.poll_unpin(cx);
                             }
@@ -313,6 +326,13 @@ impl Future for WorkflowFuture {
                                     ),
                                 );
                             }
+                            CancellableID::LocalActivity(seq) => {
+                                activation_cmds.push(
+                                    workflow_command::Variant::RequestCancelLocalActivity(
+                                        RequestCancelLocalActivity { seq },
+                                    ),
+                                );
+                            }
                             CancellableID::ChildWorkflow(seq) => {
                                 activation_cmds.push(
                                     workflow_command::Variant::CancelUnstartedChildWorkflowExecution(
@@ -359,7 +379,10 @@ impl Future for WorkflowFuture {
                             workflow_command::Variant::ScheduleActivity(ScheduleActivity {
                                 seq,
                                 ..
-                            }) => CommandID::Activity(seq),
+                            })
+                            | workflow_command::Variant::ScheduleLocalActivity(
+                                ScheduleLocalActivity { seq, .. },
+                            ) => CommandID::Activity(seq),
                             workflow_command::Variant::SetPatchMarker(_) => {
                                 panic!("Set patch marker should be a nonblocking command")
                             }
@@ -427,7 +450,7 @@ impl Future for WorkflowFuture {
                                 ),
                             );
                         }
-                        WfExitValue::ContinueAsNew(cmd) => activation_cmds.push(cmd.into()),
+                        WfExitValue::ContinueAsNew(cmd) => activation_cmds.push((*cmd).into()),
                         WfExitValue::Cancelled => {
                             activation_cmds.push(
                                 workflow_command::Variant::CancelWorkflowExecution(
@@ -469,3 +492,13 @@ impl Future for WorkflowFuture {
         }
     }
 }
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum CommandID {
+    Timer(u32),
+    Activity(u32),
+    ChildWorkflowStart(u32),
+    ChildWorkflowComplete(u32),
+    SignalExternal(u32),
+    CancelExternal(u32),
+}

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -10,11 +10,21 @@ repository = "https://github.com/temporalio/sdk-core"
 keywords = ["temporal", "workflow"]
 categories = ["development-tools"]
 
+[features]
+history_builders = ["uuid", "rand"]
+
 [dependencies]
+anyhow = "1.0"
+base64 = "0.13"
 derive_more = "0.99"
 prost = "0.9"
 prost-types = "0.9"
+rand = { version = "0.8", optional = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "1.0"
 tonic = "0.6"
+uuid = { version = "0.8.2", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = "0.5"

package/sdk-core/sdk-core-protos/build.rs

@@ -39,26 +39,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         )
         .type_attribute(
             "coresdk.workflow_commands.WorkflowCommand.variant",
-            "#[derive(::derive_more::From)]",
+            "#[derive(::derive_more::From, ::derive_more::Display)]",
         )
         .type_attribute(
             "coresdk.workflow_commands.QueryResult.variant",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute(
-            "coresdk.workflow_activation.wf_activation_job",
+            "coresdk.workflow_activation.workflow_activation_job",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute(
-            "coresdk.workflow_activation.WFActivationJob.variant",
+            "coresdk.workflow_activation.WorkflowActivationJob.variant",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute(
-            "coresdk.workflow_completion.WFActivationCompletion.status",
+            "coresdk.workflow_completion.WorkflowActivationCompletion.status",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute(
-            "coresdk.activity_result.ActivityResult.status",
+            "coresdk.activity_result.ActivityExecutionResult.status",
+            "#[derive(::derive_more::From)]",
+        )
+        .type_attribute(
+            "coresdk.activity_result.ActivityResolution.status",
             "#[derive(::derive_more::From)]",
         )
         .type_attribute(
@@ -66,9 +70,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "#[derive(::derive_more::Display)]",
         )
         .type_attribute("coresdk.Task.variant", "#[derive(::derive_more::From)]")
+        // All external data is useful to be able to JSON serialize, so it can render in web UI
+        .type_attribute(
+            ".coresdk.external_data",
+            "#[derive(::serde::Serialize, ::serde::Deserialize)]",
+        )
+        .field_attribute(
+            "coresdk.external_data.LocalActivityMarkerData.complete_time",
+            "#[serde(with = \"opt_timestamp\")]",
+        )
+        .field_attribute(
+            "coresdk.external_data.LocalActivityMarkerData.original_schedule_time",
+            "#[serde(with = \"opt_timestamp\")]",
+        )
+        .field_attribute(
+            "coresdk.external_data.LocalActivityMarkerData.backoff",
+            "#[serde(with = \"opt_duration\")]",
+        )
         .compile(
             &[
-                "../protos/local/core_interface.proto",
+                "../protos/local/temporal/sdk/core/core_interface.proto",
+                "../protos/local/temporal/sdk/core/bridge/bridge.proto",
                 "../protos/api_upstream/temporal/api/workflowservice/v1/service.proto",
             ],
             &["../protos/api_upstream", "../protos/local"],

package/sdk-core/sdk-core-protos/src/constants.rs

@@ -0,0 +1,7 @@
+//! Contains various constants that are used by core when storing/serializing data
+
+/// Used as `marker_name` field when recording patch markers
+pub const PATCH_MARKER_NAME: &str = "core_patch";
+
+/// Used as `marker_name` field when recording local activity markers
+pub const LOCAL_ACTIVITY_MARKER_NAME: &str = "core_local_activity";

package/sdk-core/{src/test_help → sdk-core-protos/src}/history_builder.rs

@@ -1,27 +1,30 @@
 use crate::{
-    machines::HAS_CHANGE_MARKER_NAME,
-    test_help::{
-        history_info::{HistoryInfo, HistoryInfoError},
-        Result,
+    constants::{LOCAL_ACTIVITY_MARKER_NAME, PATCH_MARKER_NAME},
+    coresdk::{
+        common::{
+            build_has_change_marker_details, build_local_activity_marker_details,
+            NamespacedWorkflowExecution, Payload as CorePayload,
+        },
+        external_data::LocalActivityMarkerData,
+        IntoPayloadsExt,
     },
-    workflow::HistoryUpdate,
-};
-use anyhow::bail;
-use std::time::SystemTime;
-use temporal_sdk_core_protos::{
-    coresdk::common::{
-        build_has_change_marker_details, NamespacedWorkflowExecution, Payload as CorePayload,
-    },
-    coresdk::IntoPayloadsExt,
     temporal::api::{
         common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{EventType, WorkflowTaskFailedCause},
-        failure::v1::Failure,
+        failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
     },
+    HistoryInfo,
 };
+use anyhow::bail;
+use prost_types::Timestamp;
+use std::time::{Duration, SystemTime};
 use uuid::Uuid;
 
+pub static DEFAULT_WORKFLOW_TYPE: &str = "default_wf_type";
+
+type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
+
 #[derive(Default, Clone, Debug)]
 pub struct TestHistoryBuilder {
     events: Vec<HistoryEvent>,
@@ -30,7 +33,6 @@ pub struct TestHistoryBuilder {
     current_event_id: i64,
     workflow_task_scheduled_event_id: i64,
     final_workflow_task_started_event_id: i64,
-    previous_started_event_id: i64,
     previous_task_completed_id: i64,
     original_run_id: String,
 }
@@ -76,8 +78,6 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_workflow_task_scheduled(&mut self) {
-        // WFStarted always immediately follows WFScheduled
-        self.previous_started_event_id = self.workflow_task_scheduled_event_id + 1;
         self.workflow_task_scheduled_event_id =
             self.add_get_event_id(EventType::WorkflowTaskScheduled, None);
     }
@@ -100,7 +100,7 @@ impl TestHistoryBuilder {
         self.previous_task_completed_id = id;
     }
 
-    pub(crate) fn add_workflow_task_timed_out(&mut self) {
+    pub fn add_workflow_task_timed_out(&mut self) {
         let attrs = WorkflowTaskTimedOutEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
             ..Default::default()
@@ -221,6 +221,16 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::WorkflowTaskFailed, attrs.into());
     }
 
+    pub fn add_timer_fired(&mut self, timer_started_evt_id: i64, timer_id: String) {
+        self.add(
+            EventType::TimerFired,
+            history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
+                started_event_id: timer_started_evt_id,
+                timer_id,
+            }),
+        );
+    }
+
     pub fn add_we_signaled(&mut self, signal_name: &str, payloads: Vec<Payload>) {
         let attrs = WorkflowExecutionSignaledEventAttributes {
             signal_name: signal_name.to_string(),
@@ -230,9 +240,9 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::WorkflowExecutionSignaled, attrs.into());
     }
 
-    pub(crate) fn add_has_change_marker(&mut self, patch_id: &str, deprecated: bool) {
+    pub fn add_has_change_marker(&mut self, patch_id: &str, deprecated: bool) {
         let attrs = MarkerRecordedEventAttributes {
-            marker_name: HAS_CHANGE_MARKER_NAME.to_string(),
+            marker_name: PATCH_MARKER_NAME.to_string(),
             details: build_has_change_marker_details(patch_id, deprecated),
             workflow_task_completed_event_id: self.previous_task_completed_id,
             ..Default::default()
@@ -240,7 +250,82 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::MarkerRecorded, attrs.into());
     }
 
-    pub(crate) fn add_signal_wf(
+    fn add_local_activity_marker(
+        &mut self,
+        seq: u32,
+        activity_id: &str,
+        payload: Option<CorePayload>,
+        failure: Option<Failure>,
+        complete_time: Option<Timestamp>,
+    ) {
+        let attrs = MarkerRecordedEventAttributes {
+            marker_name: LOCAL_ACTIVITY_MARKER_NAME.to_string(),
+            details: build_local_activity_marker_details(
+                LocalActivityMarkerData {
+                    seq,
+                    attempt: 1,
+                    activity_id: activity_id.to_string(),
+                    activity_type: "some_act_type".to_string(),
+                    complete_time,
+                    backoff: None,
+                    original_schedule_time: None,
+                },
+                payload,
+            ),
+            workflow_task_completed_event_id: self.previous_task_completed_id,
+            failure,
+            ..Default::default()
+        };
+        self.build_and_push_event(EventType::MarkerRecorded, attrs.into());
+    }
+
+    pub fn add_local_activity_result_marker(
+        &mut self,
+        seq: u32,
+        activity_id: &str,
+        payload: CorePayload,
+    ) {
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, None);
+    }
+
+    pub fn add_local_activity_result_marker_with_time(
+        &mut self,
+        seq: u32,
+        activity_id: &str,
+        payload: CorePayload,
+        complete_time: Timestamp,
+    ) {
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, Some(complete_time));
+    }
+
+    pub fn add_local_activity_fail_marker(
+        &mut self,
+        seq: u32,
+        activity_id: &str,
+        failure: Failure,
+    ) {
+        self.add_local_activity_marker(seq, activity_id, None, Some(failure), None);
+    }
+
+    pub fn add_local_activity_cancel_marker(&mut self, seq: u32, activity_id: &str) {
+        self.add_local_activity_marker(
+            seq,
+            activity_id,
+            None,
+            Some(Failure {
+                message: "cancelled bro".to_string(),
+                source: "".to_string(),
+                stack_trace: "".to_string(),
+                cause: None,
+                failure_info: Some(failure::FailureInfo::CanceledFailureInfo(
+                    CanceledFailureInfo { details: None },
+                )),
+            }),
+            None,
+        );
+    }
+
+    pub fn add_signal_wf(
         &mut self,
         signal_name: impl Into<String>,
         workflow_id: impl Into<String>,
@@ -262,7 +347,7 @@ impl TestHistoryBuilder {
         )
     }
 
-    pub(crate) fn add_external_signal_completed(&mut self, initiated_id: i64) {
+    pub fn add_external_signal_completed(&mut self, initiated_id: i64) {
         let attrs = ExternalWorkflowExecutionSignaledEventAttributes {
             initiated_event_id: initiated_id,
             ..Default::default()
@@ -270,7 +355,7 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::ExternalWorkflowExecutionSignaled, attrs.into());
     }
 
-    pub(crate) fn add_external_signal_failed(&mut self, initiated_id: i64) {
+    pub fn add_external_signal_failed(&mut self, initiated_id: i64) {
         let attrs = SignalExternalWorkflowExecutionFailedEventAttributes {
             initiated_event_id: initiated_id,
             ..Default::default()
@@ -281,7 +366,7 @@ impl TestHistoryBuilder {
         );
     }
 
-    pub(crate) fn add_cancel_external_wf(&mut self, execution: NamespacedWorkflowExecution) -> i64 {
+    pub fn add_cancel_external_wf(&mut self, execution: NamespacedWorkflowExecution) -> i64 {
         let attrs = RequestCancelExternalWorkflowExecutionInitiatedEventAttributes {
             workflow_task_completed_event_id: self.previous_task_completed_id,
             namespace: execution.namespace,
@@ -297,7 +382,7 @@ impl TestHistoryBuilder {
         )
     }
 
-    pub(crate) fn add_cancel_external_wf_completed(&mut self, initiated_id: i64) {
+    pub fn add_cancel_external_wf_completed(&mut self, initiated_id: i64) {
         let attrs = ExternalWorkflowExecutionCancelRequestedEventAttributes {
             initiated_event_id: initiated_id,
             ..Default::default()
@@ -308,7 +393,7 @@ impl TestHistoryBuilder {
         );
     }
 
-    pub(crate) fn add_cancel_external_wf_failed(&mut self, initiated_id: i64) {
+    pub fn add_cancel_external_wf_failed(&mut self, initiated_id: i64) {
         let attrs = RequestCancelExternalWorkflowExecutionFailedEventAttributes {
             initiated_event_id: initiated_id,
             ..Default::default()
@@ -319,39 +404,37 @@ impl TestHistoryBuilder {
         );
     }
 
-    pub(crate) fn as_history_update(&self) -> HistoryUpdate {
-        self.get_full_history_info().unwrap().into()
-    }
-
     pub fn get_orig_run_id(&self) -> &str {
         &self.original_run_id
     }
 
     /// Iterates over the events in this builder to return a [HistoryInfo] including events up to
     /// the provided `to_wf_task_num`
-    pub(crate) fn get_history_info(
-        &self,
-        to_wf_task_num: usize,
-    ) -> Result<HistoryInfo, HistoryInfoError> {
+    pub fn get_history_info(&self, to_wf_task_num: usize) -> Result<HistoryInfo, anyhow::Error> {
         HistoryInfo::new_from_history(&self.events.clone().into(), Some(to_wf_task_num))
     }
 
     /// Iterates over the events in this builder to return a [HistoryInfo] representing *all*
     /// events in the history
-    pub(crate) fn get_full_history_info(&self) -> Result<HistoryInfo, HistoryInfoError> {
+    pub fn get_full_history_info(&self) -> Result<HistoryInfo, anyhow::Error> {
         HistoryInfo::new_from_history(&self.events.clone().into(), None)
     }
 
-    pub(crate) fn get_one_wft(
-        &self,
-        from_wft_number: usize,
-    ) -> Result<HistoryInfo, HistoryInfoError> {
+    pub fn get_one_wft(&self, from_wft_number: usize) -> Result<HistoryInfo, anyhow::Error> {
         let mut histinfo =
             HistoryInfo::new_from_history(&self.events.clone().into(), Some(from_wft_number))?;
         histinfo.make_incremental();
         Ok(histinfo)
     }
 
+    /// Return most recent wft start time or panic if unset
+    pub fn wft_start_time(&self) -> prost_types::Timestamp {
+        self.events[(self.workflow_task_scheduled_event_id + 1) as usize]
+            .event_time
+            .clone()
+            .unwrap()
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -374,20 +457,22 @@ impl TestHistoryBuilder {
     }
 }
 
-pub static DEFAULT_WORKFLOW_TYPE: &str = "not_specified";
-
 fn default_attribs(et: EventType) -> Result<Attributes> {
     Ok(match et {
-        EventType::WorkflowExecutionStarted => WorkflowExecutionStartedEventAttributes {
-            original_execution_run_id: Uuid::new_v4().to_string(),
-            workflow_type: Some(WorkflowType {
-                name: DEFAULT_WORKFLOW_TYPE.to_owned(),
-            }),
-            ..Default::default()
-        }
-        .into(),
+        EventType::WorkflowExecutionStarted => default_wes_attribs().into(),
         EventType::WorkflowTaskScheduled => WorkflowTaskScheduledEventAttributes::default().into(),
         EventType::TimerStarted => TimerStartedEventAttributes::default().into(),
         _ => bail!("Don't know how to construct default attrs for {:?}", et),
     })
 }
+
+pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
+    WorkflowExecutionStartedEventAttributes {
+        original_execution_run_id: Uuid::new_v4().to_string(),
+        workflow_type: Some(WorkflowType {
+            name: DEFAULT_WORKFLOW_TYPE.to_owned(),
+        }),
+        workflow_task_timeout: Some(Duration::from_secs(5).into()),
+        ..Default::default()
+    }
+}