#![cfg(feature = "server")]
use std::net::SocketAddr;
use std::sync::Arc;
use parking_lot::Mutex;
use symforge::live_index::LiveIndex;
use symforge::protocol::SymForgeServer;
use symforge::server::{
AuthConfig, AuthLayerState, OriginLayerState, ServerRuntime, admin::build_admin_router,
apply_bearer_auth, apply_origin_gate,
};
use symforge::sidecar::governor::RequestGovernor;
use symforge::stel::ledger_store::StelLedgerStore;
use symforge::stel::types::{AdmissionDecision, IntentBucket, RouteConfidence, StelLedgerEvent};
use symforge::watcher::WatcherInfo;
fn seeded_ledger(net_each: i32, n: u64) -> StelLedgerStore {
let store = StelLedgerStore::open_in_memory("render-it").expect("ledger");
for i in 0..n {
store.record(&StelLedgerEvent {
ts_ms: 1_000 + i,
plan_id: format!("p-{i}"),
surface: "symforge".into(),
intent: IntentBucket::Trace,
decision: AdmissionDecision::Serve,
tools_called: vec!["find_references".into()],
predicted_response_tokens: 100,
actual_response_tokens: 90,
manual_baseline_tokens: 300,
net_vs_manual: net_each,
equivalence: None,
route_confidence: RouteConfidence::Exact,
pff_bypass: None,
cache_hit: None,
degrade_flags: vec![],
});
}
store
}
fn runtime(ledger: StelLedgerStore) -> ServerRuntime {
let index = LiveIndex::empty();
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
let protocol = Arc::new(SymForgeServer::new(
Arc::clone(&index),
"render-it-project".to_string(),
watcher_info,
None,
None,
));
let governor = Arc::new(RequestGovernor::new());
ServerRuntime::build_runtime(
index,
protocol,
governor,
AuthConfig::new(None),
Some(ledger),
)
}
struct TestServer {
addr: SocketAddr,
shutdown: Option<tokio::sync::oneshot::Sender<()>>,
join: tokio::task::JoinHandle<()>,
}
impl TestServer {
fn url(&self, path: &str) -> String {
format!("http://{}{}", self.addr, path)
}
async fn shutdown(mut self) {
if let Some(tx) = self.shutdown.take() {
let _ = tx.send(());
}
let _ = self.join.await;
}
}
async fn start(runtime: ServerRuntime) -> TestServer {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind");
let addr = listener.local_addr().expect("local_addr");
let admin = build_admin_router(&runtime);
let gated = apply_origin_gate(admin, OriginLayerState::from_bind_addr(addr));
let app = apply_bearer_auth(gated, AuthLayerState::new(AuthConfig::new(None), true));
let (tx, rx) = tokio::sync::oneshot::channel::<()>();
let join = tokio::spawn(async move {
let shutdown = async {
let _ = rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
TestServer {
addr,
shutdown: Some(tx),
join,
}
}
#[tokio::test]
async fn admin_page_references_endpoints_and_summary_has_real_values() {
let store = seeded_ledger(210, 4);
let server = start(runtime(store)).await;
let client = reqwest::Client::new();
let html = client
.get(server.url("/admin"))
.send()
.await
.expect("html req")
.text()
.await
.expect("html body");
assert!(html.contains("/admin/app.js"), "HTML loads app.js");
assert!(html.contains("/admin/style.css"), "HTML loads style.css");
assert!(html.contains("id=\"economics\""));
assert!(html.contains("id=\"surface\""));
assert!(html.contains("id=\"system\""));
let js = client
.get(server.url("/admin/app.js"))
.send()
.await
.expect("js req")
.text()
.await
.expect("js body");
for endpoint in ["/summary", "/surface", "/harness", "/system", "/keys"] {
assert!(js.contains(endpoint), "app.js fetches {endpoint}");
}
assert!(js.contains("total_events"));
assert!(js.contains("total_net_vs_manual"));
let summary = client
.get(server.url("/api/v1/summary"))
.send()
.await
.expect("summary req")
.json::<serde_json::Value>()
.await
.expect("summary json");
assert_eq!(summary["available"], true);
assert_eq!(summary["total_events"], 4);
assert_eq!(summary["total_net_vs_manual"], 840);
server.shutdown().await;
}