chore(config): create a replacement for config smoke tests

Add a generated config smoke test in the agent-data-plane-config crate
that mostly replicates the functionality of config_registry smoke tests
(which have to be deleted one-by-one).

Each value that is declared in the overlay as MIGRATED_TO_CONFIG_SYSTEM
will run through a config system smoke test that asserts setting the
key to a non-default value results in a non-default SalukiConfiguration.

Author: webern

Cargo.lock

@@ -19,6 +19,13 @@ saluki-error = { workspace = true }
 serde_json = { workspace = true }
 stringtheory = { workspace = true }
 
+[build-dependencies]
+datadog-agent-config-overlay-model = { workspace = true }
+indexmap = { workspace = true }
+
 [dev-dependencies]
+agent-data-plane-config = { workspace = true }
 figment = { workspace = true }
+saluki-config-tools = { workspace = true }
+serde_json = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt"] }

lib/agent-data-plane-config-system/Cargo.toml

@@ -0,0 +1,111 @@
+use std::fmt::Write as _;
+use std::path::PathBuf;
+
+use datadog_agent_config_overlay_model::schema_gen::{self, FieldInfo, FieldType};
+use datadog_agent_config_overlay_model::smoke_test_support::ConfigurationStruct;
+use datadog_agent_config_overlay_model::{Files, KnownEntry, SchemaOverlay, TestSupport};
+use indexmap::IndexMap;
+
+fn main() {
+    let files = Files::default();
+
+    let schema_dir = files.schema.parent().expect("schema file must have a parent directory");
+    println!("cargo:rerun-if-changed={}", schema_dir.display());
+    println!("cargo:rerun-if-changed={}", files.overlay.display());
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let schema_path = files.schema.clone();
+    let overlay = SchemaOverlay::load(files).unwrap_or_else(|e| panic!("{e}"));
+    let schema_map = schema_gen::load_schema(&schema_path);
+
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    generate_smoke_tests(&overlay, &schema_map, &out_dir);
+}
+
+fn generate_smoke_tests(overlay: &SchemaOverlay, schema_map: &IndexMap<String, FieldInfo>, out_dir: &std::path::Path) {
+    let mut keys: Vec<(&str, &TestSupport, &FieldInfo)> = Vec::new();
+
+    for (yaml_path, entry) in &overlay.inventory {
+        let ts = match entry {
+            KnownEntry::Full(f) => &f.test_support,
+            KnownEntry::Partial(p) => &p.test_support,
+            _ => continue,
+        };
+        if !ts.used_by.contains(&ConfigurationStruct::MigratedToConfigSystem) {
+            continue;
+        }
+        let field_info = schema_map
+            .get(yaml_path.as_str())
+            .unwrap_or_else(|| panic!("MigratedToConfigSystem key '{}' not found in schema", yaml_path));
+        keys.push((yaml_path.as_str(), ts, field_info));
+    }
+
+    keys.sort_by_key(|(path, _, _)| *path);
+
+    let mut out = String::new();
+    writeln!(out, "// @generated by build.rs from schema_overlay.yaml — DO NOT EDIT").unwrap();
+    writeln!(out).unwrap();
+
+    for (yaml_path, ts, field_info) in &keys {
+        let fn_name = yaml_path.replace('.', "_");
+        let test_value = resolve_test_value(yaml_path, ts, field_info);
+
+        writeln!(out, "#[tokio::test]").unwrap();
+        writeln!(out, "async fn smoke_{fn_name}() {{").unwrap();
+        writeln!(out, "    assert_key_propagates(\"{yaml_path}\", {test_value}).await;").unwrap();
+        writeln!(out, "}}").unwrap();
+        writeln!(out).unwrap();
+    }
+
+    let path = out_dir.join("translation_smoke_tests.rs");
+    std::fs::write(&path, out).unwrap_or_else(|e| panic!("cannot write {}: {}", path.display(), e));
+}
+
+fn resolve_test_value(yaml_path: &str, ts: &TestSupport, field_info: &FieldInfo) -> String {
+    if let Some(ref test_json) = ts.test_json {
+        return format_json_literal(test_json);
+    }
+
+    let effective_type = ts
+        .value_type_override
+        .as_ref()
+        .map_or(&field_info.value_type, |vt| match vt {
+            datadog_agent_config_overlay_model::ValueType::Boolean => &FieldType::Bool,
+            datadog_agent_config_overlay_model::ValueType::Integer => &FieldType::Integer,
+            datadog_agent_config_overlay_model::ValueType::Float => &FieldType::Float,
+            datadog_agent_config_overlay_model::ValueType::String => &FieldType::String,
+            datadog_agent_config_overlay_model::ValueType::StringList => &FieldType::StringList,
+        });
+
+    match effective_type {
+        FieldType::Bool => {
+            let default_is_true = field_info
+                .default
+                .as_deref()
+                .map(|d| d.trim() == "true")
+                .unwrap_or(false);
+            if default_is_true {
+                "serde_json::json!(false)".to_string()
+            } else {
+                "serde_json::json!(true)".to_string()
+            }
+        }
+        FieldType::Integer => "serde_json::json!(42i64)".to_string(),
+        FieldType::Float => "serde_json::json!(1.5f64)".to_string(),
+        FieldType::String => "serde_json::json!(\"http://smoke-test.example.com:3128\")".to_string(),
+        FieldType::StringList => {
+            "serde_json::json!([\"smoke-host-1.example.com\", \"smoke-host-2.example.com\"])".to_string()
+        }
+        FieldType::Unknown => {
+            panic!("MigratedToConfigSystem key '{yaml_path}' has unknown type and no test_json override");
+        }
+    }
+}
+
+fn format_json_literal(raw: &str) -> String {
+    if raw.contains('"') {
+        format!("serde_json::from_str::<serde_json::Value>(r#\"{raw}\"#).unwrap()")
+    } else {
+        format!("serde_json::json!({raw})")
+    }
+}

lib/agent-data-plane-config-system/build.rs

@@ -53,3 +53,6 @@ mod system;
 pub(crate) mod translate;
 
 pub use self::system::{ConfigurationSystem, ConfigurationSystemLoader};
+
+#[cfg(test)]
+mod smoke_test;

lib/agent-data-plane-config-system/src/lib.rs

@@ -0,0 +1,50 @@
+//! Tests to verify that changes to keys in a `GenericConfiguration` reach `SalukiConfiguration`.
+//!
+//! Each test checks a single key by setting a non default value in a `GenericConfiguration` map
+//! then running that map through `DatadogConfiguration` deserialization and witness trait
+//! translation. The resulting `SalukiConfiguration` is checked against default construction to
+//! ensure that it's value has been perturbed. This ensures that none of the witness trait function
+//! implementations are inert.
+use saluki_config_tools::ConfigurationLoader;
+use serde_json::json;
+
+use crate::system::ConfigurationSystem;
+
+/// Create a `GenericConfiguration` from the root JSON value.
+async fn generic_from(value: serde_json::Value) -> saluki_config_tools::GenericConfiguration {
+    ConfigurationLoader::default()
+        .add_providers([figment::providers::Serialized::defaults(value)])
+        .into_generic()
+        .await
+        .expect("build generic configuration")
+}
+
+/// Drive deserialization and translation.
+async fn translate_from(value: serde_json::Value) -> agent_data_plane_config::SalukiConfiguration {
+    let config = generic_from(value).await;
+    let system = ConfigurationSystem::load(config)
+        .start()
+        .await
+        .expect("translation must succeed");
+    system.saluki()
+}
+
+/// Check that the `SalukiConfiguration` object is not default constructed after deserialization
+/// and translation.
+async fn assert_key_propagates(yaml_path: &str, test_value: serde_json::Value) {
+    let default = translate_from(json!({})).await;
+
+    // Set up a JSON object holding the test value at our key-path.
+    let mut map = json!({});
+    saluki_config_tools::upsert(&mut map, yaml_path, test_value);
+    let with_value = translate_from(map).await;
+
+    assert_ne!(
+        default, with_value,
+        "key '{}' did not change SalukiConfiguration — \
+         is the test value the same as the default, or is translation not wired?",
+        yaml_path,
+    );
+}
+
+include!(concat!(env!("OUT_DIR"), "/translation_smoke_tests.rs"));