v0.1.3-pre.012

crates/ksp-config-lib/unit_tests/logging.rs

@@ -0,0 +1,329 @@
+// file: crates/ksp-config-lib/unit_tests/logging.rs
+// version: 1
+
+#[test]
+fn committed_logging_profile_maps_complete_runtime_contract() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let environment = crate::ConfigEnvironment::from_maps(std::collections::BTreeMap::new(), std::collections::BTreeMap::new());
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    assert!(resolved.is_ok(), "committed Logging Config should map");
+    let resolved = match resolved {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(resolved.file_id().as_str(), crate::FILE_ID_STD_LOGGING);
+    assert_eq!(resolved.profile_id(), "local_dev");
+    assert_eq!(resolved.selection_source(), crate::ConfigProfileSelectionSource::DefaultProfile);
+    assert_eq!(resolved.logs_directory(), current_directory().join("logs").as_path());
+    assert_eq!(resolved.effective().value()["logs_directory"], serde_json::Value::String("logs".to_owned()));
+    let settings = resolved.settings();
+    assert_eq!(settings.default_filter(), ksp_logging_lib::LogFilterLevel::Warn);
+    assert_eq!(settings.span_events(), ksp_logging_lib::SpanEvents::NewAndClose);
+    assert_eq!(settings.target_filters().len(), 2);
+    assert_eq!(settings.target_filters()[0].target_prefix(), "ksp-config-lib");
+    assert_eq!(settings.target_filters()[0].level(), ksp_logging_lib::LogFilterLevel::Trace);
+    assert_eq!(settings.target_filters()[1].target_prefix(), "ksp-logging-lib");
+    assert_eq!(settings.target_filters()[1].level(), ksp_logging_lib::LogFilterLevel::Debug);
+    let console = settings.console();
+    assert!(console.is_some(), "committed Logging Config declares console settings");
+    let console = match console {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(console.enabled());
+    assert_eq!(console.output(), ksp_logging_lib::ConsoleOutput::Stderr);
+    assert!(console.ansi());
+    assert_eq!(console.format(), ksp_logging_lib::LogFormat::Compact);
+    assert_eq!(console.filter().level(), ksp_logging_lib::LogFilterLevel::Debug);
+    assert_eq!(console.filter().targets(), &["*".to_owned()]);
+    assert_eq!(console.filter().domains(), &["*".to_owned()]);
+    assert_eq!(settings.files().len(), 2);
+    assert_file(
+        &settings.files()[0],
+        "file.all.debug",
+        current_directory().join("logs/debug").as_path(),
+        "ksp-debug.log",
+        ksp_logging_lib::FileRotation::Daily,
+        ksp_logging_lib::LogFormat::Human,
+        ksp_logging_lib::LogFilterLevel::Debug,
+        &["*"],
+        &["*"],
+    );
+    assert_file(
+        &settings.files()[1],
+        "file.config.error",
+        current_directory().join("logs/config").as_path(),
+        "ksp-config-errors.jsonl",
+        ksp_logging_lib::FileRotation::Daily,
+        ksp_logging_lib::LogFormat::Json,
+        ksp_logging_lib::LogFilterLevel::Error,
+        &["ksp-config-lib"],
+        &["config"],
+    );
+}
+
+#[test]
+fn relative_logs_directory_is_anchored_to_process_current_directory() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let environment = environment_with_logs_directory("relative-ksp-logs");
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    assert!(resolved.is_ok(), "relative Logging root should map");
+    if let std::result::Result::Ok(resolved) = resolved {
+        assert_eq!(resolved.logs_directory(), current_directory().join("relative-ksp-logs").as_path());
+        assert_eq!(resolved.settings().files()[0].directory(), current_directory().join("relative-ksp-logs/debug").as_path());
+    }
+}
+
+#[test]
+fn absolute_logs_directory_is_preserved() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let absolute = std::env::temp_dir().join(format!("ksp-pre012-absolute-{}", std::process::id()));
+    let environment = environment_with_logs_directory(absolute.to_string_lossy().as_ref());
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    assert!(resolved.is_ok(), "absolute Logging root should map even when it does not exist yet");
+    if let std::result::Result::Ok(resolved) = resolved {
+        assert_eq!(resolved.logs_directory(), absolute.as_path());
+    }
+}
+
+#[test]
+fn effective_file_paths_cannot_escape_logging_root() {
+    assert!(super::relative_file_path_is_valid("debug/ksp.log"));
+    assert!(super::relative_file_path_is_valid("ksp.log"));
+    assert!(!super::relative_file_path_is_valid("../ksp.log"));
+    assert!(!super::relative_file_path_is_valid("./ksp.log"));
+    assert!(!super::relative_file_path_is_valid("/var/log/ksp.log"));
+}
+
+#[test]
+fn explicit_empty_logs_directory_is_invalid_instead_of_using_fallback() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let environment = environment_with_logs_directory("");
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    let error = match resolved {
+        std::result::Result::Ok(_) => return,
+        std::result::Result::Err(error) => error,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_EFFECTIVE_CONFIG_INVALID);
+    assert!(error.context().iter().any(|item| -> bool {
+        return item.key() == "field" && item.value() == "logs_directory";
+    }));
+}
+
+#[test]
+fn existing_non_directory_logging_root_is_rejected_without_secret_leak() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let secret = format!("ksp-secret-path-canary-{}", std::process::id());
+    let path = std::env::temp_dir().join(secret.as_str());
+    let write = std::fs::write(path.as_path(), b"not a directory");
+    assert!(write.is_ok(), "secret canary file should be created");
+    let profile = load_committed_profile(&engine);
+    let profile = match profile {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => {
+            cleanup_file(path.as_path());
+            return;
+        },
+    };
+    let resolved = super::resolve_logs_directory(path.to_string_lossy().as_ref(), crate::REDACTED_CONFIG_VALUE, &profile);
+    cleanup_file(path.as_path());
+    let error = match resolved {
+        std::result::Result::Ok(_) => return,
+        std::result::Result::Err(error) => error,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_EFFECTIVE_CONFIG_INVALID);
+    let debug = format!("{error:?}");
+    assert!(!debug.contains(secret.as_str()), "effective Config diagnostics must not reveal real secret-derived paths");
+    assert!(debug.contains(crate::REDACTED_CONFIG_VALUE));
+}
+
+#[test]
+fn logging_adapter_rejects_secret_effective_values_without_exposing_canary() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let profile = load_committed_profile(&engine);
+    let profile = match profile {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let canary = "ksp-pre012-secret-canary-c3e4";
+    let mut process = std::collections::BTreeMap::<String, String>::new();
+    process.insert("KSP_SECRET_LOGGING_CANARY".to_owned(), canary.to_owned());
+    let environment = crate::ConfigEnvironment::from_maps(process, std::collections::BTreeMap::new());
+    let effective = environment.resolve_json_detailed(&serde_json::json!({"canary": "${KSP_SECRET_LOGGING_CANARY}"}));
+    assert!(effective.is_ok(), "secret canary fixture should resolve");
+    let effective = match effective {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let validation = super::validate_logging_sensitivity(&profile, &effective);
+    let error = match validation {
+        std::result::Result::Ok(()) => return,
+        std::result::Result::Err(error) => error,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_EFFECTIVE_CONFIG_INVALID);
+    let debug = format!("{error:?}");
+    assert!(!debug.contains(canary), "Logging adapter diagnostics must not reveal secret canaries");
+}
+
+#[test]
+fn mapped_logging_settings_can_initialize_and_reinitialize_runtime() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let root = std::env::temp_dir().join(format!("ksp-pre012-runtime-{}", std::process::id()));
+    cleanup_directory(root.as_path());
+    let environment = environment_with_logs_directory(root.to_string_lossy().as_ref());
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    assert!(resolved.is_ok(), "runtime Logging Config should map");
+    let resolved = match resolved {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let guard = ksp_logging_lib::initialize(resolved.settings());
+    assert!(guard.is_ok(), "mapped Logging settings should initialize the Logging runtime");
+    let mut guard = match guard {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert!(root.join("debug").is_dir(), "Logging initialization should create the first configured file directory");
+    assert!(root.join("config").is_dir(), "Logging initialization should create the second configured file directory");
+    let reload = ksp_logging_lib::reinitialize(&mut guard, resolved.settings());
+    assert!(reload.is_ok(), "mapped Logging settings should support hot reload");
+    let disabled = ksp_logging_lib::LoggingSettings::new(
+        ksp_logging_lib::LogFilterLevel::Off,
+        ksp_logging_lib::SpanEvents::Off,
+        std::option::Option::None,
+        std::vec::Vec::new(),
+    );
+    let disable = ksp_logging_lib::reinitialize(&mut guard, &disabled);
+    assert!(disable.is_ok(), "test Logging runtime should disable outputs before cleanup");
+    drop(guard);
+    cleanup_directory(root.as_path());
+}
+
+#[test]
+fn resolved_logging_debug_uses_safe_effective_view() {
+    let engine = committed_engine();
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let root = std::env::temp_dir().join(format!("ksp-pre012-debug-{}", std::process::id()));
+    let environment = environment_with_logs_directory(root.to_string_lossy().as_ref());
+    let resolved = engine.load_resolved_logging_config(std::option::Option::None, &environment);
+    assert!(resolved.is_ok(), "Logging Config should map for Debug contract");
+    if let std::result::Result::Ok(resolved) = resolved {
+        let debug = format!("{resolved:?}");
+        assert!(debug.contains("ResolvedLoggingConfig"));
+        assert!(debug.contains("effective"));
+    }
+}
+
+fn assert_file(
+    file: &ksp_logging_lib::FileSettings,
+    output_id: &str,
+    directory: &std::path::Path,
+    file_name: &str,
+    rotation: ksp_logging_lib::FileRotation,
+    format: ksp_logging_lib::LogFormat,
+    level: ksp_logging_lib::LogFilterLevel,
+    targets: &[&str],
+    domains: &[&str],
+) {
+    assert_eq!(file.output_id(), output_id);
+    assert!(file.enabled());
+    assert_eq!(file.directory(), directory);
+    assert_eq!(file.file_name_prefix(), file_name);
+    assert_eq!(file.rotation(), rotation);
+    assert_eq!(file.format(), format);
+    assert!(!file.ansi());
+    assert_eq!(file.filter().level(), level);
+    assert_eq!(file.filter().targets().iter().map(String::as_str).collect::<std::vec::Vec<&str>>(), targets.to_vec());
+    assert_eq!(file.filter().domains().iter().map(String::as_str).collect::<std::vec::Vec<&str>>(), domains.to_vec());
+}
+
+fn committed_engine() -> ksp_core_lib::Result<crate::ConfigDocumentEngine> {
+    let workspace = workspace_root();
+    let bootstrap = crate::ConfigBootstrapOptions::from_paths(workspace.join("config"), workspace.join("config/schemas"));
+    let bootstrap = match bootstrap {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let registry = crate::ConfigFileRegistry::defaults();
+    let registry = match registry {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok(crate::ConfigDocumentEngine::new(bootstrap, registry));
+}
+
+fn load_committed_profile(engine: &crate::ConfigDocumentEngine) -> ksp_core_lib::Result<crate::ResolvedConfigProfile> {
+    let file_id = crate::ConfigFileId::new(crate::FILE_ID_STD_LOGGING);
+    let file_id = match file_id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return engine.load_resolved_profile(&file_id, std::option::Option::None);
+}
+
+fn environment_with_logs_directory(value: &str) -> crate::ConfigEnvironment {
+    let mut process = std::collections::BTreeMap::<String, String>::new();
+    process.insert("KSP_LOGS_DIRECTORY".to_owned(), value.to_owned());
+    return crate::ConfigEnvironment::from_maps(process, std::collections::BTreeMap::new());
+}
+
+fn workspace_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
+}
+
+fn current_directory() -> std::path::PathBuf {
+    let current = std::env::current_dir();
+    return match current {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => std::path::PathBuf::new(),
+    };
+}
+
+fn cleanup_file(path: &std::path::Path) {
+    let removal = std::fs::remove_file(path);
+    if let std::result::Result::Err(error) = removal
+        && error.kind() != std::io::ErrorKind::NotFound
+    {
+        eprintln!("unable to cleanup Config Logging adapter file {}: {error}", path.display());
+    }
+}
+
+fn cleanup_directory(path: &std::path::Path) {
+    let removal = std::fs::remove_dir_all(path);
+    if let std::result::Result::Err(error) = removal
+        && error.kind() != std::io::ErrorKind::NotFound
+    {
+        eprintln!("unable to cleanup Config Logging adapter directory {}: {error}", path.display());
+    }
+}