@temporalio/core-bridge 1.5.2 → 1.7.0

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

@@ -6,10 +6,13 @@ use crate::{
             NamespacedWorkflowExecution,
         },
         external_data::LocalActivityMarkerData,
-        IntoPayloadsExt,
+        workflow_commands::ScheduleActivity,
+        AsJsonPayloadExt, IntoPayloadsExt,
     },
     temporal::api::{
-        common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
+        common::v1::{
+            ActivityType, Payload, Payloads, SearchAttributes, WorkflowExecution, WorkflowType,
+        },
         enums::v1::{EventType, TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::{failure, CanceledFailureInfo, Failure},
         history::v1::{history_event::Attributes, *},
@@ -18,11 +21,15 @@ use crate::{
     HistoryInfo,
 };
 use anyhow::bail;
-use prost_types::Timestamp;
-use std::time::{Duration, SystemTime};
+use prost_wkt_types::Timestamp;
+use std::{
+    collections::HashMap,
+    time::{Duration, SystemTime},
+};
 use uuid::Uuid;
 
 pub static DEFAULT_WORKFLOW_TYPE: &str = "default_wf_type";
+pub static DEFAULT_ACTIVITY_TYPE: &str = "default_act_type";
 
 type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
 
@@ -61,26 +68,19 @@ impl TestHistoryBuilder {
     }
 
     /// Add an event by type with attributes. Bundles both into a [HistoryEvent] with an id that is
-    /// incremented on each call to add.
-    pub fn add(&mut self, event_type: EventType, attribs: Attributes) {
-        self.build_and_push_event(event_type, attribs);
+    /// incremented on each call to add. Returns the id of the new event.
+    pub fn add(&mut self, attribs: impl Into<Attributes>) -> i64 {
+        let attribs: Attributes = attribs.into();
+        self.build_and_push_event(attribs.event_type(), attribs);
+        self.current_event_id
     }
 
-    /// Adds an event to the history by type, with default attributes.
-    pub fn add_by_type(&mut self, event_type: EventType) {
+    /// Adds an event to the history by type, with default attributes. Returns the id of the new
+    /// event.
+    pub fn add_by_type(&mut self, event_type: EventType) -> i64 {
         let attribs =
             default_attribs(event_type).expect("Couldn't make default attributes in test builder");
-        self.build_and_push_event(event_type, attribs);
-    }
-
-    /// Adds an event, returning the ID that was assigned to it
-    pub fn add_get_event_id(&mut self, event_type: EventType, attrs: Option<Attributes>) -> i64 {
-        if let Some(a) = attrs {
-            self.build_and_push_event(event_type, a);
-        } else {
-            self.add_by_type(event_type);
-        }
-        self.current_event_id
+        self.add(attribs)
     }
 
     /// Adds the following events:
@@ -100,25 +100,21 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_workflow_task_scheduled(&mut self) {
-        self.workflow_task_scheduled_event_id =
-            self.add_get_event_id(EventType::WorkflowTaskScheduled, None);
+        self.workflow_task_scheduled_event_id = self.add_by_type(EventType::WorkflowTaskScheduled);
     }
 
     pub fn add_workflow_task_started(&mut self) {
-        let attrs = WorkflowTaskStartedEventAttributes {
+        self.final_workflow_task_started_event_id = self.add(WorkflowTaskStartedEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
             ..Default::default()
-        };
-        self.final_workflow_task_started_event_id =
-            self.add_get_event_id(EventType::WorkflowTaskStarted, Some(attrs.into()));
+        });
     }
 
     pub fn add_workflow_task_completed(&mut self) {
-        let attrs = WorkflowTaskCompletedEventAttributes {
+        let id = self.add(WorkflowTaskCompletedEventAttributes {
             scheduled_event_id: self.workflow_task_scheduled_event_id,
             ..Default::default()
-        };
-        let id = self.add_get_event_id(EventType::WorkflowTaskCompleted, Some(attrs.into()));
+        });
         self.previous_task_completed_id = id;
     }
 
@@ -176,30 +172,22 @@ impl TestHistoryBuilder {
     }
 
     pub fn add_activity_task_scheduled(&mut self, activity_id: impl Into<String>) -> i64 {
-        self.add_get_event_id(
-            EventType::ActivityTaskScheduled,
-            Some(
-                history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                    ActivityTaskScheduledEventAttributes {
-                        activity_id: activity_id.into(),
-                        ..Default::default()
-                    },
-                ),
-            ),
-        )
+        self.add(ActivityTaskScheduledEventAttributes {
+            activity_id: activity_id.into(),
+            activity_type: Some(ActivityType {
+                name: DEFAULT_ACTIVITY_TYPE.to_string(),
+            }),
+            ..Default::default()
+        })
     }
+
     pub fn add_activity_task_started(&mut self, scheduled_event_id: i64) -> i64 {
-        self.add_get_event_id(
-            EventType::ActivityTaskStarted,
-            Some(
-                history_event::Attributes::ActivityTaskStartedEventAttributes(
-                    ActivityTaskStartedEventAttributes {
-                        scheduled_event_id,
-                        ..Default::default()
-                    },
-                ),
-            ),
-        )
+        self.add(Attributes::ActivityTaskStartedEventAttributes(
+            ActivityTaskStartedEventAttributes {
+                scheduled_event_id,
+                ..Default::default()
+            },
+        ))
     }
 
     pub fn add_activity_task_completed(
@@ -208,17 +196,12 @@ impl TestHistoryBuilder {
         started_event_id: i64,
         payload: Payload,
     ) {
-        self.add(
-            EventType::ActivityTaskCompleted,
-            history_event::Attributes::ActivityTaskCompletedEventAttributes(
-                ActivityTaskCompletedEventAttributes {
-                    scheduled_event_id,
-                    started_event_id,
-                    result: vec![payload].into_payloads(),
-                    ..Default::default()
-                },
-            ),
-        );
+        self.add(ActivityTaskCompletedEventAttributes {
+            scheduled_event_id,
+            started_event_id,
+            result: vec![payload].into_payloads(),
+            ..Default::default()
+        });
     }
 
     pub fn add_activity_task_cancel_requested(&mut self, scheduled_event_id: i64) {
@@ -258,13 +241,10 @@ impl TestHistoryBuilder {
     }
 
     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,
-            }),
-        );
+        self.add(TimerFiredEventAttributes {
+            started_event_id: timer_started_evt_id,
+            timer_id,
+        });
     }
 
     pub fn add_we_signaled(&mut self, signal_name: &str, payloads: Vec<Payload>) {
@@ -279,7 +259,7 @@ impl TestHistoryBuilder {
     pub fn add_has_change_marker(&mut self, patch_id: &str, deprecated: bool) {
         let attrs = MarkerRecordedEventAttributes {
             marker_name: PATCH_MARKER_NAME.to_string(),
-            details: build_has_change_marker_details(patch_id, deprecated),
+            details: build_has_change_marker_details(patch_id, deprecated).unwrap(),
             workflow_task_completed_event_id: self.previous_task_completed_id,
             ..Default::default()
         };
@@ -292,22 +272,21 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Option<Payload>,
         failure: Option<Failure>,
-        complete_time: Option<Timestamp>,
+        detail_mutator: impl FnOnce(&mut LocalActivityMarkerData),
     ) {
+        let mut lamd = LocalActivityMarkerData {
+            seq,
+            attempt: 1,
+            activity_id: activity_id.to_string(),
+            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+            complete_time: None,
+            backoff: None,
+            original_schedule_time: None,
+        };
+        detail_mutator(&mut lamd);
         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,
-            ),
+            details: build_local_activity_marker_details(lamd, payload),
             workflow_task_completed_event_id: self.previous_task_completed_id,
             failure,
             ..Default::default()
@@ -321,7 +300,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Payload,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, None);
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |_| {});
     }
 
     pub fn add_local_activity_result_marker_with_time(
@@ -331,7 +310,9 @@ impl TestHistoryBuilder {
         payload: Payload,
         complete_time: Timestamp,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, Some(complete_time));
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |d| {
+            d.complete_time = Some(complete_time)
+        });
     }
 
     pub fn add_local_activity_fail_marker(
@@ -340,7 +321,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         failure: Failure,
     ) {
-        self.add_local_activity_marker(seq, activity_id, None, Some(failure), None);
+        self.add_local_activity_marker(seq, activity_id, None, Some(failure), |_| {});
     }
 
     pub fn add_local_activity_cancel_marker(&mut self, seq: u32, activity_id: &str) {
@@ -358,7 +339,7 @@ impl TestHistoryBuilder {
                 )),
                 encoded_attributes: Default::default(),
             }),
-            None,
+            |_| {},
         );
     }
 
@@ -368,7 +349,7 @@ impl TestHistoryBuilder {
         workflow_id: impl Into<String>,
         run_id: impl Into<String>,
     ) -> i64 {
-        let attrs = SignalExternalWorkflowExecutionInitiatedEventAttributes {
+        self.add(SignalExternalWorkflowExecutionInitiatedEventAttributes {
             workflow_task_completed_event_id: self.previous_task_completed_id,
             workflow_execution: Some(WorkflowExecution {
                 workflow_id: workflow_id.into(),
@@ -377,11 +358,7 @@ impl TestHistoryBuilder {
             signal_name: signal_name.into(),
             control: "".to_string(),
             ..Default::default()
-        };
-        self.add_get_event_id(
-            EventType::SignalExternalWorkflowExecutionInitiated,
-            Some(attrs.into()),
-        )
+        })
     }
 
     pub fn add_external_signal_completed(&mut self, initiated_id: i64) {
@@ -404,18 +381,16 @@ impl TestHistoryBuilder {
     }
 
     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,
-            workflow_execution: Some(WorkflowExecution {
-                workflow_id: execution.workflow_id,
-                run_id: execution.run_id,
-            }),
-            ..Default::default()
-        };
-        self.add_get_event_id(
-            EventType::RequestCancelExternalWorkflowExecutionInitiated,
-            Some(attrs.into()),
+        self.add(
+            RequestCancelExternalWorkflowExecutionInitiatedEventAttributes {
+                workflow_task_completed_event_id: self.previous_task_completed_id,
+                namespace: execution.namespace,
+                workflow_execution: Some(WorkflowExecution {
+                    workflow_id: execution.workflow_id,
+                    run_id: execution.run_id,
+                }),
+                ..Default::default()
+            },
         )
     }
 
@@ -441,6 +416,25 @@ impl TestHistoryBuilder {
         );
     }
 
+    pub fn add_wfe_started_with_wft_timeout(&mut self, dur: Duration) {
+        let mut wesattrs = default_wes_attribs();
+        wesattrs.workflow_task_timeout = Some(dur.try_into().unwrap());
+        self.add(wesattrs);
+    }
+
+    pub fn add_upsert_search_attrs_for_patch(&mut self, attribs: &[String]) {
+        let mut indexed_fields = HashMap::new();
+        indexed_fields.insert(
+            "TemporalChangeVersion".to_string(),
+            attribs.as_json_payload().unwrap(),
+        );
+        let attrs = UpsertWorkflowSearchAttributesEventAttributes {
+            workflow_task_completed_event_id: self.previous_task_completed_id,
+            search_attributes: Some(SearchAttributes { indexed_fields }),
+        };
+        self.build_and_push_event(EventType::UpsertWorkflowSearchAttributes, attrs.into())
+    }
+
     pub fn get_orig_run_id(&self) -> &str {
         &self.original_run_id
     }
@@ -465,7 +459,7 @@ impl TestHistoryBuilder {
     }
 
     /// Return most recent wft start time or panic if unset
-    pub fn wft_start_time(&self) -> prost_types::Timestamp {
+    pub fn wft_start_time(&self) -> Timestamp {
         self.events[(self.workflow_task_scheduled_event_id + 1) as usize]
             .event_time
             .clone()
@@ -492,6 +486,37 @@ impl TestHistoryBuilder {
         modifier(he);
     }
 
+    /// Sets internal patches which should appear in the first WFT complete event
+    pub fn set_flags_first_wft(&mut self, core: &[u32], lang: &[u32]) {
+        Self::set_flags(self.events.iter_mut(), core, lang)
+    }
+
+    /// Sets internal patches which should appear in the most recent complete event
+    pub fn set_flags_last_wft(&mut self, core: &[u32], lang: &[u32]) {
+        Self::set_flags(self.events.iter_mut().rev(), core, lang)
+    }
+
+    fn set_flags<'a>(
+        mut events: impl Iterator<Item = &'a mut HistoryEvent>,
+        core: &[u32],
+        lang: &[u32],
+    ) {
+        if let Some(first_attrs) = events.find_map(|e| {
+            if let Some(Attributes::WorkflowTaskCompletedEventAttributes(a)) = e.attributes.as_mut()
+            {
+                Some(a)
+            } else {
+                None
+            }
+        }) {
+            let sdk_dat = first_attrs
+                .sdk_metadata
+                .get_or_insert_with(Default::default);
+            sdk_dat.core_used_flags = core.to_vec();
+            sdk_dat.lang_used_flags = lang.to_vec();
+        }
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -541,3 +566,10 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
         ..Default::default()
     }
 }
+
+pub fn default_act_sched() -> ScheduleActivity {
+    ScheduleActivity {
+        activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+        ..Default::default()
+    }
+}

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

@@ -136,6 +136,10 @@ impl HistoryInfo {
         &self.events
     }
 
+    pub fn into_events(self) -> Vec<HistoryEvent> {
+        self.events
+    }
+
     /// Extract run id from the workflow execution started attributes.
     pub fn orig_run_id(&self) -> &str {
         &self.wf_exe_started_attrs.original_execution_run_id
@@ -179,6 +183,11 @@ impl HistoryInfo {
     pub fn previous_started_event_id(&self) -> i64 {
         self.previous_started_event_id
     }
+
+    /// Returns the current workflow task started event id
+    pub fn workflow_task_started_event_id(&self) -> i64 {
+        self.workflow_task_started_event_id
+    }
 }
 
 impl From<HistoryInfo> for History {
@@ -204,7 +213,7 @@ mod tests {
         let mut t = TestHistoryBuilder::default();
         t.add_by_type(EventType::WorkflowExecutionStarted);
         t.add_full_wf_task();
-        let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
+        let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
         t.add_timer_fired(timer_started_event_id, timer_id.to_string());
         t.add_workflow_task_scheduled_and_started();
         t