@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/core/src/worker/client/mocks.rs

@@ -0,0 +1,86 @@
+use super::*;
+use futures::Future;
+
+#[cfg(test)]
+/// Create a mock client primed with basic necessary expectations
+pub(crate) fn mock_workflow_client() -> MockWorkerClient {
+    MockWorkerClient::new()
+}
+
+/// Create a mock manual client primed with basic necessary expectations
+pub(crate) fn mock_manual_workflow_client() -> MockManualWorkerClient {
+    MockManualWorkerClient::new()
+}
+
+// Need a version of the mock that can return futures so we can return potentially pending
+// results. This is really annoying b/c of the async trait stuff. Need
+// https://github.com/asomers/mockall/issues/189 to be fixed for it to go away.
+mockall::mock! {
+    pub ManualWorkerClient {}
+    impl WorkerClient for ManualWorkerClient {
+        fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
+            -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn poll_activity_task<'a, 'b>(&self, task_queue: String, max_tasks_per_sec: Option<f64>)
+            -> impl Future<Output = Result<PollActivityTaskQueueResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn complete_workflow_task<'a, 'b>(
+            &self,
+            request: WorkflowTaskCompletion,
+        ) -> impl Future<Output = Result<RespondWorkflowTaskCompletedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn complete_activity_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            result: Option<Payloads>,
+        ) -> impl Future<Output = Result<RespondActivityTaskCompletedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn cancel_activity_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            details: Option<Payloads>,
+        ) -> impl Future<Output = Result<RespondActivityTaskCanceledResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn fail_activity_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            failure: Option<Failure>,
+        ) -> impl Future<Output = Result<RespondActivityTaskFailedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn fail_workflow_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            cause: WorkflowTaskFailedCause,
+            failure: Option<Failure>,
+        ) -> impl Future<Output = Result<RespondWorkflowTaskFailedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn record_activity_heartbeat<'a, 'b>(
+           &self,
+           task_token: TaskToken,
+           details: Option<Payloads>,
+        ) -> impl Future<Output = Result<RecordActivityTaskHeartbeatResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn get_workflow_execution_history<'a, 'b>(
+            &self,
+            workflow_id: String,
+            run_id: Option<String>,
+            page_token: Vec<u8>
+        ) -> impl Future<Output = Result<GetWorkflowExecutionHistoryResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
+        fn respond_legacy_query<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            query_result: QueryResult,
+        ) -> impl Future<Output = Result<RespondQueryTaskCompletedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+    }
+}

package/sdk-core/core/src/worker/client.rs

@@ -0,0 +1,209 @@
+//! Worker-specific client needs
+
+pub(crate) mod mocks;
+
+use std::{
+    borrow::Borrow,
+    ops::{Deref, DerefMut},
+};
+use temporal_client::{WorkflowClientTrait, WorkflowTaskCompletion};
+use temporal_sdk_core_protos::{
+    coresdk::workflow_commands::QueryResult,
+    temporal::api::{
+        common::v1::Payloads, enums::v1::WorkflowTaskFailedCause, failure::v1::Failure,
+        workflowservice::v1::*,
+    },
+    TaskToken,
+};
+
+type Result<T, E = tonic::Status> = std::result::Result<T, E>;
+
+/// Contains everything a worker needs to interact with the server
+pub(crate) struct WorkerClientBag {
+    client: Box<dyn WorkerClient>,
+    namespace: String,
+}
+
+impl WorkerClientBag {
+    pub fn new(client: Box<dyn WorkerClient>, namespace: String) -> Self {
+        Self { client, namespace }
+    }
+
+    pub fn namespace(&self) -> &str {
+        &self.namespace
+    }
+}
+impl Deref for WorkerClientBag {
+    type Target = dyn WorkerClient;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.client
+    }
+}
+impl DerefMut for WorkerClientBag {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.client
+    }
+}
+#[cfg(test)]
+impl<T> From<T> for WorkerClientBag
+where
+    T: WorkerClient + 'static,
+{
+    fn from(c: T) -> Self {
+        use temporal_sdk_core_test_utils::NAMESPACE;
+
+        WorkerClientBag::new(Box::new(c), NAMESPACE.to_string())
+    }
+}
+
+/// This trait contains everything workers need to interact with Temporal, and hence provides a
+/// minimal mocking surface. Delegates to [WorkflowClientTrait] so see that for details.
+#[cfg_attr(test, mockall::automock)]
+#[async_trait::async_trait]
+pub(crate) trait WorkerClient: Sync + Send {
+    async fn poll_workflow_task(
+        &self,
+        task_queue: String,
+        is_sticky: bool,
+    ) -> Result<PollWorkflowTaskQueueResponse>;
+    async fn poll_activity_task(
+        &self,
+        task_queue: String,
+        max_tasks_per_sec: Option<f64>,
+    ) -> Result<PollActivityTaskQueueResponse>;
+    async fn complete_workflow_task(
+        &self,
+        request: WorkflowTaskCompletion,
+    ) -> Result<RespondWorkflowTaskCompletedResponse>;
+    async fn complete_activity_task(
+        &self,
+        task_token: TaskToken,
+        result: Option<Payloads>,
+    ) -> Result<RespondActivityTaskCompletedResponse>;
+    async fn record_activity_heartbeat(
+        &self,
+        task_token: TaskToken,
+        details: Option<Payloads>,
+    ) -> Result<RecordActivityTaskHeartbeatResponse>;
+    async fn cancel_activity_task(
+        &self,
+        task_token: TaskToken,
+        details: Option<Payloads>,
+    ) -> Result<RespondActivityTaskCanceledResponse>;
+    async fn fail_activity_task(
+        &self,
+        task_token: TaskToken,
+        failure: Option<Failure>,
+    ) -> Result<RespondActivityTaskFailedResponse>;
+    async fn fail_workflow_task(
+        &self,
+        task_token: TaskToken,
+        cause: WorkflowTaskFailedCause,
+        failure: Option<Failure>,
+    ) -> Result<RespondWorkflowTaskFailedResponse>;
+    async fn get_workflow_execution_history(
+        &self,
+        workflow_id: String,
+        run_id: Option<String>,
+        page_token: Vec<u8>,
+    ) -> Result<GetWorkflowExecutionHistoryResponse>;
+    async fn respond_legacy_query(
+        &self,
+        task_token: TaskToken,
+        query_result: QueryResult,
+    ) -> Result<RespondQueryTaskCompletedResponse>;
+}
+
+#[async_trait::async_trait]
+impl<'a, T> WorkerClient for T
+where
+    T: Borrow<dyn WorkflowClientTrait + 'a + Send + Sync> + Send + Sync,
+{
+    async fn poll_workflow_task(
+        &self,
+        task_queue: String,
+        is_sticky: bool,
+    ) -> Result<PollWorkflowTaskQueueResponse> {
+        WorkflowClientTrait::poll_workflow_task(self.borrow(), task_queue, is_sticky).await
+    }
+
+    async fn poll_activity_task(
+        &self,
+        task_queue: String,
+        max_tasks_per_sec: Option<f64>,
+    ) -> Result<PollActivityTaskQueueResponse> {
+        WorkflowClientTrait::poll_activity_task(self.borrow(), task_queue, max_tasks_per_sec).await
+    }
+
+    async fn complete_workflow_task(
+        &self,
+        request: WorkflowTaskCompletion,
+    ) -> Result<RespondWorkflowTaskCompletedResponse> {
+        WorkflowClientTrait::complete_workflow_task(self.borrow(), request).await
+    }
+
+    async fn complete_activity_task(
+        &self,
+        task_token: TaskToken,
+        result: Option<Payloads>,
+    ) -> Result<RespondActivityTaskCompletedResponse> {
+        WorkflowClientTrait::complete_activity_task(self.borrow(), task_token, result).await
+    }
+
+    async fn record_activity_heartbeat(
+        &self,
+        task_token: TaskToken,
+        details: Option<Payloads>,
+    ) -> Result<RecordActivityTaskHeartbeatResponse> {
+        WorkflowClientTrait::record_activity_heartbeat(self.borrow(), task_token, details).await
+    }
+
+    async fn cancel_activity_task(
+        &self,
+        task_token: TaskToken,
+        details: Option<Payloads>,
+    ) -> Result<RespondActivityTaskCanceledResponse> {
+        WorkflowClientTrait::cancel_activity_task(self.borrow(), task_token, details).await
+    }
+
+    async fn fail_activity_task(
+        &self,
+        task_token: TaskToken,
+        failure: Option<Failure>,
+    ) -> Result<RespondActivityTaskFailedResponse> {
+        WorkflowClientTrait::fail_activity_task(self.borrow(), task_token, failure).await
+    }
+
+    async fn fail_workflow_task(
+        &self,
+        task_token: TaskToken,
+        cause: WorkflowTaskFailedCause,
+        failure: Option<Failure>,
+    ) -> Result<RespondWorkflowTaskFailedResponse> {
+        WorkflowClientTrait::fail_workflow_task(self.borrow(), task_token, cause, failure).await
+    }
+
+    async fn get_workflow_execution_history(
+        &self,
+        workflow_id: String,
+        run_id: Option<String>,
+        page_token: Vec<u8>,
+    ) -> Result<GetWorkflowExecutionHistoryResponse> {
+        WorkflowClientTrait::get_workflow_execution_history(
+            self.borrow(),
+            workflow_id,
+            run_id,
+            page_token,
+        )
+        .await
+    }
+
+    async fn respond_legacy_query(
+        &self,
+        task_token: TaskToken,
+        query_result: QueryResult,
+    ) -> Result<RespondQueryTaskCompletedResponse> {
+        WorkflowClientTrait::respond_legacy_query(self.borrow(), task_token, query_result).await
+    }
+}