//! 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::net::{IpAddr, Ipv4Addr}; use std::path::{Path, PathBuf}; use std::time::Duration; use axum::body::{to_bytes, Body}; use axum::http::{Request, StatusCode}; use figment::Jail; use skyg_linux_tracker::api; use skyg_linux_tracker::config::{CliOverrides, 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()); } #[test] #[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() { Jail::expect_with(|jail| { jail.create_file( "peers.toml", r#" [server] bind = "0.0.0.0" [peers] enabled = true tcp_interval_secs = 2 tcp_timeout_secs = 1 api_interval_secs = 3 api_timeout_secs = 2 fail_threshold = 2 request_timeout_secs = 4 [[peers.peer]] name = "beta" url = "http://beta:1984" token_file = "/run/credentials/skyg-linux-tracker.service/peer-beta" allow_plain_http = true [[peers.peer]] name = "gamma" url = "https://gamma:1984" token_file = "/run/credentials/skyg-linux-tracker.service/peer-gamma" ca_file = "/etc/ssl/private-ca.pem" allow_plain_http = false [[peers.peer]] name = "delta" url = "https://delta:1984" token_file = "/run/credentials/skyg-linux-tracker.service/peer-delta" enabled = false "#, )?; let cfg = Config::load(Some(Path::new("peers.toml")), &CliOverrides::default()) .expect("peer entries must deserialize"); assert!(cfg.auth.enabled); assert_eq!(cfg.server.bind, IpAddr::V4(Ipv4Addr::UNSPECIFIED)); assert!(cfg.peers.enabled); assert_eq!(cfg.peers.tcp_interval_secs, 2); assert_eq!(cfg.peers.api_timeout_secs, 2); assert_eq!(cfg.peers.request_timeout_secs, 4); assert_eq!(cfg.peers.max_response_bytes, 8 * 1024 * 1024); let peer = |name: &str| { cfg.peers .peer .iter() .find(|p| p.name.as_str() == name) .unwrap() }; let beta = peer("beta"); assert!(beta.enabled); assert!(beta.allow_plain_http); assert!(beta.ca_file.is_none()); assert_eq!( beta.token_file, PathBuf::from("/run/credentials/skyg-linux-tracker.service/peer-beta") ); let gamma = peer("gamma"); assert!(gamma.enabled); assert!(!gamma.allow_plain_http); assert_eq!( gamma.ca_file.as_deref(), Some(Path::new("/etc/ssl/private-ca.pem")) ); let delta = peer("delta"); assert!(!delta.enabled); assert!(!delta.allow_plain_http); assert!(delta.ca_file.is_none()); Ok(()) }); } #[tokio::test] async fn ping_without_a_token_is_unauthorized() { let pool = sqlx::sqlite::SqlitePoolOptions::new() .max_connections(1) .connect("sqlite::memory:") .await .unwrap(); skyg_linux_tracker::db::migrate(&pool).await.unwrap(); let token = skyg_linux_tracker::auth::tokens::create(&pool, "ping") .await .unwrap(); let mut config = Config::default(); config.auth.enabled = true; let mut state = skyg_linux_tracker::sources::fake::fake_state(config); state.db = Some(pool); let app = skyg_linux_tracker::server::build_router(state); let (status, body, www) = request(&app, "/api/v1/ping", None).await; assert_eq!(status, StatusCode::UNAUTHORIZED); assert_eq!(www.as_deref(), Some("Bearer")); assert!(body.contains("unauthorized")); let (status, body, _) = request(&app, "/api/v1/ping", Some(&format!("Bearer {token}"))).await; assert_eq!(status, StatusCode::OK); let v: serde_json::Value = serde_json::from_str(&body).unwrap(); assert_eq!(v["status"], "ok"); assert!(v["version"].as_str().is_some_and(|s| !s.is_empty())); } async fn request( app: &axum::Router, uri: &str, authorization: Option<&str>, ) -> (StatusCode, String, Option) { let mut builder = Request::builder().uri(uri); if let Some(auth) = authorization { builder = builder.header("authorization", auth); } let resp = app .clone() .oneshot(builder.body(Body::empty()).unwrap()) .await .unwrap(); let status = resp.status(); let www = resp .headers() .get(axum::http::header::WWW_AUTHENTICATE) .and_then(|v| v.to_str().ok()) .map(str::to_owned); let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap(); (status, String::from_utf8(body.to_vec()).unwrap(), www) } #[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); }