Implement GET /crates/:crate_id/maintenance.svg endpoint

Author: Turbo87

src/controllers/krate.rs

@@ -1,3 +1,4 @@
+pub mod badges;
 pub mod downloads;
 pub mod follow;
 pub mod metadata;

src/controllers/krate/badges.rs

@@ -0,0 +1,74 @@
+//! Endpoints that provide badges based on crate metadata
+
+use crate::controllers::frontend_prelude::*;
+
+use crate::models::{Badge, Crate, CrateBadge, MaintenanceStatus};
+use crate::schema::*;
+
+use conduit::{Body, Response};
+
+/// Handles the `GET /crates/:crate_id/maintenance.svg` route.
+pub fn maintenance(req: &mut dyn RequestExt) -> EndpointResult {
+    let name = &req.params()["crate_id"];
+    let conn = req.db_read_only()?;
+
+    let krate = Crate::by_name(name).first::<Crate>(&*conn);
+    if krate.is_err() {
+        let response = Response::builder().status(404).body(Body::empty()).unwrap();
+
+        return Ok(response);
+    }
+
+    let krate = krate.unwrap();
+
+    let maintenance_badge = CrateBadge::belonging_to(&krate)
+        .select((badges::crate_id, badges::all_columns))
+        .load::<CrateBadge>(&*conn)?
+        .into_iter()
+        .find(|cb| match cb.badge {
+            Badge::Maintenance { .. } => true,
+            _ => false,
+        });
+
+    if maintenance_badge.is_none() {
+        return Ok(req.redirect(
+            "https://img.shields.io/badge/maintenance-unknown-lightgrey.svg".to_owned(),
+        ));
+    }
+
+    let status = match maintenance_badge {
+        Some(CrateBadge {
+            badge: Badge::Maintenance { status },
+            ..
+        }) => Some(status),
+        _ => None,
+    };
+
+    let status = status.unwrap();
+
+    let message = match status {
+        MaintenanceStatus::ActivelyDeveloped => "actively--developed",
+        MaintenanceStatus::PassivelyMaintained => "passively--maintained",
+        MaintenanceStatus::AsIs => "as--is",
+        MaintenanceStatus::None => "unknown",
+        MaintenanceStatus::Experimental => "experimental",
+        MaintenanceStatus::LookingForMaintainer => "looking--for--maintainer",
+        MaintenanceStatus::Deprecated => "deprecated",
+    };
+
+    let color = match status {
+        MaintenanceStatus::ActivelyDeveloped => "brightgreen",
+        MaintenanceStatus::PassivelyMaintained => "yellowgreen",
+        MaintenanceStatus::AsIs => "yellow",
+        MaintenanceStatus::None => "lightgrey",
+        MaintenanceStatus::Experimental => "blue",
+        MaintenanceStatus::LookingForMaintainer => "orange",
+        MaintenanceStatus::Deprecated => "red",
+    };
+
+    let url = format!(
+        "https://img.shields.io/badge/maintenance-{}-{}.svg",
+        message, color
+    );
+    Ok(req.redirect(url))
+}

src/router.rs

@@ -66,6 +66,10 @@ pub fn build_router(app: &App) -> R404 {
         "/crates/:crate_id/reverse_dependencies",
         C(krate::metadata::reverse_dependencies),
     );
+    api_router.get(
+        "/crates/:crate_id/maintenance.svg",
+        C(krate::badges::maintenance),
+    );
     api_router.get("/keywords", C(keyword::index));
     api_router.get("/keywords/:keyword_id", C(keyword::show));
     api_router.get("/categories", C(category::index));

src/tests/all.rs

@@ -51,6 +51,7 @@ mod dump_db;
 mod git;
 mod keyword;
 mod krate;
+mod maintenance_badge;
 mod owners;
 mod read_only_mode;
 mod record;

src/tests/maintenance_badge.rs

@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+
+use cargo_registry::models::Badge;
+use conduit::StatusCode;
+
+use crate::util::{MockAnonymousUser, RequestHelper};
+use crate::{builders::CrateBuilder, TestApp};
+
+fn set_up() -> MockAnonymousUser {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        let mut badges = HashMap::new();
+        badges.insert("maintenance".to_owned(), {
+            let mut attributes = HashMap::new();
+            attributes.insert("status".to_owned(), "looking-for-maintainer".to_owned());
+            attributes
+        });
+
+        let krate = CrateBuilder::new("foo", user.id).expect_build(conn);
+        Badge::update_crate(conn, &krate, Some(&badges)).unwrap();
+
+        CrateBuilder::new("bar", user.id).expect_build(conn);
+    });
+
+    anon
+}
+
+#[test]
+fn crate_with_maintenance_badge() {
+    let anon = set_up();
+
+    anon.get::<()>("/api/v1/crates/foo/maintenance.svg")
+        .assert_status(StatusCode::FOUND)
+        .assert_redirects_to(
+            "https://img.shields.io/badge/maintenance-looking--for--maintainer-orange.svg",
+        );
+}
+
+#[test]
+fn crate_without_maintenance_badge() {
+    let anon = set_up();
+
+    anon.get::<()>("/api/v1/crates/bar/maintenance.svg")
+        .assert_status(StatusCode::FOUND)
+        .assert_redirects_to("https://img.shields.io/badge/maintenance-unknown-lightgrey.svg");
+}
+
+#[test]
+fn unknown_crate() {
+    let anon = set_up();
+
+    anon.get::<()>("/api/v1/crates/unknown/maintenance.svg")
+        .assert_status(StatusCode::NOT_FOUND);
+}

src/tests/util.rs

@@ -627,6 +627,19 @@ where
             .ends_with(target));
         self
     }
+
+    pub fn assert_redirects_to(&self, target: &str) -> &Self {
+        assert_eq!(
+            self.response
+                .headers()
+                .get(header::LOCATION)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            target
+        );
+        self
+    }
 }
 
 impl Response<()> {