lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

tests.rs (4550B)

      1 use super::{
      2     current_path_resolver, default_log_file_name, default_log_file_name_from_exe_name,
      3     default_shared_runtime_logs_dir, default_shared_runtime_logs_dir_for, env_value, init,
      4     init_with_logs_dir, log_name_from_path, log_name_from_stem, normalize_env_value,
      5     resolve_default_level, test_hooks,
      6 };
      7 use radroots_runtime_paths::{
      8     RadrootsHostEnvironment, RadrootsPathOverrides, RadrootsPathProfile, RadrootsPathResolver,
      9     RadrootsPlatform,
     10 };
     11 use std::path::PathBuf;
     12 use tempfile::tempdir;
     13 
     14 #[test]
     15 fn normalize_env_value_handles_empty_and_non_empty_values() {
     16     assert_eq!(normalize_env_value(" value "), Some("value".to_string()));
     17     assert_eq!(normalize_env_value("   "), None);
     18     assert_eq!(normalize_env_value(""), None);
     19 }
     20 
     21 #[test]
     22 fn env_helpers_return_expected_values() {
     23     assert_eq!(env_value("RADROOTS_RUNTIME_TEST_MISSING_KEY"), None);
     24     let home = env_value("HOME").expect("home env");
     25     assert!(!home.is_empty());
     26 }
     27 
     28 #[test]
     29 fn log_name_helpers_cover_empty_and_non_empty_names() {
     30     assert_eq!(
     31         log_name_from_stem("radrootsd"),
     32         Some("radrootsd.log".to_string())
     33     );
     34     assert_eq!(log_name_from_stem(""), None);
     35 }
     36 
     37 #[test]
     38 fn log_name_from_path_handles_missing_components() {
     39     assert_eq!(log_name_from_path(None), None);
     40     assert_eq!(log_name_from_path(Some(PathBuf::from("/"))), None);
     41     assert_eq!(
     42         log_name_from_path(Some(PathBuf::from("/tmp/radrootsd"))),
     43         Some("radrootsd.log".to_string())
     44     );
     45 }
     46 
     47 #[test]
     48 fn default_log_file_name_helpers_cover_fallback() {
     49     assert_eq!(
     50         default_log_file_name_from_exe_name(Some("svc.log".to_string())),
     51         "svc.log"
     52     );
     53     assert_eq!(
     54         default_log_file_name_from_exe_name(None),
     55         format!("{}.log", env!("CARGO_PKG_NAME"))
     56     );
     57     assert!(!default_log_file_name().trim().is_empty());
     58 }
     59 
     60 #[test]
     61 fn resolve_default_level_prefers_env_then_fallback() {
     62     let env_value = resolve_default_level(Some("warn".to_string()), Some("info"));
     63     assert_eq!(env_value, Some("warn".to_string()));
     64     let fallback = resolve_default_level(None, Some("info"));
     65     assert_eq!(fallback, Some("info".to_string()));
     66     let none = resolve_default_level(None, None);
     67     assert_eq!(none, None);
     68 }
     69 
     70 #[test]
     71 fn default_shared_runtime_logs_dir_uses_shared_namespace() {
     72     let resolver = RadrootsPathResolver::new(
     73         RadrootsPlatform::Macos,
     74         RadrootsHostEnvironment {
     75             home_dir: Some(PathBuf::from("/Users/treesap")),
     76             ..RadrootsHostEnvironment::default()
     77         },
     78     );
     79 
     80     let logs_dir = default_shared_runtime_logs_dir_for(
     81         &resolver,
     82         RadrootsPathProfile::InteractiveUser,
     83         &RadrootsPathOverrides::default(),
     84     )
     85     .expect("default shared runtime logs dir should resolve");
     86 
     87     assert_eq!(
     88         logs_dir,
     89         PathBuf::from("/Users/treesap/.radroots/logs/shared/runtime")
     90     );
     91 }
     92 
     93 #[test]
     94 fn default_shared_runtime_logs_dir_and_init_use_current_resolver() {
     95     let dir = tempdir().expect("tempdir");
     96     let resolver = RadrootsPathResolver::new(
     97         RadrootsPlatform::Linux,
     98         RadrootsHostEnvironment {
     99             home_dir: Some(dir.path().to_path_buf()),
    100             ..RadrootsHostEnvironment::default()
    101         },
    102     );
    103 
    104     test_hooks::set_current_resolver(Some(resolver));
    105     test_hooks::set_ignore_env(true);
    106 
    107     let logs_dir = default_shared_runtime_logs_dir().expect("default shared runtime logs dir");
    108     assert_eq!(logs_dir, dir.path().join(".radroots/logs/shared/runtime"));
    109 
    110     let _ = init();
    111 
    112     test_hooks::set_ignore_env(false);
    113     test_hooks::set_current_resolver(None);
    114 }
    115 
    116 #[test]
    117 fn current_path_resolver_falls_back_when_no_override_is_set() {
    118     test_hooks::set_current_resolver(None);
    119     let expected = format!("{:?}", RadrootsPathResolver::current());
    120     let actual = format!("{:?}", current_path_resolver());
    121     assert_eq!(actual, expected);
    122 }
    123 
    124 #[test]
    125 fn init_paths_execute() {
    126     let dir = tempdir().expect("tempdir");
    127     test_hooks::set_ignore_env(true);
    128     let invalid = dir.path().join("not-a-dir");
    129     std::fs::write(&invalid, "file").expect("write invalid path");
    130     let _ = init_with_logs_dir(invalid.as_path(), Some("info"));
    131     let invalid_str = invalid.to_string_lossy().to_string();
    132     let _ = init_with_logs_dir(invalid_str.as_str(), Some("info"));
    133     let _ = init_with_logs_dir(dir.path(), Some("info"));
    134     let owned_path = dir.path().to_path_buf();
    135     let _ = init_with_logs_dir(owned_path.as_path(), None);
    136     test_hooks::set_ignore_env(false);
    137 }