Feat/1012 intel crash fix (tinyhumansai#1320)

Author: M3gA-Mind

app/src-tauri/src/lib.rs

@@ -1881,6 +1881,12 @@ fn macos_os_version() -> Option<String> {
 mod tests {
     use super::*;
 
+    // Tests that read/write process-global env vars must serialize through this
+    // mutex. Rust's test runner executes tests in parallel by default; without
+    // coordination, concurrent set_var / remove_var calls race and produce
+    // spurious failures.
+    static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
     /// Test that is_daemon_mode correctly detects daemon flag variations
     #[test]
     fn is_daemon_mode_detects_daemon_flag() {
@@ -1892,20 +1898,17 @@ mod tests {
     /// Test core_rpc_url returns expected format
     #[test]
     fn core_rpc_url_returns_expected_format() {
-        // Save original env
+        let _g = ENV_LOCK.lock().unwrap();
         let original = std::env::var("OPENHUMAN_CORE_RPC_URL").ok();
 
-        // Test with env var set
         std::env::set_var("OPENHUMAN_CORE_RPC_URL", "http://localhost:9999/rpc");
         let url = core_rpc_url();
         assert_eq!(url, "http://localhost:9999/rpc");
 
-        // Test fallback when env not set
         std::env::remove_var("OPENHUMAN_CORE_RPC_URL");
         let url = core_rpc_url();
         assert_eq!(url, "http://127.0.0.1:7788/rpc");
 
-        // Restore original
         match original {
             Some(v) => std::env::set_var("OPENHUMAN_CORE_RPC_URL", v),
             None => std::env::remove_var("OPENHUMAN_CORE_RPC_URL"),
@@ -1915,25 +1918,21 @@ mod tests {
     /// Test overlay_parent_rpc_url handles empty env var
     #[test]
     fn overlay_parent_rpc_url_handles_empty() {
-        // Save original env
+        let _g = ENV_LOCK.lock().unwrap();
         let original = std::env::var("OPENHUMAN_CORE_RPC_URL").ok();
 
-        // Test with empty string (should return None)
         std::env::set_var("OPENHUMAN_CORE_RPC_URL", "");
-        let result = overlay_parent_rpc_url();
-        assert!(result.is_none());
+        assert!(overlay_parent_rpc_url().is_none());
 
-        // Test with whitespace only (should return None)
         std::env::set_var("OPENHUMAN_CORE_RPC_URL", "   ");
-        let result = overlay_parent_rpc_url();
-        assert!(result.is_none());
+        assert!(overlay_parent_rpc_url().is_none());
 
-        // Test with valid URL
         std::env::set_var("OPENHUMAN_CORE_RPC_URL", "http://127.0.0.1:7788/rpc");
-        let result = overlay_parent_rpc_url();
-        assert_eq!(result, Some("http://127.0.0.1:7788/rpc".to_string()));
+        assert_eq!(
+            overlay_parent_rpc_url(),
+            Some("http://127.0.0.1:7788/rpc".to_string())
+        );
 
-        // Restore original
         match original {
             Some(v) => std::env::set_var("OPENHUMAN_CORE_RPC_URL", v),
             None => std::env::remove_var("OPENHUMAN_CORE_RPC_URL"),
@@ -1983,4 +1982,219 @@ mod tests {
         //
         // This test passes if the code compiles with these log messages.
     }
+
+    // -------------------------------------------------------------------------
+    // macos_os_version (issue #1012)
+    // -------------------------------------------------------------------------
+
+    /// On macOS, sw_vers is always present and must return a version string.
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_os_version_returns_some() {
+        assert!(
+            macos_os_version().is_some(),
+            "sw_vers -productVersion must succeed on macOS"
+        );
+    }
+
+    /// The returned version must be a non-empty trimmed string.
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_os_version_is_nonempty() {
+        let ver = macos_os_version().expect("sw_vers must return a version on macOS");
+        assert!(!ver.is_empty());
+        // No leading/trailing whitespace (the impl trims).
+        assert_eq!(ver, ver.trim());
+    }
+
+    /// The version string must look like dot-separated integers ("14.5", "13.2.1").
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_os_version_is_dotted_integer_format() {
+        let ver = macos_os_version().expect("sw_vers must return a version on macOS");
+        let all_numeric_parts = ver
+            .split('.')
+            .all(|part| !part.is_empty() && part.chars().all(|c| c.is_ascii_digit()));
+        assert!(
+            all_numeric_parts,
+            "os version {ver:?} must be dot-separated integers (e.g. '14.5')"
+        );
+    }
+
+    /// The version must have at least one component (e.g. a bare major "15" is valid).
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_os_version_has_at_least_one_component() {
+        let ver = macos_os_version().expect("sw_vers must return a version on macOS");
+        assert!(
+            !ver.split('.').next().unwrap_or("").is_empty(),
+            "version must have at least one numeric component"
+        );
+    }
+
+    // -------------------------------------------------------------------------
+    // Platform constants (issue #1012 Sentry tagging)
+    // -------------------------------------------------------------------------
+
+    /// cpu_arch tag is derived from std::env::consts::ARCH which must be non-empty.
+    #[test]
+    fn platform_arch_constant_is_nonempty() {
+        assert!(
+            !std::env::consts::ARCH.is_empty(),
+            "ARCH constant used for Sentry cpu_arch tag must be non-empty"
+        );
+    }
+
+    /// os_name tag is derived from std::env::consts::OS which must be non-empty.
+    #[test]
+    fn platform_os_constant_is_nonempty() {
+        assert!(
+            !std::env::consts::OS.is_empty(),
+            "OS constant used for Sentry os_name tag must be non-empty"
+        );
+    }
+
+    /// On a macOS build the OS constant must equal "macos".
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn platform_os_is_macos_on_macos_build() {
+        assert_eq!(std::env::consts::OS, "macos");
+    }
+
+    /// On an Intel macOS build the ARCH constant must equal "x86_64".
+    /// This is the architecture that triggers --disable-gpu-compositing.
+    #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
+    #[test]
+    fn platform_arch_is_x86_64_on_intel_build() {
+        assert_eq!(std::env::consts::ARCH, "x86_64");
+    }
+
+    /// On Apple Silicon the ARCH constant must equal "aarch64"; the GPU flag
+    /// must NOT be compiled in (verified by this test existing in the binary).
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    #[test]
+    fn platform_arch_is_aarch64_on_apple_silicon_build() {
+        assert_eq!(std::env::consts::ARCH, "aarch64");
+    }
+
+    // -------------------------------------------------------------------------
+    // build_sentry_release_tag
+    // -------------------------------------------------------------------------
+
+    #[test]
+    fn sentry_release_tag_starts_with_openhuman() {
+        let tag = build_sentry_release_tag();
+        assert!(
+            tag.starts_with("openhuman@"),
+            "release tag must start with 'openhuman@', got: {tag:?}"
+        );
+    }
+
+    #[test]
+    fn sentry_release_tag_contains_cargo_pkg_version() {
+        let tag = build_sentry_release_tag();
+        let version = env!("CARGO_PKG_VERSION");
+        assert!(
+            tag.contains(version),
+            "release tag {tag:?} must embed CARGO_PKG_VERSION {version:?}"
+        );
+    }
+
+    #[test]
+    fn sentry_release_tag_version_part_is_nonempty() {
+        let tag = build_sentry_release_tag();
+        let after_prefix = tag.strip_prefix("openhuman@").unwrap_or("");
+        assert!(!after_prefix.is_empty(), "version part must not be empty");
+    }
+
+    /// When a SHA is baked in the tag takes the form `openhuman@<ver>+<sha12>`.
+    /// When it is not, the tag is simply `openhuman@<ver>` with no `+`.
+    /// Either way the full tag must be non-empty.
+    #[test]
+    fn sentry_release_tag_is_nonempty() {
+        assert!(!build_sentry_release_tag().is_empty());
+    }
+
+    // -------------------------------------------------------------------------
+    // resolve_sentry_environment
+    // -------------------------------------------------------------------------
+
+    #[test]
+    fn sentry_environment_reads_openhuman_app_env() {
+        let _g = ENV_LOCK.lock().unwrap();
+        let key = "OPENHUMAN_APP_ENV";
+        let original = std::env::var(key).ok();
+        std::env::set_var(key, "staging");
+        let env = resolve_sentry_environment();
+        match original {
+            Some(v) => std::env::set_var(key, v),
+            None => std::env::remove_var(key),
+        }
+        assert_eq!(env, "staging");
+    }
+
+    #[test]
+    fn sentry_environment_trims_whitespace_from_openhuman_app_env() {
+        let _g = ENV_LOCK.lock().unwrap();
+        let key = "OPENHUMAN_APP_ENV";
+        let original = std::env::var(key).ok();
+        std::env::set_var(key, "  dev  ");
+        let env = resolve_sentry_environment();
+        match original {
+            Some(v) => std::env::set_var(key, v),
+            None => std::env::remove_var(key),
+        }
+        assert_eq!(env, "dev");
+    }
+
+    #[test]
+    fn sentry_environment_skips_empty_openhuman_app_env() {
+        let _g = ENV_LOCK.lock().unwrap();
+        let key = "OPENHUMAN_APP_ENV";
+        let original = std::env::var(key).ok();
+        std::env::set_var(key, "");
+        let env = resolve_sentry_environment();
+        match original {
+            Some(v) => std::env::set_var(key, v),
+            None => std::env::remove_var(key),
+        }
+        // Falls through to VITE_ compile-time value or "production"; must be non-empty.
+        assert!(!env.is_empty());
+    }
+
+    #[test]
+    fn sentry_environment_skips_whitespace_only_openhuman_app_env() {
+        let _g = ENV_LOCK.lock().unwrap();
+        let key = "OPENHUMAN_APP_ENV";
+        let original = std::env::var(key).ok();
+        std::env::set_var(key, "   ");
+        let env = resolve_sentry_environment();
+        match original {
+            Some(v) => std::env::set_var(key, v),
+            None => std::env::remove_var(key),
+        }
+        assert!(!env.is_empty());
+    }
+
+    /// When neither runtime env var nor compile-time VITE_ is set, the fallback
+    /// must be "production". Guard with a compile-time check so this test only
+    /// asserts the hard default when no compile-time override is present.
+    #[test]
+    fn sentry_environment_defaults_to_production_when_unset() {
+        let _g = ENV_LOCK.lock().unwrap();
+        if option_env!("VITE_OPENHUMAN_APP_ENV").is_some() {
+            // A compile-time override is baked in; skip — the fallback path is
+            // exercised by sentry_environment_skips_empty_openhuman_app_env.
+            return;
+        }
+        let key = "OPENHUMAN_APP_ENV";
+        let original = std::env::var(key).ok();
+        std::env::remove_var(key);
+        let env = resolve_sentry_environment();
+        match original {
+            Some(v) => std::env::set_var(key, v),
+            None => std::env::remove_var(key),
+        }
+        assert_eq!(env, "production");
+    }
 }