@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/tests/integ_tests/data_converter_tests.rs

@@ -0,0 +1,381 @@
+use crate::common::{CoreWfStarter, get_integ_connection, integ_namespace};
+use futures::{FutureExt, future::BoxFuture};
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use temporalio_client::{Client, ClientOptions, UntypedWorkflow, WorkflowStartOptions};
+use temporalio_common::{
+    data_converters::{
+        DataConverter, DefaultFailureConverter, MultiArgs2, PayloadCodec, PayloadConversionError,
+        PayloadConverter, SerializationContext, SerializationContextData, TemporalDeserializable,
+        TemporalSerializable,
+    },
+    protos::temporal::api::{common::v1::Payload, history::v1::history_event::Attributes},
+    worker::WorkerTaskTypes,
+};
+use temporalio_macros::{activities, workflow, workflow_methods};
+use temporalio_sdk::{
+    ActivityOptions, WorkflowContext, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
+};
+
+#[derive(Clone, Debug)]
+struct TrackedWrapper(TrackedValue);
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+struct TrackedValue {
+    data: String,
+    serialize_count: u32,
+    deserialize_count: u32,
+}
+
+impl TrackedValue {
+    fn new(data: String) -> Self {
+        Self {
+            data,
+            serialize_count: 0,
+            deserialize_count: 0,
+        }
+    }
+}
+
+impl TemporalSerializable for TrackedWrapper {
+    fn to_payload(&self, _: &SerializationContext<'_>) -> Result<Payload, PayloadConversionError> {
+        let mut wire = self.0.clone();
+        wire.serialize_count += 1;
+        let json = serde_json::to_vec(&wire)
+            .map_err(|e| PayloadConversionError::EncodingError(Box::new(e)))?;
+        Ok(Payload {
+            metadata: {
+                let mut hm = std::collections::HashMap::new();
+                hm.insert("encoding".to_string(), b"json/plain".to_vec());
+                hm
+            },
+            data: json,
+            external_payloads: vec![],
+        })
+    }
+}
+
+impl TemporalDeserializable for TrackedWrapper {
+    fn from_payload(
+        _: &SerializationContext<'_>,
+        payload: Payload,
+    ) -> Result<Self, PayloadConversionError> {
+        let wire: TrackedValue = serde_json::from_slice(&payload.data)
+            .map_err(|e| PayloadConversionError::EncodingError(Box::new(e)))?;
+        let mut val = wire.clone();
+        val.deserialize_count += 1;
+        Ok(TrackedWrapper(val))
+    }
+}
+
+struct TestActivities;
+#[activities]
+impl TestActivities {
+    #[activity]
+    async fn process_tracked(
+        _ctx: ActivityContext,
+        mut input: TrackedWrapper,
+    ) -> Result<TrackedWrapper, ActivityError> {
+        input.0.data = format!("activity-processed:{}", input.0.data);
+        Ok(input)
+    }
+}
+
+#[workflow]
+#[derive(Default)]
+struct DataConverterTestWorkflow;
+#[workflow_methods]
+impl DataConverterTestWorkflow {
+    #[run]
+    async fn run(
+        ctx: &mut WorkflowContext<Self>,
+        input: TrackedWrapper,
+    ) -> WorkflowResult<TrackedWrapper> {
+        let output = ctx
+            .start_activity(
+                TestActivities::process_tracked,
+                input,
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(5)),
+                    ..Default::default()
+                },
+            )
+            .await
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+
+        Ok(output)
+    }
+}
+
+#[tokio::test]
+async fn data_converter_tracks_serialization_points() {
+    let wf_name = DataConverterTestWorkflow::name();
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_activities(TestActivities);
+    starter
+        .sdk_config
+        .register_workflow::<DataConverterTestWorkflow>();
+    let mut worker = starter.worker().await;
+
+    let input = TrackedValue::new("test-input".to_string());
+    assert_eq!(input.serialize_count, 0);
+    assert_eq!(input.deserialize_count, 0);
+
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            DataConverterTestWorkflow::run,
+            TrackedWrapper(input),
+            WorkflowStartOptions::new(task_queue, wf_name.to_owned()).build(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let output = handle.get_result(Default::default()).await.unwrap().0;
+
+    assert!(
+        output.data.contains("activity-processed:test-input"),
+        "Activity should have processed the input, got: {}",
+        output.data
+    );
+
+    // Expected path:
+    // 1. Client serializes input (serialize_count: 0 -> 1)
+    // 2. Workflow deserializes input (deserialize_count: 0 -> 1)
+    // 3. Workflow serializes for activity call (serialize_count: 1 -> 2)
+    // 4. Activity deserializes input (deserialize_count: 1 -> 2)
+    // 5. Activity serializes result (serialize_count: 2 -> 3)
+    // 6. Workflow deserializes activity result (deserialize_count: 2 -> 3)
+    // 7. Workflow serializes final result (serialize_count: 3 -> 4)
+    // 8. Client deserializes result (deserialize_count: 3 -> 4)
+
+    assert!(
+        output.serialize_count == 4,
+        "Value should have been serialized 4 times, was serialized {} times",
+        output.serialize_count
+    );
+    assert!(
+        output.deserialize_count == 4,
+        "Value should have been deserialized 4 times, was deserialized {} times",
+        output.deserialize_count
+    );
+}
+
+#[workflow]
+#[derive(Default)]
+struct MultiArgs2Workflow;
+#[workflow_methods]
+impl MultiArgs2Workflow {
+    #[run]
+    async fn run(
+        _ctx: &mut WorkflowContext<Self>,
+        input: MultiArgs2<String, i32>,
+    ) -> WorkflowResult<String> {
+        Ok(format!("received: {} and {}", input.0, input.1))
+    }
+}
+
+#[tokio::test]
+async fn multi_args_serializes_as_multiple_payloads() {
+    let wf_name = MultiArgs2Workflow::name();
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_workflow::<MultiArgs2Workflow>();
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    let mut worker = starter.worker().await;
+
+    let input = MultiArgs2("hello".to_string(), 42);
+
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            MultiArgs2Workflow::run,
+            input,
+            WorkflowStartOptions::new(task_queue, wf_name.to_owned()).build(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let output = handle.get_result(Default::default()).await.unwrap();
+    assert_eq!(output, "received: hello and 42");
+
+    // Verify the workflow history contains multiple payloads in the input
+    let client = starter.get_client().await;
+    let events = client
+        .get_workflow_handle::<UntypedWorkflow>(wf_name)
+        .fetch_history(Default::default())
+        .await
+        .unwrap()
+        .into_events();
+
+    let workflow_started_event = events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::WorkflowExecutionStartedEventAttributes(attrs) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(attrs)
+            } else {
+                None
+            }
+        })
+        .expect("Should find WorkflowExecutionStarted event");
+
+    let input_payloads = workflow_started_event
+        .input
+        .as_ref()
+        .expect("Should have input payloads");
+
+    assert_eq!(
+        input_payloads.payloads.len(),
+        2,
+        "MultiArgs2<A, B> should produce 2 payloads, got {}",
+        input_payloads.payloads.len()
+    );
+
+    // Verify the content of each payload
+    let first_payload_data: String =
+        serde_json::from_slice(&input_payloads.payloads[0].data).unwrap();
+    assert_eq!(first_payload_data, "hello");
+
+    let second_payload_data: i32 =
+        serde_json::from_slice(&input_payloads.payloads[1].data).unwrap();
+    assert_eq!(second_payload_data, 42);
+}
+
+/// A codec that XORs payload data with a key and tracks encode/decode operations.
+struct XorCodec {
+    key: u8,
+    encode_count: AtomicUsize,
+    decode_count: AtomicUsize,
+}
+
+impl XorCodec {
+    fn new(key: u8) -> Self {
+        Self {
+            key,
+            encode_count: AtomicUsize::new(0),
+            decode_count: AtomicUsize::new(0),
+        }
+    }
+
+    fn encode_count(&self) -> usize {
+        self.encode_count.load(Ordering::SeqCst)
+    }
+
+    fn decode_count(&self) -> usize {
+        self.decode_count.load(Ordering::SeqCst)
+    }
+}
+
+impl PayloadCodec for XorCodec {
+    fn encode(
+        &self,
+        _context: &SerializationContextData,
+        payloads: Vec<Payload>,
+    ) -> BoxFuture<'static, Vec<Payload>> {
+        let count = payloads.len();
+        eprintln!("XorCodec::encode called with {} payloads", count);
+        self.encode_count.fetch_add(count, Ordering::SeqCst);
+        let key = self.key;
+        async move {
+            payloads
+                .into_iter()
+                .map(|mut p| {
+                    p.data = p.data.iter().map(|b| b ^ key).collect();
+                    p.metadata.insert("xor_encoded".to_string(), vec![key]);
+                    p
+                })
+                .collect()
+        }
+        .boxed()
+    }
+
+    fn decode(
+        &self,
+        _context: &SerializationContextData,
+        payloads: Vec<Payload>,
+    ) -> BoxFuture<'static, Vec<Payload>> {
+        let count = payloads.len();
+        eprintln!("XorCodec::decode called with {} payloads", count);
+        self.decode_count.fetch_add(count, Ordering::SeqCst);
+        let key = self.key;
+        async move {
+            payloads
+                .into_iter()
+                .map(|mut p| {
+                    if p.metadata.remove("xor_encoded").is_some() {
+                        p.data = p.data.iter().map(|b| b ^ key).collect();
+                    }
+                    p
+                })
+                .collect()
+        }
+        .boxed()
+    }
+}
+
+#[tokio::test]
+async fn codec_encodes_and_decodes_payloads() {
+    let wf_name = DataConverterTestWorkflow::name();
+    let codec = Arc::new(XorCodec::new(0x42));
+
+    // Create a client with our custom codec
+    let connection = get_integ_connection(None).await;
+    let data_converter = DataConverter::new(
+        PayloadConverter::default(),
+        DefaultFailureConverter,
+        codec.clone(),
+    );
+    let client_opts = ClientOptions::new(integ_namespace())
+        .data_converter(data_converter)
+        .build();
+    let client = Client::new(connection, client_opts).unwrap();
+
+    let mut starter = CoreWfStarter::new_with_overrides(wf_name, None, Some(client));
+    starter.sdk_config.register_activities(TestActivities);
+    starter.sdk_config.task_types = WorkerTaskTypes::all();
+    starter
+        .sdk_config
+        .register_workflow::<DataConverterTestWorkflow>();
+    // Use task queue name as workflow ID to avoid collisions with parallel tests
+    let wf_id = starter.get_task_queue().to_owned();
+    let mut worker = starter.worker().await;
+
+    let input = TrackedValue::new("codec-test".to_string());
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            DataConverterTestWorkflow::run,
+            TrackedWrapper(input),
+            WorkflowStartOptions::new(task_queue, wf_id).build(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let output = handle.get_result(Default::default()).await.unwrap().0;
+
+    // Verify the workflow processed correctly (activity echoed the data)
+    assert!(
+        output.data.contains("activity-processed:codec-test"),
+        "Activity should have processed the input, got: {}",
+        output.data
+    );
+
+    // Verify the codec was used for both encoding and decoding
+    assert!(
+        codec.encode_count() > 0,
+        "Codec should have encoded payloads, but encode_count was 0"
+    );
+    assert!(
+        codec.decode_count() > 0,
+        "Codec should have decoded payloads, but decode_count was 0"
+    );
+}

package/sdk-core/crates/sdk-core/tests/integ_tests/ephemeral_server_tests.rs

@@ -1,7 +1,10 @@
 use crate::common::{INTEG_CLIENT_IDENTITY, INTEG_CLIENT_NAME, INTEG_CLIENT_VERSION, NAMESPACE};
 use futures_util::{TryStreamExt, stream};
 use std::time::{SystemTime, UNIX_EPOCH};
-use temporalio_client::{ClientOptions, TestService, WorkflowService};
+use temporalio_client::{
+    Connection, ConnectionOptions,
+    grpc::{TestService, WorkflowService},
+};
 use temporalio_common::protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
 use temporalio_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfig,
@@ -132,16 +135,14 @@ fn fixed_cached_download(version: &str) -> EphemeralExe {
 
 async fn assert_ephemeral_server(server: &EphemeralServer) {
     // Connect and describe namespace
-    let mut client = ClientOptions::builder()
-        .identity(INTEG_CLIENT_IDENTITY.to_string())
-        .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
-        .client_name(INTEG_CLIENT_NAME.to_string())
-        .client_version(INTEG_CLIENT_VERSION.to_string())
-        .build()
-        .connect_no_namespace(None)
-        .await
-        .unwrap();
-    let resp = client
+    let connection_opts =
+        ConnectionOptions::new(Url::try_from(&*format!("http://{}", server.target)).unwrap())
+            .identity(INTEG_CLIENT_IDENTITY.to_string())
+            .client_name(INTEG_CLIENT_NAME.to_string())
+            .client_version(INTEG_CLIENT_VERSION.to_string())
+            .build();
+    let mut connection = Connection::connect(connection_opts).await.unwrap();
+    let resp = connection
         .describe_namespace(
             DescribeNamespaceRequest {
                 namespace: NAMESPACE.to_string(),
@@ -155,7 +156,10 @@ async fn assert_ephemeral_server(server: &EphemeralServer) {
 
     // If it has test service, make sure we can use it too
     if server.has_test_service {
-        let resp = client.get_current_time(().into_request()).await.unwrap();
+        let resp = connection
+            .get_current_time(().into_request())
+            .await
+            .unwrap();
         // Make sure it's within 5 mins of now
         let resp_seconds = resp.get_ref().time.as_ref().unwrap().seconds as u64;
         let curr_seconds = SystemTime::now()

package/sdk-core/crates/sdk-core/tests/integ_tests/heartbeat_tests.rs

@@ -1,13 +1,13 @@
-use crate::common::{CoreWfStarter, init_core_and_create_wf};
+use crate::common::{CoreWfStarter, activity_functions::StdActivities, init_core_and_create_wf};
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporalio_client::{WfClientExt, WorkflowOptions};
+use temporalio_client::WorkflowStartOptions;
 use temporalio_common::{
     prost_dur,
     protos::{
         DEFAULT_ACTIVITY_TYPE,
         coresdk::{
-            ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
+            ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
             activity_result::{
                 self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
             },
@@ -25,10 +25,44 @@ use temporalio_common::{
         test_utils::schedule_activity_cmd,
     },
 };
-use temporalio_sdk::{ActContext, ActivityOptions, WfContext};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{ActivityExecutionError, ActivityOptions, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
 use tokio::time::sleep;
 
+#[workflow]
+#[derive(Default)]
+struct ActivityDoesntHeartbeatHitsTimeoutThenCompletesWf;
+
+#[workflow_methods]
+impl ActivityDoesntHeartbeatHitsTimeoutThenCompletesWf {
+    #[run]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let res: Result<(), ActivityExecutionError> = ctx
+            .start_activity(
+                StdActivities::delay,
+                Duration::from_secs(4),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(10)),
+                    heartbeat_timeout: Some(Duration::from_secs(2)),
+                    retry_policy: Some(RetryPolicy {
+                        maximum_attempts: 1,
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                },
+            )
+            .await;
+        let err = res.unwrap_err();
+        if let ActivityExecutionError::Failed(f) = &err {
+            assert_eq!(f.is_timeout(), Some(TimeoutType::Heartbeat));
+        } else {
+            panic!("expected Failed, got {err:?}");
+        }
+        Ok(())
+    }
+}
+
 #[tokio::test]
 async fn activity_heartbeat() {
     let mut starter = init_core_and_create_wf("activity_heartbeat").await;
@@ -184,46 +218,20 @@ async fn many_act_fails_with_heartbeats() {
 async fn activity_doesnt_heartbeat_hits_timeout_then_completes() {
     let wf_name = "activity_doesnt_heartbeat_hits_timeout_then_completes";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move {
-            sleep(Duration::from_secs(4)).await;
-            Ok(echo_me)
-        },
-    );
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        let res = ctx
-            .activity(ActivityOptions {
-                activity_type: "echo_activity".to_string(),
-                input: "hi!".as_json_payload().expect("serializes fine"),
-                start_to_close_timeout: Some(Duration::from_secs(10)),
-                heartbeat_timeout: Some(Duration::from_secs(2)),
-                retry_policy: Some(RetryPolicy {
-                    maximum_attempts: 1,
-                    ..Default::default()
-                }),
-                ..Default::default()
-            })
-            .await;
-        assert_eq!(res.timed_out(), Some(TimeoutType::Heartbeat));
-        Ok(().into())
-    });
 
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+    worker.register_workflow::<ActivityDoesntHeartbeatHitsTimeoutThenCompletesWf>();
+
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            ActivityDoesntHeartbeatHitsTimeoutThenCompletesWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, wf_name.to_owned()).build(),
         )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    let handle = client.get_untyped_workflow_handle(wf_name, run_id);
-    handle
-        .get_workflow_result(Default::default())
-        .await
-        .unwrap();
+    handle.get_result(Default::default()).await.unwrap();
 }