Files
skyg-linux-tracker/tests/peers_config.rs
T
ari 4bfb097be6 A0: contract stubs types, transport, fake and registry seams
Land the shared peer contracts: types, error mapping, transport trait,
fake transport and fixtures, registry/proxy/health skeletons, the
AppState.peers and Config.peers seams, the ping and peers route stubs,
and unit plus integration tests. No loops, no network, feature off by
default.
2026-10-19 20:02:17 -04:00

161 lines
5.2 KiB
Rust

//! Peer seams exercised end to end against the fake transport and fake
//! sources: the peer-less default, the ping route, and registry reads.
use std::time::Duration;
use axum::body::{to_bytes, Body};
use axum::http::{Request, StatusCode};
use skyg_linux_tracker::api;
use skyg_linux_tracker::config::Config;
use skyg_linux_tracker::peers::testing::{
fake_peers_config, fake_state_with_peers, registry_with, static_registry, FakeTransport,
};
use skyg_linux_tracker::peers::types::{ApiStatus, AuthState, PeerName, PeerStatus, ServerStatus};
use skyg_linux_tracker::peers::{PeerError, ProxyOpts};
use tower::ServiceExt;
async fn get(app: &axum::Router, uri: &str) -> (StatusCode, String) {
let resp = app
.clone()
.oneshot(Request::get(uri).body(Body::empty()).unwrap())
.await
.unwrap();
let status = resp.status();
let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
(status, String::from_utf8(body.to_vec()).unwrap())
}
fn status(name: &str, up: bool) -> PeerStatus {
PeerStatus {
name: PeerName::parse(name).unwrap(),
enabled: true,
url: format!("http://{name}:1984"),
server: ServerStatus {
up,
..ServerStatus::default()
},
api: ApiStatus::default(),
}
}
#[tokio::test]
async fn peerless_default_is_off_and_unchanged() {
let config = Config::default();
assert!(!config.peers.enabled);
assert!(config.peers.peer.is_empty());
let state = skyg_linux_tracker::sources::fake::fake_state(config);
assert!(state.peers.is_none());
let (s, b) = get(&api::router(state), "/systemd/units").await;
assert_eq!(s, StatusCode::OK);
assert!(!b.is_empty());
}
#[tokio::test]
async fn ping_route_is_present_without_peers() {
let app = api::router(skyg_linux_tracker::sources::fake::fake_state(
Config::default(),
));
let (s, b) = get(&app, "/ping").await;
assert_eq!(s, StatusCode::OK);
let v: serde_json::Value = serde_json::from_str(&b).unwrap();
assert_eq!(v["status"], "ok");
assert!(v["version"].is_string());
}
#[tokio::test]
async fn fake_state_carries_the_registry() {
let fake = FakeTransport::new();
let reg = registry_with(fake, fake_peers_config(&["beta", "gamma"]));
let state = fake_state_with_peers(Config::default(), reg);
let peers = state.peers.as_ref().expect("registry present");
let names: Vec<_> = peers
.snapshot()
.into_iter()
.map(|p| p.name.as_str().to_owned())
.collect();
assert_eq!(names, ["beta", "gamma"]);
assert_eq!(peers.status("beta").unwrap().api.auth, AuthState::Unknown);
}
#[tokio::test]
async fn registry_proxies_through_the_fake_and_records_the_request() {
let fake = FakeTransport::new();
fake.peer("beta")
.respond("/systemd/units", 200, "application/json", r#"{"units":[]}"#);
let reg = registry_with(fake.clone(), fake_peers_config(&["beta"]));
let resp = reg
.get(
"beta",
"/systemd/units",
&[("state".into(), "failed".into())],
ProxyOpts::default(),
)
.await
.unwrap();
assert_eq!(resp.status, 200);
let calls = fake.calls();
assert_eq!(calls.len(), 1);
assert_eq!(
calls[0].1.query,
vec![("state".to_owned(), "failed".to_owned())]
);
assert!(calls[0]
.1
.headers
.iter()
.any(|(k, v)| k.as_str() == "x-slinuxm-hop" && v == "1"));
assert!(!calls[0]
.1
.headers
.iter()
.any(|(k, _)| k.as_str() == "authorization"));
}
#[tokio::test]
async fn unknown_peer_and_peer_failures_use_the_shared_mapping() {
let fake = FakeTransport::new();
fake.peer("beta")
.respond_err("/systemd/units", PeerError::Rejected);
let reg = registry_with(fake, fake_peers_config(&["beta"]));
let err = reg
.get("nope", "/systemd/units", &[], ProxyOpts::default())
.await
.unwrap_err();
assert_eq!(err.code(), "not_found");
assert_eq!(err.message(), "peer nope: unknown peer");
let err = reg
.get("beta", "/systemd/units", &[], ProxyOpts::default())
.await
.unwrap_err();
assert_eq!(err.code(), "unavailable");
assert_eq!(err.status(), StatusCode::SERVICE_UNAVAILABLE);
assert!(err.message().contains("beta"));
assert_eq!(err.message(), "peer beta: peer rejected credentials");
}
#[tokio::test]
async fn static_registry_is_sorted_and_serves_rendering() {
let reg = static_registry(vec![status("gamma", false), status("beta", true)]);
let snap = reg.snapshot();
assert_eq!(snap[0].name.as_str(), "beta");
assert_eq!(snap[1].name.as_str(), "gamma");
assert!(reg.status("beta").unwrap().server.up);
assert_eq!(reg.status("nope").unwrap_err().code(), "not_found");
// Static snapshots do not script the transport; unscripted GETs still use
// the fake defaults, so a proxy call is bounded and never touches a socket.
let resp = tokio::time::timeout(
Duration::from_secs(1),
reg.get("beta", "/systemd/units", &[], ProxyOpts::default()),
)
.await
.expect("fake transport must not block")
.unwrap();
assert_eq!(resp.status, 404);
}