test(response-cache): cover cache failure paths

Signed-off-by: Zhongxuan Wang <daniewang@nvidia.com>

Author: zhongxuanwang-nv

codecov.yml

@@ -49,7 +49,7 @@ component_management:
         - "crates/adaptive/src"
       statuses:
         - type: project
-          target: auto
+          target: 95%
           threshold: 0.5%
           base: auto
           if_ci_failed: error

crates/adaptive/tests/integration/response_cache_tests.rs

@@ -25,7 +25,8 @@ use nemo_relay::api::subscriber::{deregister_subscriber, flush_subscribers, regi
 use nemo_relay::api::tool::{ToolCallExecuteParams, tool_call_execute};
 use nemo_relay::error::FlowError;
 use nemo_relay::plugin::{
-    PluginConfig, clear_plugin_configuration, initialize_plugins_exact, validate_plugin_config,
+    DiagnosticLevel, PluginConfig, clear_plugin_configuration, initialize_plugins_exact,
+    validate_plugin_config,
 };
 use nemo_relay_adaptive::plugin_component::{ComponentSpec, register_adaptive_component};
 use nemo_relay_adaptive::{
@@ -551,6 +552,7 @@ async fn invalid_config_is_rejected_by_validation() {
         response_cache: Some(ResponseCacheConfig {
             ttl_seconds: 0,
             bypass_rate: 2.0,
+            key_strategy: "semantic".to_string(),
             namespace: "invalid-config-test".to_string(),
             ..ResponseCacheConfig::default()
         }),
@@ -575,6 +577,13 @@ async fn invalid_config_is_rejected_by_validation() {
             .any(|diagnostic| diagnostic.code == "response_cache.invalid_bypass_rate"),
         "bypass_rate out of range must produce a diagnostic"
     );
+    assert!(
+        report
+            .diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.code == "response_cache.unsupported_key_strategy"),
+        "an unsupported key strategy must produce a diagnostic"
+    );
 }
 
 #[tokio::test]
@@ -627,6 +636,81 @@ async fn unknown_and_unavailable_backends_are_rejected_by_validation() {
     }
 }
 
+#[tokio::test]
+async fn response_cache_validation_diagnostics_identify_the_invalid_setting() {
+    let _guard = TEST_MUTEX.lock().await;
+    reset_global();
+    register_adaptive_component().unwrap();
+
+    let mut cache = ResponseCacheConfig {
+        namespace: "diagnostic-contract-test".to_string(),
+        key_strategy: "semantic".to_string(),
+        tools: Some(ToolCacheConfig {
+            enabled: true,
+            default: ToolClass {
+                bypass_rate: Some(-0.01),
+                ..ToolClass::default()
+            },
+            ..ToolCacheConfig::default()
+        }),
+        ..ResponseCacheConfig::default()
+    };
+    cache.backend.kind = "redis".to_string();
+
+    let report = validate_plugin_config(&PluginConfig {
+        components: vec![
+            ComponentSpec::new(AdaptiveConfig {
+                response_cache: Some(cache),
+                ..AdaptiveConfig::default()
+            })
+            .into(),
+        ],
+        ..PluginConfig::default()
+    });
+
+    assert!(
+        report.diagnostics.iter().any(|diagnostic| {
+            diagnostic.code == "response_cache.unsupported_key_strategy"
+                && diagnostic.level == DiagnosticLevel::Error
+                && diagnostic.component.as_deref() == Some("response_cache")
+                && diagnostic.field.as_deref() == Some("key_strategy")
+        }),
+        "an unsupported key strategy must identify its setting: {:?}",
+        report.diagnostics
+    );
+    assert!(
+        report.diagnostics.iter().any(|diagnostic| {
+            diagnostic.code == "response_cache.tool_invalid_bypass_rate"
+                && diagnostic.level == DiagnosticLevel::Error
+                && diagnostic.field.as_deref() == Some("tools")
+        }),
+        "an invalid tool bypass rate must identify the tools section: {:?}",
+        report.diagnostics
+    );
+
+    #[cfg(not(feature = "redis-backend"))]
+    assert!(
+        report.diagnostics.iter().any(|diagnostic| {
+            diagnostic.code == "response_cache.backend_unavailable"
+                && diagnostic.level == DiagnosticLevel::Error
+                && diagnostic.field.as_deref() == Some("backend.kind")
+        }),
+        "redis must be rejected when its backend feature is not compiled: {:?}",
+        report.diagnostics
+    );
+
+    #[cfg(feature = "redis-backend")]
+    assert!(
+        report.diagnostics.iter().any(|diagnostic| {
+            diagnostic.code == "response_cache.missing_redis_url"
+                && diagnostic.level == DiagnosticLevel::Error
+                && diagnostic.field.as_deref() == Some("backend.config.url")
+        }),
+        "redis must identify a missing connection URL when its backend feature is compiled: {:?}",
+        report.diagnostics
+    );
+}
+
 #[tokio::test]
 async fn hit_preserves_usage_on_the_end_event_and_reports_savings_on_the_mark() {
     let _guard = TEST_MUTEX.lock().await;
@@ -2205,10 +2289,19 @@ async fn invalid_tool_config_is_rejected_by_validation() {
         ToolClass {
             cacheable: true,
             ttl_seconds: Some(0),
+            bypass_rate: Some(1.1),
             members: vec!["dup".to_string()],
             ..ToolClass::default()
         },
     );
+    let mut overrides = std::collections::BTreeMap::new();
+    overrides.insert(
+        "docs_lookup".to_string(),
+        ToolOverride {
+            bypass_rate: Some(-0.1),
+            ..ToolOverride::default()
+        },
+    );
     let adaptive = AdaptiveConfig {
         response_cache: Some(cache_with_tools(ToolCacheConfig {
             enabled: true,
@@ -2217,6 +2310,7 @@ async fn invalid_tool_config_is_rejected_by_validation() {
                 ..ToolClass::default()
             },
             classes,
+            overrides,
             ..ToolCacheConfig::default()
         })),
         ..AdaptiveConfig::default()
@@ -2242,6 +2336,14 @@ async fn invalid_tool_config_is_rejected_by_validation() {
         "a zero class TTL must be rejected: {:?}",
         report.diagnostics
     );
+    assert!(
+        report
+            .diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.code == "response_cache.tool_invalid_bypass_rate"),
+        "out-of-range class and override bypass rates must be rejected: {:?}",
+        report.diagnostics
+    );
     assert!(
         report
             .diagnostics

crates/adaptive/tests/unit/cache_diagnostics_tests.rs

@@ -232,6 +232,34 @@ fn cache_request_facts_keeps_missing_facts_bounded_when_inputs_are_unavailable()
     assert_eq!(facts.stable_prefix_tokens, None);
 }
 
+#[test]
+fn cache_request_facts_rejects_a_truncated_stable_prefix() {
+    let hot_cache = make_hot_cache(Some(2));
+    let mut tracker = CacheDiagnosticsTracker::default();
+    let prompt_ir = make_prompt_ir(vec![("system-0", "You are a careful planner", Some(700))]);
+
+    let facts = build_cache_request_facts_from_prompt_ir(
+        CacheFactsBuildInput {
+            agent_id: "agent-1",
+            provider: "openai",
+            model: Some("gpt-4o"),
+            prompt_ir: &prompt_ir,
+            hot_cache: &hot_cache,
+            profile_key: "test-profile",
+            now: sample_timestamp(),
+        },
+        &mut tracker,
+    );
+
+    assert_eq!(facts.stable_prefix_length, 2);
+    assert_eq!(facts.stable_prefix_tokens, None);
+    assert!(
+        facts
+            .missing_facts
+            .contains(&"stable_prefix_tokens_unavailable".to_string())
+    );
+}
+
 #[test]
 fn cache_request_facts_populates_provider_thresholds_and_retention_defaults() {
     let hot_cache = make_hot_cache(Some(2));

crates/adaptive/tests/unit/config_tests.rs

@@ -39,6 +39,36 @@ fn test_backend_spec_in_memory_helper_uses_empty_config() {
     let backend = BackendSpec::in_memory();
     assert_eq!(backend.kind, "in_memory");
     assert!(backend.config.is_empty());
+
+    let default_backend = BackendSpec::default();
+    assert_eq!(default_backend.kind, "in_memory");
+    assert!(default_backend.config.is_empty());
+}
+
+#[cfg(not(feature = "redis-backend"))]
+#[test]
+fn test_response_cache_redis_backend_requires_the_redis_feature() {
+    let mut response_cache = ResponseCacheConfig {
+        namespace: "cache-tests".to_string(),
+        ..ResponseCacheConfig::default()
+    };
+    response_cache.backend.kind = "redis".to_string();
+    response_cache
+        .backend
+        .config
+        .insert("url".to_string(), json!("redis://127.0.0.1/"));
+
+    let report = crate::runtime::features::AdaptiveRuntime::validate_config(&AdaptiveConfig {
+        response_cache: Some(response_cache),
+        ..AdaptiveConfig::default()
+    });
+
+    assert!(
+        report
+            .diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.code == "response_cache.backend_unavailable")
+    );
 }
 
 #[cfg(feature = "redis-backend")]

crates/adaptive/tests/unit/plugin_component_tests.rs

@@ -371,6 +371,42 @@ fn validate_adaptive_plugin_config_reports_component_specific_unknown_fields() {
     }));
 }
 
+#[test]
+fn response_cache_tool_policy_validation_checks_nested_classes_and_overrides() {
+    let config = json!({
+        "version": 1,
+        "response_cache": {
+            "tools": {
+                "default": {"unexpected_default": true},
+                "classes": {
+                    "read_only": {"unexpected_class": true}
+                },
+                "overrides": {
+                    "docs_lookup": {"unexpected_override": true}
+                }
+            }
+        },
+        "policy": {"unknown_field": "warn"}
+    });
+
+    let diagnostics = validate_adaptive_plugin_config(config.as_object().unwrap());
+    for (component, field) in [
+        ("response_cache.tools.default", "unexpected_default"),
+        ("response_cache.tools.classes.read_only", "unexpected_class"),
+        (
+            "response_cache.tools.overrides.docs_lookup",
+            "unexpected_override",
+        ),
+    ] {
+        assert!(diagnostics.iter().any(|diagnostic| {
+            diagnostic.code == "adaptive.unknown_field"
+                && diagnostic.component.as_deref() == Some(component)
+                && diagnostic.field.as_deref() == Some(field)
+                && diagnostic.level == DiagnosticLevel::Warning
+        }));
+    }
+}
+
 #[tokio::test(flavor = "current_thread")]
 async fn adaptive_plugin_registers_runtime_and_rolls_back_registration() {
     let _guard = crate::TEST_GLOBAL_CONTEXT_MUTEX.lock().await;