330 lines
14 KiB
Rust
330 lines
14 KiB
Rust
// 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());
|
|
}
|
|
}
|