@temporalio/core-bridge 0.14.0 → 0.16.4

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

@@ -9,7 +9,10 @@ use crate::{
 use anyhow::bail;
 use std::time::SystemTime;
 use temporal_sdk_core_protos::{
-    coresdk::common::{build_has_change_marker_details, NamespacedWorkflowExecution},
+    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},
@@ -136,6 +139,52 @@ impl TestHistoryBuilder {
         self.build_and_push_event(EventType::WorkflowExecutionCanceled, attrs.into());
     }
 
+    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()
+                    },
+                ),
+            ),
+        )
+    }
+    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()
+                    },
+                ),
+            ),
+        )
+    }
+
+    pub fn add_activity_task_completed(
+        &mut self,
+        scheduled_event_id: i64,
+        started_event_id: i64,
+        payload: CorePayload,
+    ) {
+        self.add(
+            EventType::ActivityTaskCompleted,
+            history_event::Attributes::ActivityTaskCompletedEventAttributes(
+                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) {
         let attrs = ActivityTaskCancelRequestedEventAttributes {
             scheduled_event_id,
@@ -293,6 +342,16 @@ impl TestHistoryBuilder {
         HistoryInfo::new_from_history(&self.events.clone().into(), None)
     }
 
+    pub(crate) fn get_one_wft(
+        &self,
+        from_wft_number: usize,
+    ) -> Result<HistoryInfo, HistoryInfoError> {
+        let mut histinfo =
+            HistoryInfo::new_from_history(&self.events.clone().into(), Some(from_wft_number))?;
+        histinfo.make_incremental();
+        Ok(histinfo)
+    }
+
     fn build_and_push_event(&mut self, event_type: EventType, attribs: Attributes) {
         self.current_event_id += 1;
         let evt = HistoryEvent {
@@ -309,7 +368,7 @@ impl TestHistoryBuilder {
             },
         )) = &evt.attributes
         {
-            self.original_run_id = original_execution_run_id.to_owned();
+            self.original_run_id = original_execution_run_id.clone();
         };
         self.events.push(evt);
     }

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

@@ -100,19 +100,31 @@ impl HistoryInfo {
         unreachable!()
     }
 
+    /// Remove events from the beginning of this history such that it looks like what would've been
+    /// delivered on a sticky queue where the previously started task was the one before the last
+    /// task in this history.
+    pub(crate) fn make_incremental(&mut self) {
+        let last_complete_ix = self
+            .events
+            .iter()
+            .rposition(|he| he.event_type() == EventType::WorkflowTaskCompleted)
+            .expect("Must be a WFT completed event in history");
+        self.events.drain(0..=last_complete_ix);
+    }
+
     pub(crate) fn events(&self) -> &[HistoryEvent] {
         &self.events
     }
 
     /// Non-test code should *not* rely on just counting workflow tasks b/c of pagination
-    pub(crate) fn wf_task_count(&self) -> usize {
+    pub(crate) const fn wf_task_count(&self) -> usize {
         self.wf_task_count
     }
 }
 
 impl From<HistoryInfo> for HistoryUpdate {
     fn from(v: HistoryInfo) -> Self {
-        HistoryUpdate::new_from_events(v.events, v.previous_started_event_id)
+        Self::new_from_events(v.events, v.previous_started_event_id)
     }
 }
 
@@ -135,4 +147,11 @@ mod tests {
         let history_info = t.get_history_info(2).unwrap();
         assert_eq!(8, history_info.events.len());
     }
+
+    #[test]
+    fn incremental_works() {
+        let t = canned_histories::single_timer("timer1");
+        let hi = t.get_one_wft(2).unwrap();
+        dbg!(hi.events);
+    }
 }

package/sdk-core/src/test_help/mod.rs

@@ -47,22 +47,27 @@ use temporal_sdk_core_protos::{
 
 pub type Result<T, E = anyhow::Error> = std::result::Result<T, E>;
 pub const TEST_Q: &str = "q";
+pub static NO_MORE_WORK_ERROR_MSG: &str = "No more work to do";
 
 /// When constructing responses for mocks, indicates how a given response should be built
 #[derive(derive_more::From, Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub enum ResponseType {
     ToTaskNum(usize),
+    /// Returns just the history after the WFT completed of the provided task number - 1, through to
+    /// the next WFT started. Simulating the incremental history for just the provided task number
+    #[from(ignore)]
+    OneTask(usize),
     AllHistory,
 }
 
 impl From<&usize> for ResponseType {
     fn from(u: &usize) -> Self {
-        ResponseType::ToTaskNum(*u)
+        Self::ToTaskNum(*u)
     }
 }
 // :shrug:
-impl From<&ResponseType> for ResponseType {
-    fn from(r: &ResponseType) -> Self {
+impl From<&Self> for ResponseType {
+    fn from(r: &Self) -> Self {
         *r
     }
 }
@@ -164,7 +169,7 @@ pub struct MockWorker {
 
 impl Default for MockWorker {
     fn default() -> Self {
-        MockWorker {
+        Self {
             wf_poller: Box::from(mock_poller()),
             act_poller: None,
             config: WorkerConfig::default_test_q(),
@@ -174,14 +179,14 @@ impl Default for MockWorker {
 
 impl MockWorker {
     pub fn new(q: &str, wf_poller: BoxedWFPoller) -> Self {
-        MockWorker {
+        Self {
             wf_poller,
             act_poller: None,
             config: WorkerConfig::default(q),
         }
     }
     pub fn for_queue(q: &str) -> Self {
-        MockWorker {
+        Self {
             wf_poller: Box::from(mock_poller()),
             act_poller: None,
             config: WorkerConfig::default(q),
@@ -193,15 +198,12 @@ impl<SG> MocksHolder<SG>
 where
     SG: ServerGatewayApis + Send + Sync + 'static,
 {
-    pub fn from_mock_workers(
-        sg: SG,
-        mock_workers: impl IntoIterator<Item = MockWorker>,
-    ) -> MocksHolder<SG> {
+    pub fn from_mock_workers(sg: SG, mock_workers: impl IntoIterator<Item = MockWorker>) -> Self {
         let mock_pollers = mock_workers
             .into_iter()
             .map(|w| (w.config.task_queue.clone(), w))
             .collect();
-        MocksHolder {
+        Self {
             sg,
             mock_pollers,
             outstanding_task_map: None,
@@ -209,16 +211,12 @@ where
     }
 
     /// Uses the provided list of tasks to create a mock poller for the `TEST_Q`
-    pub fn from_gateway_with_responses<WFT, ACT>(
-        sg: SG,
-        wf_tasks: WFT,
-        act_tasks: ACT,
-    ) -> MocksHolder<SG>
+    pub fn from_gateway_with_responses<WFT, ACT>(sg: SG, wf_tasks: WFT, act_tasks: ACT) -> Self
     where
         WFT: IntoIterator<Item = PollWorkflowTaskQueueResponse>,
         ACT: IntoIterator<Item = PollActivityTaskQueueResponse>,
-        <WFT as IntoIterator>::IntoIter: std::marker::Send + 'static,
-        <ACT as IntoIterator>::IntoIter: std::marker::Send + 'static,
+        <WFT as IntoIterator>::IntoIter: Send + 'static,
+        <ACT as IntoIterator>::IntoIter: Send + 'static,
     {
         let mut mock_pollers = HashMap::new();
         let mock_poller = mock_poller_from_resps(wf_tasks);
@@ -234,7 +232,7 @@ where
                     .unwrap(),
             },
         );
-        MocksHolder {
+        Self {
             sg,
             mock_pollers,
             outstanding_task_map: None,
@@ -246,7 +244,7 @@ pub fn mock_poller_from_resps<T, I>(tasks: I) -> BoxedPoller<T>
 where
     T: Send + Sync + 'static,
     I: IntoIterator<Item = T>,
-    <I as IntoIterator>::IntoIter: std::marker::Send + 'static,
+    <I as IntoIterator>::IntoIter: Send + 'static,
 {
     let mut mock_poller = mock_poller();
     let mut tasks = tasks.into_iter();
@@ -254,9 +252,7 @@ where
         if let Some(t) = tasks.next() {
             Some(Ok(t))
         } else {
-            Some(Err(tonic::Status::out_of_range(
-                "Ran out of mock responses!",
-            )))
+            Some(Err(tonic::Status::cancelled(NO_MORE_WORK_ERROR_MSG)))
         }
     });
     Box::new(mock_poller) as BoxedPoller<T>
@@ -412,7 +408,7 @@ pub fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder<MockServerGateway
                 let cur_attempt = attempts_at_task_num.entry(to_task_num).or_insert(1);
                 let mut r = hist_to_poll_resp(
                     &hist.hist,
-                    hist.wf_id.to_owned(),
+                    hist.wf_id.clone(),
                     *to_task_num,
                     hist.task_q.clone(),
                 );
@@ -430,7 +426,7 @@ pub fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder<MockServerGateway
     }
 
     let mut mock_pollers = HashMap::new();
-    for (task_q, mut queue_tasks) in task_queues_to_resps.into_iter() {
+    for (task_q, mut queue_tasks) in task_queues_to_resps {
         let mut mock_poller = mock_poller();
 
         // The poller will return history from any workflow runs that do not have currently
@@ -438,11 +434,7 @@ pub fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder<MockServerGateway
         let outstanding = outstanding_wf_task_tokens.clone();
         mock_poller
             .expect_poll()
-            .times(
-                correct_num_polls
-                    .map::<TimesRange, _>(Into::into)
-                    .unwrap_or_else(|| RangeFull.into()),
-            )
+            .times(correct_num_polls.map_or_else(|| RangeFull.into(), Into::<TimesRange>::into))
             .returning(move || {
                 for (_, tasks) in queue_tasks.iter_mut() {
                     // Must extract run id from a workflow task associated with this workflow
@@ -458,7 +450,7 @@ pub fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder<MockServerGateway
                         }
                     }
                 }
-                Some(Err(tonic::Status::cancelled("No more work to do")))
+                Some(Err(tonic::Status::cancelled(NO_MORE_WORK_ERROR_MSG)))
             });
         let mw = MockWorker::new(&task_q, Box::from(mock_poller));
         mock_pollers.insert(task_q, mw);
@@ -477,8 +469,7 @@ pub fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder<MockServerGateway
         .withf(cfg.expect_fail_wft_matcher)
         .times(
             cfg.num_expected_fails
-                .map::<TimesRange, _>(Into::into)
-                .unwrap_or_else(|| RangeFull.into()),
+                .map_or_else(|| RangeFull.into(), Into::<TimesRange>::into),
         )
         .returning(move |tt, _, _| {
             outstanding.write().remove_by_right(&tt);
@@ -508,6 +499,7 @@ pub fn hist_to_poll_resp(
     };
     let hist_info = match response_type {
         ResponseType::ToTaskNum(tn) => t.get_history_info(tn).unwrap(),
+        ResponseType::OneTask(tn) => t.get_one_wft(tn).unwrap(),
         ResponseType::AllHistory => t.get_full_history_info().unwrap(),
     };
     let batch = hist_info.events().to_vec();
@@ -557,7 +549,7 @@ pub(crate) async fn poll_and_reply<'a>(
     eviction_mode: WorkflowCachingPolicy,
     expect_and_reply: &'a [AsserterWithReply<'a>],
 ) {
-    poll_and_reply_clears_outstanding_evicts(core, None, eviction_mode, expect_and_reply).await
+    poll_and_reply_clears_outstanding_evicts(core, None, eviction_mode, expect_and_reply).await;
 }
 
 pub(crate) async fn poll_and_reply_clears_outstanding_evicts<'a>(