Use redirects for semver status requests

Author: Nemo157

src/test/mod.rs

@@ -149,53 +149,65 @@ fn assert_redirect_common(
 }
 
 /// Makes sure that a URL redirects to a specific page, but doesn't check that the target exists
+///
+/// Returns the redirect response
 #[context("expected redirect from {path} to {expected_target}")]
 pub(crate) fn assert_redirect_unchecked(
     path: &str,
     expected_target: &str,
     web: &TestFrontend,
-) -> Result<()> {
-    assert_redirect_common(path, expected_target, web).map(|_| ())
+) -> Result<Response> {
+    assert_redirect_common(path, expected_target, web)
 }
 
 /// Makes sure that a URL redirects to a specific page, but doesn't check that the target exists
+///
+/// Returns the redirect response
 #[context("expected redirect from {path} to {expected_target}")]
 pub(crate) fn assert_redirect_cached_unchecked(
     path: &str,
     expected_target: &str,
     cache_policy: cache::CachePolicy,
     web: &TestFrontend,
     config: &Config,
-) -> Result<()> {
+) -> Result<Response> {
     let redirect_response = assert_redirect_common(path, expected_target, web)?;
     assert_cache_control(&redirect_response, cache_policy, config);
-    Ok(())
+    Ok(redirect_response)
 }
 
 /// Make sure that a URL redirects to a specific page, and that the target exists and is not another redirect
+///
+/// Returns the redirect response
 #[context("expected redirect from {path} to {expected_target}")]
-pub(crate) fn assert_redirect(path: &str, expected_target: &str, web: &TestFrontend) -> Result<()> {
-    assert_redirect_common(path, expected_target, web)?;
+pub(crate) fn assert_redirect(
+    path: &str,
+    expected_target: &str,
+    web: &TestFrontend,
+) -> Result<Response> {
+    let redirect_response = assert_redirect_common(path, expected_target, web)?;
 
     let response = web.get_no_redirect(expected_target).send()?;
     let status = response.status();
     if !status.is_success() {
         anyhow::bail!("failed to GET {expected_target}: {status}");
     }
 
-    Ok(())
+    Ok(redirect_response)
 }
 
 /// Make sure that a URL redirects to a specific page, and that the target exists and is not another redirect.
 /// Also verifies that the redirect's cache-control header matches the provided cache policy.
+///
+/// Returns the redirect response
 #[context("expected redirect from {path} to {expected_target}")]
 pub(crate) fn assert_redirect_cached(
     path: &str,
     expected_target: &str,
     cache_policy: cache::CachePolicy,
     web: &TestFrontend,
     config: &Config,
-) -> Result<()> {
+) -> Result<Response> {
     let redirect_response = assert_redirect_common(path, expected_target, web)?;
     assert_cache_control(&redirect_response, cache_policy, config);
 
@@ -205,7 +217,7 @@ pub(crate) fn assert_redirect_cached(
         anyhow::bail!("failed to GET {expected_target}: {status}");
     }
 
-    Ok(())
+    Ok(redirect_response)
 }
 
 pub(crate) struct TestEnvironment {

src/web/rustdoc.rs

@@ -2149,11 +2149,14 @@ mod test {
                 .archive_storage(archive_storage)
                 .rustdoc_file("tokio/time/index.html")
                 .create()?;
+
             assert_redirect(
                 "/tokio/0.2.21/tokio/time",
                 "/tokio/0.2.21/tokio/time/index.html",
                 env.frontend(),
-            )
+            )?;
+
+            Ok(())
         })
     }
 

src/web/status.rs

@@ -2,7 +2,7 @@ use super::cache::CachePolicy;
 use crate::{
     db::Pool,
     utils::spawn_blocking,
-    web::{error::AxumResult, match_version_axum},
+    web::{axum_redirect, error::AxumResult, match_version_axum, MatchSemver},
 };
 use axum::{
     extract::{Extension, Path},
@@ -21,10 +21,18 @@ pub(crate) async fn status_handler(
         // We use an async block to emulate a try block so that we can apply the above CORS header
         // and cache policy to both successful and failed responses
         async move {
-            let (version, id) = match_version_axum(&pool, &name, Some(&req_version))
+            let (version, id) = match match_version_axum(&pool, &name, Some(&req_version))
                 .await?
                 .exact_name_only()?
-                .into_parts();
+            {
+                MatchSemver::Exact((version, id)) | MatchSemver::Latest((version, id)) => {
+                    (version, id)
+                }
+                MatchSemver::Semver((version, _)) => {
+                    let redirect = axum_redirect(format!("/crate/{name}/{version}/status.json"))?;
+                    return Ok(redirect.into_response());
+                }
+            };
 
             let rustdoc_status: bool = spawn_blocking({
                 move || {
@@ -42,10 +50,12 @@ pub(crate) async fn status_handler(
             })
             .await?;
 
-            AxumResult::Ok(Json(serde_json::json!({
+            let json = Json(serde_json::json!({
                 "version": version,
                 "doc_status": rustdoc_status,
-            })))
+            }));
+
+            AxumResult::Ok(json.into_response())
         }
         .await,
     )
@@ -54,7 +64,7 @@ pub(crate) async fn status_handler(
 #[cfg(test)]
 mod tests {
     use crate::{
-        test::{assert_cache_control, wrapper},
+        test::{assert_cache_control, assert_redirect, wrapper},
         web::cache::CachePolicy,
     };
     use reqwest::StatusCode;
@@ -63,6 +73,7 @@ mod tests {
     #[test_case("latest")]
     #[test_case("0.1")]
     #[test_case("0.1.0")]
+    #[test_case("=0.1.0"; "exact_version")]
     fn status(version: &str) {
         wrapper(|env| {
             env.fake_release().name("foo").version("0.1.0").create()?;
@@ -88,9 +99,28 @@ mod tests {
         });
     }
 
+    #[test_case("0.1")]
+    #[test_case("*")]
+    fn redirect(version: &str) {
+        wrapper(|env| {
+            env.fake_release().name("foo").version("0.1.0").create()?;
+
+            let redirect = assert_redirect(
+                &format!("/crate/foo/{version}/status.json"),
+                "/crate/foo/0.1.0/status.json",
+                env.frontend(),
+            )?;
+            assert_cache_control(&redirect, CachePolicy::NoStoreMustRevalidate, &env.config());
+            assert_eq!(redirect.headers()["access-control-allow-origin"], "*");
+
+            Ok(())
+        });
+    }
+
     #[test_case("latest")]
     #[test_case("0.1")]
     #[test_case("0.1.0")]
+    #[test_case("=0.1.0"; "exact_version")]
     fn failure(version: &str) {
         wrapper(|env| {
             env.fake_release()
@@ -124,14 +154,15 @@ mod tests {
     #[test_case("bar", "0.1")]
     #[test_case("bar", "0.1.0")]
     // version not found
+    #[test_case("foo", "=0.1.0"; "exact_version")]
     #[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()?;
+            env.fake_release().name("foo").version("0.1.1").create()?;
 
             let response = env
                 .frontend()