#[cfg(test)]
mod tests {
use std::sync::MutexGuard;
fn isolated() -> MutexGuard<'static, ()> {
let guard = crate::core::context_kernel::kernel_config::KERNEL_TEST_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
crate::core::context_kernel::proxy_bridge::reset_state();
crate::core::context_kernel::mcp_bridge::reset_mcp_state();
guard
}
use super::super::accounting_fix;
use super::super::coverage_class::CoverageClass;
use super::super::hotpath_wiring;
use super::super::identity::CallerRole;
use super::super::proxy_bridge::{self, ProxyRequestData};
use super::super::tool_surface;
fn request_for(user_id: &str) -> ProxyRequestData {
ProxyRequestData {
headers: vec![("x-user-id".to_owned(), user_id.to_owned())],
input_tokens: 1_000,
output_tokens: 200,
tokens_saved: 300,
request_count: 1,
..ProxyRequestData::default()
}
}
#[test]
fn full_proxy_lifecycle() {
let _guard = isolated();
let request = ProxyRequestData {
headers: vec![
("x-user-id".to_owned(), "alice".to_owned()),
("x-team-id".to_owned(), "backend".to_owned()),
],
input_tokens: 1_000,
output_tokens: 200,
tokens_saved: 300,
request_count: 1,
..ProxyRequestData::default()
};
let result = proxy_bridge::process_proxy_request(&request);
assert_eq!(result.identity.user_id.as_deref(), Some("alice"));
assert_eq!(result.identity.role, CallerRole::Developer);
assert_eq!(result.coverage, CoverageClass::FullInline);
assert!(result.is_addressable);
}
#[test]
fn proxy_records_etpao() {
let _guard = isolated();
for _ in 0..5 {
let _ = proxy_bridge::process_proxy_request(&request_for("alice"));
}
assert!(proxy_bridge::current_etpao() > 0.0);
}
#[test]
fn proxy_records_identity_ledger() {
let _guard = isolated();
for _ in 0..3 {
let _ = proxy_bridge::process_proxy_request(&request_for("bob"));
}
assert!(proxy_bridge::identity_summary().total_users >= 1);
}
#[test]
fn tool_optimization_saves_tokens() {
let _guard = isolated();
let schemas = (0..15)
.map(|index| tool_surface::ToolSchema {
name: format!("tool-{index}"),
description: "Conformance test tool".to_owned(),
parameters_json: r#"{"type":"object"}"#.to_owned(),
token_count: 2_000,
priority: 1,
category: tool_surface::ToolCategory::Core,
})
.collect::<Vec<_>>();
let reduction = tool_surface::optimize_for_request(&[], &schemas);
assert!(reduction.tokens_saved > 0);
}
#[test]
fn honest_accounting_detects_phantom() {
let _guard = isolated();
let accounting = accounting_fix::account_proxy_request(1_000, 300, 200, 50);
assert!(accounting.phantom_savings_pct > 0.0);
assert!(accounting_fix::format_proxy_accounting(&accounting).contains("phantom"));
}
#[test]
fn mcp_integration_respects_coverage() {
let _guard = isolated();
let managed = hotpath_wiring::integrate_for_mcp("q", "/tmp", &[], 1_000, 300);
let unmanaged_headers = vec![("x-coverage-class".to_owned(), "unmanaged".to_owned())];
let unmanaged =
hotpath_wiring::integrate_for_mcp("q", "/tmp", &unmanaged_headers, 1_000, 300);
assert_eq!(managed.accounting.original_tokens, 1_000);
assert_eq!(unmanaged.budget_used, 0);
}
#[test]
fn end_to_end_identity_to_etpao() {
let _guard = isolated();
for index in 0..10 {
let user = format!("user-{}", index % 3);
let _ = proxy_bridge::process_proxy_request(&request_for(&user));
}
assert!(proxy_bridge::identity_summary().total_users >= 3);
let summary = proxy_bridge::etpao_summary();
assert!(summary.total_tokens > 0);
assert!(summary.accepted_outcomes > 0);
}
#[test]
fn outcome_signal_integrated() {
let _guard = isolated();
let request = ProxyRequestData {
is_retry: true,
request_count: 3,
..request_for("alice")
};
let result = proxy_bridge::process_proxy_request(&request);
assert_eq!(
result.outcome_signal.outcome,
super::super::types::ReceiptOutcome::Rejected
);
}
}