LINE1 10 20 30 40 50 60 70 80 901#[cfg(not(feature = "testing"))]2use std::time::Duration;34#[cfg(not(feature = "testing"))]5use anyhow::Context;6#[cfg(not(feature = "testing"))]7use reqwest::{Client, redirect::Policy};8#[cfg(not(feature = "testing"))]9use serde::Deserialize;1011use crate::{credential_store::CredentialStore, server_url::TwigUrl};1213#[derive(Clone, Copy, Debug, Eq, PartialEq)]14pub enum TwigHealth {15 Healthy,16 UnexpectedStatus(u16),17 Unavailable,18}1920#[derive(Clone, Debug, Eq, PartialEq)]21pub enum TwigVersion {22 Available(String),23 UnexpectedStatus(u16),24 Unavailable,25}2627#[derive(Clone, Debug, Eq, PartialEq)]28pub struct StatusReport {29 pub authenticated: bool,30 pub twig: TwigHealth,31 pub version: TwigVersion,32}3334impl StatusReport {35 pub fn render(&self) -> String {36 let authentication = if self.authenticated {37 "authenticated"38 } else {39 "not authenticated"40 };41 let twig = match self.twig {42 TwigHealth::Healthy => "healthy (HTTP 200)".to_owned(),43 TwigHealth::UnexpectedStatus(status) => format!("unhealthy (HTTP {status})"),44 TwigHealth::Unavailable => "unavailable".to_owned(),45 };46 let version = match &self.version {47 TwigVersion::Available(version) => version.clone(),48 TwigVersion::UnexpectedStatus(status) => format!("unavailable (HTTP {status})"),49 TwigVersion::Unavailable => "unavailable".to_owned(),50 };5152 format!("Authentication: {authentication}\nTwig /up: {twig}\nTwig /api/version: {version}")53 }54}5556pub trait TwigProbe {57 async fn health(&self, server: &TwigUrl) -> TwigHealth;58 async fn version(&self, server: &TwigUrl, token: &str) -> TwigVersion;59}6061pub async fn inspect(62 server: &TwigUrl,63 credentials: &impl CredentialStore,64 probe: &impl TwigProbe,65) -> anyhow::Result<StatusReport> {66 let token = credentials.get(server)?;67 let authenticated = token.is_some();68 let twig = probe.health(server).await;69 let version = match token {70 Some(token) => probe.version(server, &token).await,71 None => TwigVersion::Unavailable,72 };73 Ok(StatusReport {74 authenticated,75 twig,76 version,77 })78}7980#[cfg(not(feature = "testing"))]81pub struct HttpTwigStatusProbe {82 client: Client,83}8485#[cfg(not(feature = "testing"))]86impl HttpTwigStatusProbe {87 pub fn new() -> anyhow::Result<Self> {88 let client = Client::builder()89 .timeout(Duration::from_secs(5))90 .redirect(Policy::none())91 .build()92 .context("Failed to initialize Twig status-check client")?;93 Ok(Self { client })94 }95}9697#[cfg(not(feature = "testing"))]98impl TwigProbe for HttpTwigStatusProbe {99 async fn health(&self, server: &TwigUrl) -> TwigHealth {100 let Ok(endpoint) = server.as_url().join("up") else {101 return TwigHealth::Unavailable;102 };103 let Ok(response) = self.client.get(endpoint).send().await else {104 return TwigHealth::Unavailable;105 };106 let status = response.status().as_u16();107 if status == 200 {108 TwigHealth::Healthy109 } else {110 TwigHealth::UnexpectedStatus(status)111 }112 }113114 async fn version(&self, server: &TwigUrl, token: &str) -> TwigVersion {115 let Ok(endpoint) = server.as_url().join("/api/version") else {116 return TwigVersion::Unavailable;117 };118 let Ok(response) = self.client.get(endpoint).bearer_auth(token).send().await else {119 return TwigVersion::Unavailable;120 };121 let status = response.status().as_u16();122 if status != 200 {123 return TwigVersion::UnexpectedStatus(status);124 }125126 match response.json::<VersionResponse>().await {127 Ok(response) => TwigVersion::Available(response.version),128 Err(_) => TwigVersion::Unavailable,129 }130 }131}132133#[cfg(not(feature = "testing"))]134#[derive(Deserialize)]135struct VersionResponse {136 version: String,137}138139#[cfg(all(test, not(feature = "testing")))]140mod tests {141 use std::net::TcpListener;142143 use wiremock::{Mock, MockServer, ResponseTemplate, matchers::method, matchers::path};144145 use super::{HttpTwigStatusProbe, StatusReport, TwigHealth, TwigProbe, TwigVersion, inspect};146 use crate::{credential_store::CredentialStore, server_url::TwigUrl};147148 struct TestCredentials(Option<String>);149150 impl CredentialStore for TestCredentials {151 fn check_available(&self) -> anyhow::Result<()> {152 Ok(())153 }154155 fn get(&self, _server: &TwigUrl) -> anyhow::Result<Option<String>> {156 Ok(self.0.clone())157 }158159 fn put(&self, _server: &TwigUrl, _token: &str) -> anyhow::Result<()> {160 Ok(())161 }162163 fn erase(&self, _server: &TwigUrl) -> anyhow::Result<()> {164 Ok(())165 }166 }167168 async fn mock_twig(status: u16) -> (MockServer, TwigUrl) {169 mock_twig_with_version(170 status,171 ResponseTemplate::new(200)172 .insert_header("content-type", "application/json")173 .set_body_string(r#"{"version":"0.1.104"}"#),174 )175 .await176 }177178 async fn mock_twig_with_version(179 health_status: u16,180 version_response: ResponseTemplate,181 ) -> (MockServer, TwigUrl) {182 let server = MockServer::start().await;183 Mock::given(method("GET"))184 .and(path("/up"))185 .respond_with(ResponseTemplate::new(health_status))186 .mount(&server)187 .await;188 Mock::given(method("GET"))189 .and(path("/api/version"))190 .and(wiremock::matchers::header(191 "authorization",192 "Bearer fake-token",193 ))194 .respond_with(version_response)195 .mount(&server)196 .await;197 let url = TwigUrl::parse(&server.uri()).expect("mock Twig URL");198 (server, url)199 }200201 #[tokio::test]202 async fn inspect_reports_saved_token_http_200_and_version() {203 let (_mock, server) = mock_twig(200).await;204 let credentials = TestCredentials(Some("fake-token".to_owned()));205 let probe = HttpTwigStatusProbe::new().expect("status client");206207 let report = inspect(&server, &credentials, &probe)208 .await209 .expect("status check");210211 assert_eq!(212 report,213 StatusReport {214 authenticated: true,215 twig: TwigHealth::Healthy,216 version: TwigVersion::Available("0.1.104".to_owned()),217 }218 );219 }220221 #[tokio::test]222 async fn inspect_reports_missing_token_and_non_200() {223 let (mock, server) = mock_twig(503).await;224 let credentials = TestCredentials(None);225 let probe = HttpTwigStatusProbe::new().expect("status client");226227 let report = inspect(&server, &credentials, &probe)228 .await229 .expect("status check");230231 assert!(!report.authenticated);232 assert_eq!(report.twig, TwigHealth::UnexpectedStatus(503));233 assert_eq!(report.version, TwigVersion::Unavailable);234 assert_eq!(235 mock.received_requests()236 .await237 .expect("server received /up request")238 .len(),239 1,240 "status must skip the authenticated API route without a token"241 );242 }243244 #[tokio::test]245 async fn version_probe_requests_origin_root_api_version() {246 let mock = MockServer::start().await;247 let version_mock = Mock::given(method("GET"))248 .and(path("/api/version"))249 .and(wiremock::matchers::header(250 "authorization",251 "Bearer fake-token",252 ))253 .respond_with(254 ResponseTemplate::new(200)255 .insert_header("content-type", "application/json")256 .set_body_string(r#"{"version":"0.1.104"}"#),257 )258 .expect(1)259 .mount_as_scoped(&mock)260 .await;261 let server =262 TwigUrl::parse(&format!("{}/some/prefix/", mock.uri())).expect("prefixed Twig URL");263 let probe = HttpTwigStatusProbe::new().expect("status client");264265 assert_eq!(266 probe.version(&server, "fake-token").await,267 TwigVersion::Available("0.1.104".to_owned())268 );269 assert_eq!(version_mock.received_requests().await.len(), 1);270 }271272 #[tokio::test]273 async fn version_probe_reports_non_200_status() {274 let (_mock, server) = mock_twig_with_version(200, ResponseTemplate::new(503)).await;275 let probe = HttpTwigStatusProbe::new().expect("status client");276277 assert_eq!(278 probe.version(&server, "fake-token").await,279 TwigVersion::UnexpectedStatus(503)280 );281 }282283 #[tokio::test]284 async fn version_probe_reports_invalid_json_as_unavailable() {285 let (_mock, server) = mock_twig_with_version(286 200,287 ResponseTemplate::new(200)288 .insert_header("content-type", "application/json")289 .set_body_string("not json"),290 )291 .await;292 let probe = HttpTwigStatusProbe::new().expect("status client");293294 assert_eq!(295 probe.version(&server, "fake-token").await,296 TwigVersion::Unavailable297 );298 }299300 #[tokio::test]301 async fn status_probe_does_not_follow_redirects() {302 let redirect_target = MockServer::start().await;303 Mock::given(method("GET"))304 .and(path("/up"))305 .respond_with(ResponseTemplate::new(200))306 .mount(&redirect_target)307 .await;308 Mock::given(method("GET"))309 .and(path("/api/version"))310 .respond_with(311 ResponseTemplate::new(200)312 .insert_header("content-type", "application/json")313 .set_body_string(r#"{"version":"0.1.104"}"#),314 )315 .mount(&redirect_target)316 .await;317318 let redirecting_server = MockServer::start().await;319 Mock::given(method("GET"))320 .and(path("/up"))321 .respond_with(322 ResponseTemplate::new(302)323 .insert_header("Location", format!("{}/up", redirect_target.uri())),324 )325 .mount(&redirecting_server)326 .await;327 Mock::given(method("GET"))328 .and(path("/api/version"))329 .respond_with(330 ResponseTemplate::new(302)331 .insert_header("Location", format!("{}/api/version", redirect_target.uri())),332 )333 .mount(&redirecting_server)334 .await;335 let server = TwigUrl::parse(&redirecting_server.uri()).expect("mock Twig URL");336 let probe = HttpTwigStatusProbe::new().expect("status client");337338 assert_eq!(339 probe.health(&server).await,340 TwigHealth::UnexpectedStatus(302)341 );342 assert_eq!(343 probe.version(&server, "fake-token").await,344 TwigVersion::UnexpectedStatus(302)345 );346 }347348 #[tokio::test]349 async fn status_probe_reports_request_failures_as_unavailable() {350 let listener = TcpListener::bind(("127.0.0.1", 0)).expect("reserve local port");351 let address = listener.local_addr().expect("local address");352 drop(listener);353 let server = TwigUrl::parse(&format!("http://{address}/")).expect("loopback Twig URL");354 let probe = HttpTwigStatusProbe::new().expect("status client");355356 assert_eq!(probe.health(&server).await, TwigHealth::Unavailable);357 assert_eq!(358 probe.version(&server, "fake-token").await,359 TwigVersion::Unavailable360 );361 }362}