@temporalio/core-bridge 1.12.0 → 1.12.2

package/sdk-core/core-c-bridge/src/tests/mod.rs

@@ -0,0 +1,178 @@
+use crate::client::RpcService;
+use crate::tests::utils::{
+    OwnedRpcCallOptions, RpcCallError, default_client_options, default_server_config,
+};
+use context::Context;
+use prost::Message;
+use std::sync::Arc;
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
+    GetSystemInfoRequest, GetSystemInfoResponse,
+};
+
+mod context;
+mod utils;
+
+#[test]
+fn test_get_system_info() {
+    Context::with(|context| {
+        context.runtime_new().unwrap();
+        context
+            .start_dev_server(Box::new(default_server_config()))
+            .unwrap();
+        context
+            .client_connect(Box::new(default_client_options(
+                &context.ephemeral_server_target().unwrap().unwrap(),
+            )))
+            .unwrap();
+        let result = GetSystemInfoResponse::decode(
+            &*context
+                .rpc_call(Box::new(OwnedRpcCallOptions {
+                    service: RpcService::Workflow,
+                    rpc: "GetSystemInfo".into(),
+                    req: GetSystemInfoRequest {}.encode_to_vec(),
+                    retry: false,
+                    metadata: None,
+                    timeout_millis: 0,
+                    cancellation_token: None,
+                }))
+                .unwrap(),
+        );
+        assert!(result.is_ok());
+    });
+}
+
+fn rpc_call_exists(context: &Arc<Context>, service: RpcService, rpc: &str) -> bool {
+    let result = context.rpc_call(Box::new(OwnedRpcCallOptions {
+        service,
+        rpc: rpc.into(),
+        req: Vec::new(),
+        retry: false,
+        metadata: None,
+        timeout_millis: 0,
+        cancellation_token: None,
+    }));
+
+    if let Err(e) = result {
+        // will panic on other types of errors
+        e.downcast::<RpcCallError>().unwrap().message != format!("Unknown RPC call {rpc}")
+    } else {
+        true
+    }
+}
+
+#[test]
+fn test_missing_rpc_call_has_expected_error_message() {
+    Context::with(|context| {
+        context.runtime_new().unwrap();
+        context
+            .start_dev_server(Box::new(default_server_config()))
+            .unwrap();
+        context
+            .client_connect(Box::new(default_client_options(
+                &context.ephemeral_server_target().unwrap().unwrap(),
+            )))
+            .unwrap();
+
+        assert!(!rpc_call_exists(
+            context,
+            RpcService::Workflow,
+            "NonExistentMethod"
+        ));
+        assert!(!rpc_call_exists(
+            context,
+            RpcService::Operator,
+            "NonExistentMethod"
+        ));
+        assert!(!rpc_call_exists(
+            context,
+            RpcService::Cloud,
+            "NonExistentMethod"
+        ));
+        assert!(!rpc_call_exists(
+            context,
+            RpcService::Test,
+            "NonExistentMethod"
+        ));
+        assert!(!rpc_call_exists(
+            context,
+            RpcService::Health,
+            "NonExistentMethod"
+        ));
+    });
+}
+
+fn list_proto_methods(proto_def_str: &str) -> Vec<&str> {
+    proto_def_str
+        .lines()
+        .map(|l| l.trim())
+        .filter(|l| l.starts_with("rpc"))
+        .map(|l| {
+            let stripped = l.strip_prefix("rpc ").unwrap();
+            stripped[..stripped.find('(').unwrap()].trim()
+        })
+        .collect()
+}
+
+fn all_rpc_calls_exist(context: &Arc<Context>, service: RpcService, proto: &str) -> bool {
+    let mut ret = true;
+    for rpc in list_proto_methods(proto) {
+        if !rpc_call_exists(context, service, rpc) {
+            eprintln!("RPC method {rpc} does not exist in service {service:?}");
+            ret = false;
+        }
+    }
+    ret
+}
+
+#[test]
+fn test_all_rpc_calls_exist() {
+    Context::with(|context| {
+        context.runtime_new().unwrap();
+        context
+            .start_dev_server(Box::new(default_server_config()))
+            .unwrap();
+        context
+            .client_connect(Box::new(default_client_options(
+                &context.ephemeral_server_target().unwrap().unwrap(),
+            )))
+            .unwrap();
+
+        assert!(all_rpc_calls_exist(
+            context,
+            RpcService::Workflow,
+            include_str!(
+                "../../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"
+            ),
+        ));
+
+        assert!(all_rpc_calls_exist(
+            context,
+            RpcService::Operator,
+            include_str!(
+                "../../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
+            ),
+        ));
+
+        assert!(all_rpc_calls_exist(
+            context,
+            RpcService::Cloud,
+            include_str!(
+                "../../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
+            ),
+        ));
+
+        assert!(all_rpc_calls_exist(
+            context,
+            RpcService::Test,
+            include_str!(
+                "../../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
+            ),
+        ));
+
+        assert!(all_rpc_calls_exist(
+            context,
+            RpcService::Health,
+            include_str!("../../../sdk-core-protos/protos/grpc/health/v1/health.proto"),
+        ));
+    });
+}

package/sdk-core/core-c-bridge/src/tests/utils.rs

@@ -0,0 +1,108 @@
+use crate::client::RpcService;
+use crate::runtime::{Runtime, temporal_core_byte_array_free};
+use crate::{ByteArray, CancellationToken};
+use std::collections::HashMap;
+use std::ops::Deref;
+use temporal_client::{ClientOptions, ClientOptionsBuilder};
+use temporal_sdk_core::ephemeral_server::{
+    TemporalDevServerConfig, TemporalDevServerConfigBuilder,
+};
+use temporal_sdk_core_test_utils::default_cached_download;
+use url::Url;
+
+pub fn byte_array_to_vec(runtime: *mut Runtime, byte_array: *const ByteArray) -> Option<Vec<u8>> {
+    (!byte_array.is_null()).then(|| {
+        let ret = unsafe { &*byte_array }.as_ref().to_vec();
+        temporal_core_byte_array_free(runtime, byte_array);
+        ret
+    })
+}
+
+pub fn byte_array_to_string(runtime: *mut Runtime, byte_array: *const ByteArray) -> Option<String> {
+    (!byte_array.is_null()).then(|| {
+        let ret = unsafe { &*byte_array }.as_ref().to_string();
+        temporal_core_byte_array_free(runtime, byte_array);
+        ret
+    })
+}
+
+pub fn pointer_or_null<T>(x: Option<impl Deref<Target = T>>) -> *const T {
+    x.map(|x| &*x as *const T).unwrap_or(std::ptr::null())
+}
+
+pub fn default_server_config() -> TemporalDevServerConfig {
+    TemporalDevServerConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap()
+}
+
+pub fn default_client_options(target: &str) -> ClientOptions {
+    ClientOptionsBuilder::default()
+        .target_url(Url::parse(&format!("http://{target}")).unwrap())
+        .client_name("core-c-bridge-tests".to_owned())
+        .client_version("0.1.0".to_owned())
+        .build()
+        .unwrap()
+}
+
+pub struct OwnedRpcCallOptions {
+    pub service: RpcService,
+    pub rpc: String,
+    pub req: Vec<u8>,
+    pub retry: bool,
+    pub metadata: Option<MetadataMap>,
+    pub timeout_millis: u32,
+    pub cancellation_token: Option<*mut CancellationToken>,
+}
+
+unsafe impl Send for OwnedRpcCallOptions {}
+unsafe impl Sync for OwnedRpcCallOptions {}
+
+#[derive(Clone, Debug)]
+pub enum MetadataMap {
+    Deserialized(HashMap<String, String>),
+    Serialized(String),
+}
+
+impl From<HashMap<String, String>> for MetadataMap {
+    fn from(value: HashMap<String, String>) -> Self {
+        Self::Deserialized(value)
+    }
+}
+
+#[allow(dead_code)]
+impl MetadataMap {
+    pub fn serialize_from_map(map: &HashMap<String, String>) -> String {
+        map.iter().map(|(k, v)| format!("{k}\n{v}\n")).collect()
+    }
+
+    pub fn serialize(&self) -> String {
+        match self {
+            Self::Deserialized(map) => Self::serialize_from_map(map),
+            Self::Serialized(s) => s.clone(),
+        }
+    }
+
+    pub fn serialize_in_place(&mut self) {
+        if let Self::Deserialized(map) = self {
+            *self = Self::Serialized(Self::serialize_from_map(map));
+        }
+    }
+
+    pub fn as_str(&mut self) -> &str {
+        self.serialize_in_place();
+        let Self::Serialized(s) = self else {
+            unreachable!();
+        };
+        s
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+#[error("{message} (status code {status_code})")]
+pub struct RpcCallError {
+    pub status_code: u32,
+    pub message: String,
+    pub details: Option<Vec<u8>>,
+}