Skip to content
1        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}