Allow semver in status paths

Author: Nemo157

src/web/mod.rs

@@ -116,14 +116,6 @@ impl MatchSemver {
             | MatchSemver::Latest((v, i)) => (v, i),
         }
     }
-
-    /// If the matched version was an exact match to a semver version, returns the
-    /// version string and id for the query. If the lookup required a semver match, returns
-    /// `VersionNotFound`.
-    fn exact_version_only(self) -> Result<(String, i32), AxumNope> {
-        let MatchSemver::Exact(details) = self else { return Err(AxumNope::VersionNotFound) };
-        Ok(details)
-    }
 }
 
 /// Checks the database for crate releases that match the given name and version.

src/web/status.rs

@@ -12,35 +12,48 @@ use axum::{
 };
 
 pub(crate) async fn status_handler(
-    Path((name, req_version)): Path<(String, String)>,
-    Extension(pool): Extension<Pool>,
-) -> AxumResult<impl IntoResponse> {
-    let (_, id) = match_version_axum(&pool, &name, Some(&req_version))
-        .await?
-        .exact_name_only()?
-        .exact_version_only()?;
-
-    let rustdoc_status: bool = spawn_blocking({
-        move || {
-            Ok(pool
-                .get()?
-                .query_one(
-                    "SELECT releases.rustdoc_status
-                     FROM releases
-                     WHERE releases.id = $1
-                    ",
-                    &[&id],
-                )?
-                .get("rustdoc_status"))
-        }
-    })
-    .await?;
-
-    Ok((
+    path: Path<(String, String)>,
+    pool: Extension<Pool>,
+) -> impl IntoResponse {
+    async fn inner(
+        Path((name, req_version)): Path<(String, String)>,
+        Extension(pool): Extension<Pool>,
+    ) -> AxumResult<impl IntoResponse> {
+        let (version, id) = match_version_axum(&pool, &name, Some(&req_version))
+            .await?
+            .exact_name_only()?
+            .into_parts();
+
+        let rustdoc_status: bool = spawn_blocking({
+            move || {
+                Ok(pool
+                    .get()?
+                    .query_one(
+                        "SELECT releases.rustdoc_status
+                         FROM releases
+                         WHERE releases.id = $1
+                        ",
+                        &[&id],
+                    )?
+                    .get("rustdoc_status"))
+            }
+        })
+        .await?;
+
+        Ok((
+            Extension(CachePolicy::NoStoreMustRevalidate),
+            [(ACCESS_CONTROL_ALLOW_ORIGIN, "*")],
+            Json(serde_json::json!({
+                "version": version,
+                "doc_status": rustdoc_status,
+            })),
+        ))
+    }
+    (
         Extension(CachePolicy::NoStoreMustRevalidate),
         [(ACCESS_CONTROL_ALLOW_ORIGIN, "*")],
-        Json(serde_json::json!({ "doc_status": rustdoc_status })),
-    ))
+        inner(path, pool).await,
+    )
 }
 
 #[cfg(test)]
@@ -50,93 +63,88 @@ mod tests {
         web::cache::CachePolicy,
     };
     use reqwest::StatusCode;
+    use test_case::test_case;
 
-    #[test]
-    fn success() {
+    #[test_case("latest")]
+    #[test_case("0.1")]
+    #[test_case("0.1.0")]
+    fn status(version: &str) {
         wrapper(|env| {
             env.fake_release().name("foo").version("0.1.0").create()?;
 
-            let response = env.frontend().get("/crate/foo/0.1.0/status.json").send()?;
+            let response = env
+                .frontend()
+                .get(&format!("/crate/foo/{version}/status.json"))
+                .send()?;
             assert_cache_control(&response, CachePolicy::NoStoreMustRevalidate, &env.config());
             assert_eq!(response.headers()["access-control-allow-origin"], "*");
+            assert_eq!(response.status(), StatusCode::OK);
             let value: serde_json::Value = serde_json::from_str(&response.text()?)?;
 
-            assert_eq!(value, serde_json::json!({"doc_status": true}));
+            assert_eq!(
+                value,
+                serde_json::json!({
+                    "version": "0.1.0",
+                    "doc_status": true,
+                })
+            );
 
             Ok(())
         });
     }
 
-    #[test]
-    fn failure() {
+    #[test_case("latest")]
+    #[test_case("0.1")]
+    #[test_case("0.1.0")]
+    fn failure(version: &str) {
         wrapper(|env| {
             env.fake_release()
                 .name("foo")
                 .version("0.1.0")
                 .build_result_failed()
                 .create()?;
 
-            let response = env.frontend().get("/crate/foo/0.1.0/status.json").send()?;
+            let response = env
+                .frontend()
+                .get(&format!("/crate/foo/{version}/status.json"))
+                .send()?;
             assert_cache_control(&response, CachePolicy::NoStoreMustRevalidate, &env.config());
             assert_eq!(response.headers()["access-control-allow-origin"], "*");
+            assert_eq!(response.status(), StatusCode::OK);
             let value: serde_json::Value = serde_json::from_str(&response.text()?)?;
 
-            assert_eq!(value, serde_json::json!({"doc_status": false}));
-
-            Ok(())
-        });
-    }
-
-    #[test]
-    fn crate_version_not_found() {
-        wrapper(|env| {
-            env.fake_release().name("foo").version("0.1.0").create()?;
-
-            let response = env.frontend().get("/crate/foo/0.2.0/status.json").send()?;
-            assert!(response
-                .url()
-                .as_str()
-                .ends_with("/crate/foo/0.2.0/status.json"));
-            assert_eq!(response.status(), StatusCode::NOT_FOUND);
-            Ok(())
-        });
-    }
-
-    #[test]
-    fn invalid_semver() {
-        wrapper(|env| {
-            env.fake_release().name("foo").version("0.1.0").create()?;
+            assert_eq!(
+                value,
+                serde_json::json!({
+                    "version": "0.1.0",
+                    "doc_status": false,
+                })
+            );
 
-            let response = env.frontend().get("/crate/foo/0,1,0/status.json").send()?;
-            assert!(response
-                .url()
-                .as_str()
-                .ends_with("/crate/foo/0,1,0/status.json"));
-            assert_eq!(response.status(), StatusCode::NOT_FOUND);
             Ok(())
         });
     }
 
-    /// We only support asking for the status of exact versions
-    #[test]
-    fn no_semver() {
+    // crate not found
+    #[test_case("bar", "0.1")]
+    #[test_case("bar", "0.1.0")]
+    // version not found
+    #[test_case("foo", "0.2")]
+    #[test_case("foo", "0.2.0")]
+    // invalid semver
+    #[test_case("foo", "0,1")]
+    #[test_case("foo", "0,1,0")]
+    fn not_found(krate: &str, version: &str) {
         wrapper(|env| {
             env.fake_release().name("foo").version("0.1.0").create()?;
 
-            let response = env.frontend().get("/crate/foo/latest/status.json").send()?;
-            assert!(response
-                .url()
-                .as_str()
-                .ends_with("/crate/foo/latest/status.json"));
-            assert_eq!(response.status(), StatusCode::NOT_FOUND);
-
-            let response = env.frontend().get("/crate/foo/0.1/status.json").send()?;
-            assert!(response
-                .url()
-                .as_str()
-                .ends_with("/crate/foo/0.1/status.json"));
+            let response = env
+                .frontend()
+                .get(&format!("/crate/{krate}/{version}/status.json"))
+                .send()?;
+            assert_cache_control(&response, CachePolicy::NoStoreMustRevalidate, &env.config());
+            assert_eq!(response.headers()["access-control-allow-origin"], "*");
             assert_eq!(response.status(), StatusCode::NOT_FOUND);
-
             Ok(())
         });
     }