add test for crates.io API (#231)

Author: marcoieni

src/crates/crates_api/api_health.rs

@@ -0,0 +1,121 @@
+//! Test for crates.io API health
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+
+use crate::http_client::custom_http_client;
+use crate::test::{Test, TestResult};
+
+use super::config::Config;
+
+/// The name of the test
+const NAME: &str = "crates.io API";
+
+/// Test that the crates.io API is accessible
+pub struct ApiHealth {
+    /// Configuration for this test
+    config: Arc<Config>,
+}
+
+impl ApiHealth {
+    /// Create a new instance of the test
+    pub fn new(config: Arc<Config>) -> Self {
+        Self { config }
+    }
+}
+
+#[async_trait]
+impl Test for ApiHealth {
+    async fn run(&self) -> TestResult {
+        let response = match custom_http_client()
+            .build()
+            .expect("failed to build reqwest client")
+            .get(self.config.api_url())
+            .send()
+            .await
+        {
+            Ok(response) => response,
+            Err(error) => {
+                return TestResult::builder()
+                    .name(NAME)
+                    .success(false)
+                    .message(Some(error.to_string()))
+                    .build()
+            }
+        };
+
+        if response.status().is_success() {
+            TestResult::builder().name(NAME).success(true).build()
+        } else {
+            TestResult::builder()
+                .name(NAME)
+                .success(false)
+                .message(Some(format!(
+                    "Expected HTTP 200, got HTTP {}",
+                    response.status()
+                )))
+                .build()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use mockito::ServerGuard;
+
+    use crate::test_utils::*;
+
+    use super::*;
+
+    pub async fn setup() -> (ServerGuard, Config) {
+        let server = mockito::Server::new_async().await;
+
+        let config = Config::builder().api_url(server.url()).build();
+
+        (server, config)
+    }
+
+    #[tokio::test]
+    async fn succeeds_with_http_200_response() {
+        let (mut server, config) = setup().await;
+
+        let mock = server.mock("GET", "/").with_status(200).create();
+
+        let result = ApiHealth::new(Arc::new(config)).run().await;
+
+        // Assert that the mock was called
+        mock.assert();
+
+        assert!(result.success());
+    }
+
+    #[tokio::test]
+    async fn fails_with_other_http_responses() {
+        let (mut server, config) = setup().await;
+
+        let mock = server.mock("GET", "/").with_status(500).create();
+
+        let result = ApiHealth::new(Arc::new(config)).run().await;
+
+        // Assert that the mock was called
+        mock.assert();
+
+        assert!(!result.success());
+    }
+
+    #[test]
+    fn trait_send() {
+        assert_send::<ApiHealth>();
+    }
+
+    #[test]
+    fn trait_sync() {
+        assert_sync::<ApiHealth>();
+    }
+
+    #[test]
+    fn trait_unpin() {
+        assert_unpin::<ApiHealth>();
+    }
+}

src/crates/crates_api/config.rs

@@ -0,0 +1,54 @@
+//! Configuration for crates.io API tests
+
+use getset::Getters;
+#[cfg(test)]
+use typed_builder::TypedBuilder;
+
+use crate::environment::Environment;
+
+/// Configuration for crates.io API tests
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default, Getters)]
+#[cfg_attr(test, derive(TypedBuilder))]
+pub struct Config {
+    /// The URL for the crates.io API
+    #[getset(get = "pub")]
+    api_url: String,
+}
+
+impl Config {
+    /// Return the configuration for the given environment
+    pub fn for_env(env: Environment) -> Self {
+        // Use the summary endpoint as a simple health check
+        const PATH: &str = "/api/v1/summary";
+        match env {
+            Environment::Staging => Self {
+                api_url: format!("https://staging.crates.io{PATH}"),
+            },
+            Environment::Production => Self {
+                api_url: format!("https://crates.io{PATH}"),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::*;
+
+    use super::*;
+
+    #[test]
+    fn trait_send() {
+        assert_send::<Config>();
+    }
+
+    #[test]
+    fn trait_sync() {
+        assert_sync::<Config>();
+    }
+
+    #[test]
+    fn trait_unpin() {
+        assert_unpin::<Config>();
+    }
+}

src/crates/crates_api/mod.rs

@@ -0,0 +1,91 @@
+//! crates.io API tests
+
+use std::fmt::{Display, Formatter};
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tokio::task::JoinSet;
+
+use crate::environment::Environment;
+use crate::test::{Test, TestGroup, TestGroupResult};
+
+pub use self::api_health::ApiHealth;
+pub use self::config::Config;
+
+mod api_health;
+mod config;
+
+/// The name of the test group
+const GROUP_NAME: &str = "crates.io API";
+
+/// Test crates.io API is accessible
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct CratesApi {
+    /// Configuration for the test group
+    config: Arc<Config>,
+}
+
+impl CratesApi {
+    /// Create a new instance of the test group
+    pub fn new(env: Environment) -> Self {
+        Self {
+            config: Arc::new(Config::for_env(env)),
+        }
+    }
+}
+
+impl Display for CratesApi {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{GROUP_NAME}")
+    }
+}
+
+#[async_trait]
+impl TestGroup for CratesApi {
+    async fn run(&self) -> TestGroupResult {
+        let tests: Vec<Box<dyn Test>> = vec![Box::new(ApiHealth::new(self.config.clone()))];
+
+        let mut js = JoinSet::new();
+        for test in tests {
+            js.spawn(async move { test.run().await });
+        }
+
+        let results = js.join_all().await;
+
+        TestGroupResult::builder()
+            .name(GROUP_NAME)
+            .results(results)
+            .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use crate::test_utils::*;
+
+    use super::*;
+
+    #[test]
+    fn trait_display() {
+        let crates_api = CratesApi::new(Environment::Staging);
+
+        assert_eq!("crates.io API", crates_api.to_string());
+    }
+
+    #[test]
+    fn trait_send() {
+        assert_send::<CratesApi>();
+    }
+
+    #[test]
+    fn trait_sync() {
+        assert_sync::<CratesApi>();
+    }
+
+    #[test]
+    fn trait_unpin() {
+        assert_unpin::<CratesApi>();
+    }
+}

src/crates/mod.rs

@@ -10,11 +10,13 @@ use crate::test::{TestGroup, TestSuite, TestSuiteResult};
 
 use self::crates_4891::Crates4891;
 use self::crates_6164::Crates6164;
+use self::crates_api::CratesApi;
 use self::crates_index::CratesIndex;
 use self::db_dump::DbDump;
 
 mod crates_4891;
 mod crates_6164;
+mod crates_api;
 mod crates_index;
 mod db_dump;
 mod utils;
@@ -49,6 +51,7 @@ impl TestSuite for Crates {
         let groups: Vec<Box<dyn TestGroup>> = vec![
             Box::new(Crates4891::new(self.env)),
             Box::new(Crates6164::new(self.env)),
+            Box::new(CratesApi::new(self.env)),
             Box::new(CratesIndex::new(self.env)),
             Box::new(DbDump::new(self.env)),
         ];