lean-ctx 3.9.15

#[cfg(test)]
mod tests {
    use std::sync::MutexGuard;

    use super::super::dedup_wiring::{self, DedupAction};
    use super::super::envelope_wiring;
    use super::super::kernel_config::{self, KernelFeatures};
    use super::super::live_dashboard;
    use super::super::mcp_bridge::{self, McpCallData};
    use super::super::proxy_bridge::{self, ProxyRequestData};
    use super::super::receipt_chain;
    use super::super::schema_wiring;
    use super::super::usage_normalizer;

    fn reset_all() -> MutexGuard<'static, ()> {
        let guard = crate::core::context_kernel::kernel_config::KERNEL_TEST_LOCK
            .lock()
            .unwrap_or_else(std::sync::PoisonError::into_inner);
        kernel_config::reset_features();
        proxy_bridge::reset_state();
        mcp_bridge::reset_mcp_state();
        usage_normalizer::reset_usage();
        receipt_chain::reset_chain();
        dedup_wiring::reset_dedup();
        schema_wiring::reset_schema_state();
        guard
    }

    fn proxy_request(index: usize) -> ProxyRequestData {
        ProxyRequestData {
            headers: vec![("x-user-id".to_owned(), format!("activation-{index}"))],
            input_tokens: 100 + index,
            output_tokens: 20,
            reasoning_tokens: 5,
            tokens_saved: 30,
            model: Some("gpt-5".to_owned()),
            provider: Some("openai".to_owned()),
            request_count: 1,
            ..ProxyRequestData::default()
        }
    }

    fn mcp_call(index: usize) -> McpCallData {
        McpCallData {
            tool_name: format!("ctx_tool_{index}"),
            input_tokens: 60 + index,
            output_tokens: 10,
            call_number: index + 1,
            ..McpCallData::default()
        }
    }

    fn process_proxy_requests(count: usize) {
        for index in 0..count {
            let data = proxy_request(index);
            let result = proxy_bridge::process_proxy_request(&data);
            envelope_wiring::process_proxy_evidence(&data, &result);
        }
    }

    fn mixed_requests(count: usize) {
        for index in 0..count {
            if index % 2 == 0 {
                let data = proxy_request(index);
                let result = proxy_bridge::process_proxy_request(&data);
                envelope_wiring::process_proxy_evidence(&data, &result);
            } else {
                envelope_wiring::process_mcp_evidence(&mcp_call(index));
            }
        }
    }

    fn schemas() -> Vec<(String, String, usize)> {
        (0..15)
            .map(|index| {
                (
                    format!("tool_{index}"),
                    format!(
                        "Tool {index} provides detailed contextual analysis. {}",
                        "This deliberately verbose schema description exercises budget reduction. "
                            .repeat(60)
                    ),
                    8,
                )
            })
            .collect()
    }

    #[test]
    fn full_kernel_activation_pipeline() {
        let _guard = reset_all();

        process_proxy_requests(3);
        for index in 0..2 {
            envelope_wiring::process_mcp_evidence(&mcp_call(index));
        }

        assert!(usage_normalizer::session_usage().total_requests >= 5);
        assert!(receipt_chain::chain_length() >= 5);
        assert!(live_dashboard::snapshot().usage.total_requests >= 5);
    }

    #[test]
    fn kernel_disabled_no_recording() {
        let _guard = reset_all();
        let features = KernelFeatures {
            enabled: false,
            ..KernelFeatures::default()
        };
        kernel_config::update_features(features);

        process_proxy_requests(5);

        assert_eq!(usage_normalizer::session_usage().total_requests, 0);
        assert_eq!(receipt_chain::chain_length(), 0);
    }

    #[test]
    fn schema_optimization_pipeline() {
        let _guard = reset_all();
        let entries = schemas();

        let cursor = schema_wiring::optimize_tool_list(&entries, "cursor");
        let unknown = schema_wiring::optimize_tool_list(&entries, "unknown");

        assert!(cursor.tokens_after < cursor.tokens_before);
        assert!(unknown.tokens_after < unknown.tokens_before);
        assert!(cursor.tokens_after > unknown.tokens_after);
    }

    #[test]
    fn dedup_pipeline() {
        let _guard = reset_all();

        assert_eq!(
            dedup_wiring::check_content("file.rs", "fn main() {}", false),
            DedupAction::DeliverFull
        );
        assert!(matches!(
            dedup_wiring::check_content("file.rs", "fn main() {}", false),
            DedupAction::DeliverStub { .. }
        ));
        assert!(matches!(
            dedup_wiring::check_content("file.rs", "fn main() { work(); }", false),
            DedupAction::DeliverModified | DedupAction::DeliverFull
        ));
        assert!(dedup_wiring::dedup_stats().hit_rate > 0.0);
    }

    #[test]
    fn selective_feature_disable() {
        let _guard = reset_all();
        let features = KernelFeatures {
            receipt_chain: false,
            ..KernelFeatures::default()
        };
        kernel_config::update_features(features);

        process_proxy_requests(3);

        assert_eq!(usage_normalizer::session_usage().total_requests, 3);
        assert_eq!(receipt_chain::chain_length(), 0);
    }

    #[test]
    fn evidence_summary_matches_dashboard() {
        let _guard = reset_all();
        mixed_requests(10);

        let evidence = envelope_wiring::evidence_summary();
        let dashboard = live_dashboard::snapshot();
        assert_eq!(evidence.total_envelopes, dashboard.usage.total_requests);
    }

    #[test]
    fn config_max_budget_respected() {
        let _guard = reset_all();
        let features = KernelFeatures {
            max_kernel_budget: 50,
            ..KernelFeatures::default()
        };
        kernel_config::update_features(features);

        assert_eq!(kernel_config::features().max_kernel_budget, 50);
    }

    #[test]
    fn dedup_disabled_always_full() {
        let _guard = reset_all();
        let features = KernelFeatures {
            content_dedup: false,
            ..KernelFeatures::default()
        };
        kernel_config::update_features(features);

        for _ in 0..10 {
            assert_eq!(
                dedup_wiring::check_content("file.rs", "fn main() {}", false),
                DedupAction::DeliverFull
            );
        }
        assert_eq!(dedup_wiring::dedup_stats().cache_hits, 0);
    }
}