Add Env prefix befor Config in envconfig c-bridge structs. Run envconfig test using system env vars in separate process

Author: THardy98

core-api/src/envconfig.rs

@@ -1592,15 +1592,31 @@ address = "some-address"
 
     #[test]
     fn test_load_client_config_profile_from_system_env() {
-        // WARNING: This test modifies system environment variables which can cause
-        // test pollution if tests run in parallel.
+        let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+        let output = std::process::Command::new(cargo)
+            .arg("test")
+            .arg("-F")
+            .arg("envconfig")
+            .arg("envconfig::tests::test_load_client_config_profile_from_system_env_impl")
+            .arg("--")
+            .arg("--exact")
+            .arg("--ignored")
+            .env("TEMPORAL_ADDRESS", "system-address")
+            .env("TEMPORAL_NAMESPACE", "system-namespace")
+            .output()
+            .expect("Failed to execute subprocess test");
 
-        // Set up system env vars. These tests can't be run in parallel.
-        unsafe {
-            std::env::set_var("TEMPORAL_ADDRESS", "system-address");
-            std::env::set_var("TEMPORAL_NAMESPACE", "system-namespace");
-        }
+        assert!(
+            output.status.success(),
+            "Subprocess test failed:\nstdout: {}\nstderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr),
+        );
+    }
 
+    #[test]
+    #[ignore] // Only run when explicitly called
+    fn test_load_client_config_profile_from_system_env_impl() {
         let options = LoadClientConfigProfileOptions {
             disable_file: true, // Don't load from any files
             ..Default::default()
@@ -1610,12 +1626,6 @@ address = "some-address"
         let profile = load_client_config_profile(options, None).unwrap();
         assert_eq!(profile.address.as_ref().unwrap(), "system-address");
         assert_eq!(profile.namespace.as_ref().unwrap(), "system-namespace");
-
-        // Clean up
-        unsafe {
-            std::env::remove_var("TEMPORAL_ADDRESS");
-            std::env::remove_var("TEMPORAL_NAMESPACE");
-        }
     }
 
     #[test]

core-c-bridge/include/temporal-sdk-core-c-bridge.h

@@ -247,20 +247,20 @@ typedef void (*TemporalCoreClientRpcCallCallback)(void *user_data,
  * If fail is not null, it contains UTF-8 encoded error message.
  * The returned ByteArrays must be freed by the caller.
  */
-typedef struct TemporalCoreClientConfigOrFail {
+typedef struct TemporalCoreClientEnvConfigOrFail {
   const struct TemporalCoreByteArray *success;
   const struct TemporalCoreByteArray *fail;
-} TemporalCoreClientConfigOrFail;
+} TemporalCoreClientEnvConfigOrFail;
 
 /**
  * Options for loading client configuration.
  */
-typedef struct TemporalCoreClientConfigLoadOptions {
+typedef struct TemporalCoreClientEnvConfigLoadOptions {
   struct TemporalCoreByteArrayRef path;
   struct TemporalCoreByteArrayRef data;
   bool config_file_strict;
   struct TemporalCoreByteArrayRef env_vars;
-} TemporalCoreClientConfigLoadOptions;
+} TemporalCoreClientEnvConfigLoadOptions;
 
 /**
  * OrFail result for client config profile loading operations.
@@ -269,23 +269,23 @@ typedef struct TemporalCoreClientConfigLoadOptions {
  * If fail is not null, it contains UTF-8 encoded error message.
  * The returned ByteArrays must be freed by the caller.
  */
-typedef struct TemporalCoreClientConfigProfileOrFail {
+typedef struct TemporalCoreClientEnvConfigProfileOrFail {
   const struct TemporalCoreByteArray *success;
   const struct TemporalCoreByteArray *fail;
-} TemporalCoreClientConfigProfileOrFail;
+} TemporalCoreClientEnvConfigProfileOrFail;
 
 /**
  * Options for loading a specific client configuration profile.
  */
-typedef struct TemporalCoreClientConfigProfileLoadOptions {
+typedef struct TemporalCoreClientEnvConfigProfileLoadOptions {
   struct TemporalCoreByteArrayRef profile;
   struct TemporalCoreByteArrayRef path;
   struct TemporalCoreByteArrayRef data;
   bool disable_file;
   bool disable_env;
   bool config_file_strict;
   struct TemporalCoreByteArrayRef env_vars;
-} TemporalCoreClientConfigProfileLoadOptions;
+} TemporalCoreClientEnvConfigProfileLoadOptions;
 
 typedef union TemporalCoreMetricAttributeValue {
   struct TemporalCoreByteArrayRef string_value;
@@ -823,14 +823,14 @@ void temporal_core_client_rpc_call(struct TemporalCoreClient *client,
  * Returns ClientConfigOrFail with either success JSON or error message.
  * The returned ByteArrays must be freed by the caller.
  */
-struct TemporalCoreClientConfigOrFail temporal_core_client_config_load(const struct TemporalCoreClientConfigLoadOptions *options);
+struct TemporalCoreClientEnvConfigOrFail temporal_core_client_env_config_load(const struct TemporalCoreClientEnvConfigLoadOptions *options);
 
 /**
  * Load a single client profile from given sources with env overrides.
  * Returns ClientConfigProfileOrFail with either success JSON or error message.
  * The returned ByteArrays must be freed by the caller.
  */
-struct TemporalCoreClientConfigProfileOrFail temporal_core_client_config_profile_load(const struct TemporalCoreClientConfigProfileLoadOptions *options);
+struct TemporalCoreClientEnvConfigProfileOrFail temporal_core_client_env_config_profile_load(const struct TemporalCoreClientEnvConfigProfileLoadOptions *options);
 
 struct TemporalCoreMetricMeter *temporal_core_metric_meter_new(struct TemporalCoreRuntime *runtime);
 

core-c-bridge/src/envconfig.rs

@@ -13,7 +13,7 @@ use temporal_sdk_core_api::envconfig::{
 /// If fail is not null, it contains UTF-8 encoded error message.
 /// The returned ByteArrays must be freed by the caller.
 #[repr(C)]
-pub struct ClientConfigOrFail {
+pub struct ClientEnvConfigOrFail {
     pub success: *const ByteArray,
     pub fail: *const ByteArray,
 }
@@ -24,14 +24,14 @@ pub struct ClientConfigOrFail {
 /// If fail is not null, it contains UTF-8 encoded error message.
 /// The returned ByteArrays must be freed by the caller.
 #[repr(C)]
-pub struct ClientConfigProfileOrFail {
+pub struct ClientEnvConfigProfileOrFail {
     pub success: *const ByteArray,
     pub fail: *const ByteArray,
 }
 
 /// Options for loading client configuration.
 #[repr(C)]
-pub struct ClientConfigLoadOptions {
+pub struct ClientEnvConfigLoadOptions {
     pub path: ByteArrayRef,
     pub data: ByteArrayRef,
     pub config_file_strict: bool,
@@ -40,7 +40,7 @@ pub struct ClientConfigLoadOptions {
 
 /// Options for loading a specific client configuration profile.
 #[repr(C)]
-pub struct ClientConfigProfileLoadOptions {
+pub struct ClientEnvConfigProfileLoadOptions {
     pub profile: ByteArrayRef,
     pub path: ByteArrayRef,
     pub data: ByteArrayRef,
@@ -52,11 +52,11 @@ pub struct ClientConfigProfileLoadOptions {
 
 // Wrapper types for JSON serialization
 #[derive(Serialize)]
-struct ClientConfig {
-    profiles: HashMap<String, ClientConfigProfile>,
+struct ClientEnvConfig {
+    profiles: HashMap<String, ClientEnvConfigProfile>,
 }
 
-impl From<CoreClientConfig> for ClientConfig {
+impl From<CoreClientConfig> for ClientEnvConfig {
     fn from(c: CoreClientConfig) -> Self {
         Self {
             profiles: c.profiles.into_iter().map(|(k, v)| (k, v.into())).collect(),
@@ -65,22 +65,22 @@ impl From<CoreClientConfig> for ClientConfig {
 }
 
 #[derive(Serialize)]
-struct ClientConfigProfile {
+struct ClientEnvConfigProfile {
     #[serde(skip_serializing_if = "Option::is_none")]
     address: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     namespace: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     api_key: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    tls: Option<ClientConfigTLS>,
+    tls: Option<ClientEnvConfigTLS>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    codec: Option<ClientConfigCodec>,
+    codec: Option<ClientEnvConfigCodec>,
     #[serde(skip_serializing_if = "HashMap::is_empty")]
     grpc_meta: HashMap<String, String>,
 }
 
-impl From<CoreClientConfigProfile> for ClientConfigProfile {
+impl From<CoreClientConfigProfile> for ClientEnvConfigProfile {
     fn from(c: CoreClientConfigProfile) -> Self {
         Self {
             address: c.address,
@@ -94,7 +94,7 @@ impl From<CoreClientConfigProfile> for ClientConfigProfile {
 }
 
 #[derive(Serialize)]
-struct ClientConfigTLS {
+struct ClientEnvConfigTLS {
     #[serde(skip_serializing_if = "Option::is_none")]
     disabled: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -107,7 +107,7 @@ struct ClientConfigTLS {
     client_key: Option<DataSource>,
 }
 
-impl From<CoreClientConfigTLS> for ClientConfigTLS {
+impl From<CoreClientConfigTLS> for ClientEnvConfigTLS {
     fn from(c: CoreClientConfigTLS) -> Self {
         Self {
             disabled: c.disabled,
@@ -120,14 +120,14 @@ impl From<CoreClientConfigTLS> for ClientConfigTLS {
 }
 
 #[derive(Serialize)]
-struct ClientConfigCodec {
+struct ClientEnvConfigCodec {
     #[serde(skip_serializing_if = "Option::is_none")]
     endpoint: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     auth: Option<String>,
 }
 
-impl From<CoreClientConfigCodec> for ClientConfigCodec {
+impl From<CoreClientConfigCodec> for ClientEnvConfigCodec {
     fn from(c: CoreClientConfigCodec) -> Self {
         Self {
             endpoint: c.endpoint,
@@ -204,18 +204,18 @@ fn serialize_or_error<T: Serialize>(data: T) -> Result<*const ByteArray, *const
 /// Returns ClientConfigOrFail with either success JSON or error message.
 /// The returned ByteArrays must be freed by the caller.
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_client_config_load(
-    options: *const ClientConfigLoadOptions,
-) -> ClientConfigOrFail {
+pub extern "C" fn temporal_core_client_env_config_load(
+    options: *const ClientEnvConfigLoadOptions,
+) -> ClientEnvConfigOrFail {
     if options.is_null() {
         let err = ByteArray::from_utf8("Options cannot be null".to_string());
-        return ClientConfigOrFail {
+        return ClientEnvConfigOrFail {
             success: std::ptr::null(),
             fail: err.into_raw(),
         };
     }
 
-    let result = || -> Result<ClientConfig, String> {
+    let result = || -> Result<ClientEnvConfig, String> {
         let opts = unsafe { &*options };
         let env_vars_map = parse_env_vars(&opts.env_vars)?;
 
@@ -232,18 +232,18 @@ pub extern "C" fn temporal_core_client_config_load(
 
     match result() {
         Ok(data) => match serialize_or_error(data) {
-            Ok(success) => ClientConfigOrFail {
+            Ok(success) => ClientEnvConfigOrFail {
                 success,
                 fail: std::ptr::null(),
             },
-            Err(fail) => ClientConfigOrFail {
+            Err(fail) => ClientEnvConfigOrFail {
                 success: std::ptr::null(),
                 fail,
             },
         },
         Err(e) => {
             let err = ByteArray::from_utf8(e);
-            ClientConfigOrFail {
+            ClientEnvConfigOrFail {
                 success: std::ptr::null(),
                 fail: err.into_raw(),
             }
@@ -255,18 +255,18 @@ pub extern "C" fn temporal_core_client_config_load(
 /// Returns ClientConfigProfileOrFail with either success JSON or error message.
 /// The returned ByteArrays must be freed by the caller.
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_client_config_profile_load(
-    options: *const ClientConfigProfileLoadOptions,
-) -> ClientConfigProfileOrFail {
+pub extern "C" fn temporal_core_client_env_config_profile_load(
+    options: *const ClientEnvConfigProfileLoadOptions,
+) -> ClientEnvConfigProfileOrFail {
     if options.is_null() {
         let err = ByteArray::from_utf8("Options cannot be null".to_string());
-        return ClientConfigProfileOrFail {
+        return ClientEnvConfigProfileOrFail {
             success: std::ptr::null(),
             fail: err.into_raw(),
         };
     }
 
-    let result = || -> Result<ClientConfigProfile, String> {
+    let result = || -> Result<ClientEnvConfigProfile, String> {
         let opts = unsafe { &*options };
 
         let profile_name = if !opts.profile.data.is_null() && opts.profile.size > 0 {
@@ -294,18 +294,18 @@ pub extern "C" fn temporal_core_client_config_profile_load(
 
     match result() {
         Ok(data) => match serialize_or_error(data) {
-            Ok(success) => ClientConfigProfileOrFail {
+            Ok(success) => ClientEnvConfigProfileOrFail {
                 success,
                 fail: std::ptr::null(),
             },
-            Err(fail) => ClientConfigProfileOrFail {
+            Err(fail) => ClientEnvConfigProfileOrFail {
                 success: std::ptr::null(),
                 fail,
             },
         },
         Err(e) => {
             let err = ByteArray::from_utf8(e);
-            ClientConfigProfileOrFail {
+            ClientEnvConfigProfileOrFail {
                 success: std::ptr::null(),
                 fail: err.into_raw(),
             }