Update redirect_map

Author: thomas-zahner

lychee-bin/src/formatters/stats/detailed.rs

@@ -153,7 +153,7 @@ https://original.dev/ --> https://suggestion.dev/
 
 
 Redirects in https://example.com/
-https://redirected.dev/ (at 1:1) | 200 OK | Followed 2 redirects. Redirects: https://1.dev/ --[308]--> https://2.dev/ --[308]--> http://redirected.dev/
+https://1.dev/ --[308]--> https://2.dev/ --[308]--> http://redirected.dev/
 
 
 📊 Per-host Statistics

lychee-bin/src/formatters/stats/json.rs

@@ -84,32 +84,17 @@ mod tests {
   "redirect_map": {
     "https://example.com/": [
       {
-        "url": "https://redirected.dev/",
-        "status": {
-          "text": "200 OK",
-          "code": 200,
-          "redirects": {
-            "origin": "https://1.dev/",
-            "redirects": [
-              {
-                "url": "https://2.dev/",
-                "code": 308
-              },
-              {
-                "url": "http://redirected.dev/",
-                "code": 308
-              }
-            ]
+        "origin": "https://1.dev/",
+        "redirects": [
+          {
+            "url": "https://2.dev/",
+            "code": 308
+          },
+          {
+            "url": "http://redirected.dev/",
+            "code": 308
           }
-        },
-        "span": {
-          "line": 1,
-          "column": 1
-        },
-        "duration": {
-          "secs": 1,
-          "nanos": 0
-        }
+        ]
       }
     ]
   },

lychee-bin/src/formatters/stats/junit.rs

@@ -50,10 +50,8 @@ fn junit_testcases(stats: ResponseStats) -> Vec<TestCase> {
     let skipped = junit_testcases_group(stats.excluded_map, TestCaseStatus::skipped(), "Excluded");
     let successes =
         junit_testcases_group(stats.success_map, TestCaseStatus::success(), "Successful");
-    let redirected =
-        junit_testcases_group(stats.redirect_map, TestCaseStatus::success(), "Redirected");
 
-    [failures, skipped, successes, redirected].concat()
+    [failures, skipped, successes].concat()
 }
 
 fn junit_testcases_group(
@@ -110,8 +108,8 @@ mod tests {
         assert_eq!(
             result,
             r#"<?xml version="1.0" encoding="UTF-8"?>
-<testsuites name="lychee link check results" tests="4" failures="1" errors="0">
-    <testsuite name="lychee link check results" tests="4" disabled="1" errors="0" failures="1">
+<testsuites name="lychee link check results" tests="3" failures="1" errors="0">
+    <testsuite name="lychee link check results" tests="3" disabled="1" errors="0" failures="1">
         <testcase name="Failed https://github.com/mre/idiomatic-rust-doesnt-exist-man" time="1.000" file="https://example.com/" line="1">
             <failure message="https://github.com/mre/idiomatic-rust-doesnt-exist-man (at 1:1) | 404 Not Found"/>
             <system-out>https://github.com/mre/idiomatic-rust-doesnt-exist-man (at 1:1) | 404 Not Found</system-out>
@@ -123,9 +121,6 @@ mod tests {
         <testcase name="Successful https://success.org/" time="1.000" file="https://example.com/">
             <system-out>https://success.org/</system-out>
         </testcase>
-        <testcase name="Redirected https://redirected.dev/" time="1.000" file="https://example.com/" line="1">
-            <system-out>https://redirected.dev/ (at 1:1) | 200 OK | Followed 2 redirects. Redirects: https://1.dev/ --[308]--&gt; https://2.dev/ --[308]--&gt; http://redirected.dev/</system-out>
-        </testcase>
     </testsuite>
 </testsuites>
 "#

lychee-bin/src/formatters/stats/markdown.rs

@@ -116,15 +116,12 @@ impl Display for MarkdownResponseStats {
             markdown_response(response).map_err(|_| fmt::Error)
         })?;
 
-        write_stats_per_input(f, "Redirects", &stats.redirect_map, |response| {
-            markdown_response(response).map_err(|_| fmt::Error)
+        write_stats_per_input(f, "Redirects", &stats.redirect_map, |redirects| {
+            Ok(format!("* {redirects}"))
         })?;
 
         write_stats_per_input(f, "Suggestions", &stats.suggestion_map, |suggestion| {
-            Ok(format!(
-                "* {} --> {}",
-                suggestion.original, suggestion.suggestion
-            ))
+            Ok(format!("* {suggestion}"))
         })?;
 
         Ok(())
@@ -284,7 +281,7 @@ mod tests {
 
 ### Redirects in https://example.com/
 
-* [200] <https://redirected.dev/> (at 1:1) | 200 OK | Followed 2 redirects. Redirects: https://1.dev/ --[308]--> https://2.dev/ --[308]--> http://redirected.dev/
+* https://1.dev/ --[308]--> https://2.dev/ --[308]--> http://redirected.dev/
 
 ## Suggestions per input
 

lychee-bin/src/formatters/stats/mod.rs

@@ -161,15 +161,7 @@ fn get_dummy_stats() -> OutputStats {
         code: StatusCode::PERMANENT_REDIRECT,
     });
 
-    let redirect_map = HashMap::from([(
-        source.clone(),
-        HashSet::from([ResponseBody {
-            uri: "https://redirected.dev".try_into().unwrap(),
-            status: Status::Redirected(Box::new(Status::Ok(StatusCode::OK)), redirects),
-            span: SPAN,
-            duration: DURATION,
-        }]),
-    )]);
+    let redirect_map = HashMap::from([(source.clone(), HashSet::from([redirects]))]);
 
     let response_stats = ResponseStats {
         total: 2,

lychee-bin/src/formatters/stats/response.rs

@@ -6,7 +6,7 @@ use std::{
     time::Duration,
 };
 
-use lychee_lib::{CacheStatus, InputSource, Response, ResponseBody, Status};
+use lychee_lib::{CacheStatus, InputSource, Redirects, Response, ResponseBody, Status};
 use serde::Serialize;
 
 use crate::formatters::suggestion::Suggestion;
@@ -48,10 +48,10 @@ pub(crate) struct ResponseStats {
     pub(crate) error_map: HashMap<InputSource, HashSet<ResponseBody>>,
     /// Timed out responses
     pub(crate) timeout_map: HashMap<InputSource, HashSet<ResponseBody>>,
-    /// Replacement suggestions for failed responses (if `--suggest` is enabled)
+    /// [`Suggestion`]s for failed responses (if `--suggest` is enabled)
     pub(crate) suggestion_map: HashMap<InputSource, HashSet<Suggestion>>,
-    /// Redirected responses (if `detailed_stats` is enabled)
-    pub(crate) redirect_map: HashMap<InputSource, HashSet<ResponseBody>>,
+    /// All [`Redirects`] independent of the response status (if `detailed_stats` is enabled)
+    pub(crate) redirect_map: HashMap<InputSource, HashSet<Redirects>>,
     /// Excluded responses (if `detailed_stats` is enabled)
     pub(crate) excluded_map: HashMap<InputSource, HashSet<ResponseBody>>,
     /// The time it took to perform the full run
@@ -107,16 +107,28 @@ impl ResponseStats {
     fn add_response_status(&mut self, response: Response) {
         let status = response.status();
         let source: InputSource = response.source().clone();
-        let status_map_entry = match status {
-            _ if status.is_timeout() => self.timeout_map.entry(source).or_default(),
-            _ if status.is_error() => self.error_map.entry(source).or_default(),
-            Status::Ok(_) if self.detailed_stats => self.success_map.entry(source).or_default(),
-            Status::Excluded if self.detailed_stats => self.excluded_map.entry(source).or_default(),
-            Status::Redirected(_, _) if self.detailed_stats => {
-                self.redirect_map.entry(source).or_default()
-            }
-            _ => return,
+
+        if self.detailed_stats
+            && let Some(redirects) = status.redirects()
+        {
+            self.redirect_map
+                .entry(source.clone())
+                .or_default()
+                .insert(redirects.clone());
+        }
+
+        let status_map_entry = if status.is_timeout() {
+            self.timeout_map.entry(source).or_default()
+        } else if status.is_error() {
+            self.error_map.entry(source).or_default()
+        } else if status.is_excluded() {
+            self.excluded_map.entry(source).or_default()
+        } else if status.is_success() && self.detailed_stats {
+            self.success_map.entry(source).or_default()
+        } else {
+            return;
         };
+
         status_map_entry.insert(response.into_body());
     }
 

lychee-bin/tests/cli.rs

@@ -80,11 +80,12 @@ mod cli {
 
     /// Parse lychee's json output to [`Value`].
     /// Additionally remove the non-deterministic duration to simplify subsequent assertions
-    fn stdout_to_json(stdout: &[u8]) -> Result<Value> {
-        let mut output_json = serde_json::from_slice::<Value>(stdout)?;
+    fn stdout_to_json(stdout: &[u8]) -> Value {
+        let mut output_json =
+            serde_json::from_slice::<Value>(stdout).expect("stdout is not valid JSON");
         remove_nondeterministic_duration(&mut output_json["success_map"]);
-        remove_nondeterministic_duration(&mut output_json["redirect_map"]);
-        return Ok(output_json);
+        remove_nondeterministic_duration(&mut output_json["excluded_map"]);
+        return output_json;
 
         fn remove_nondeterministic_duration(value: &mut Value) {
             let map = value.as_object_mut().expect("Expected object");
@@ -197,7 +198,7 @@ mod cli {
             .assert()
             .success();
         let output = cmd.output().unwrap();
-        let output_json = stdout_to_json(&output.stdout)?;
+        let output_json = stdout_to_json(&output.stdout);
 
         // Check that the output is valid JSON
         assert!(output_json.is_object());
@@ -257,7 +258,7 @@ mod cli {
         let output = cmd.output()?;
 
         // Check that the output is valid JSON
-        stdout_to_json(&output.stdout)?;
+        stdout_to_json(&output.stdout);
         Ok(())
     }
 
@@ -276,7 +277,7 @@ mod cli {
         let output = cmd.output()?;
 
         // Parse site error status from the error_map
-        let output_json = stdout_to_json(&output.stdout)?;
+        let output_json = stdout_to_json(&output.stdout);
         let site_error_status =
             &output_json["error_map"][&test_path.to_str().unwrap()][0]["status"];
 
@@ -901,24 +902,20 @@ mod cli {
 
     /// Test excludes
     #[test]
-    fn test_exclude_wildcard() -> Result<()> {
+    fn test_exclude_wildcard() {
         let test_path = fixtures_path!().join("TEST.md");
-
         cargo_bin_cmd!()
             .arg(test_path)
             .arg("--exclude")
             .arg(".*")
             .assert()
             .success()
             .stdout(contains("12 Excluded"));
-
-        Ok(())
     }
 
     #[test]
-    fn test_exclude_multiple_urls() -> Result<()> {
+    fn test_exclude_multiple_urls() {
         let test_path = fixtures_path!().join("TEST.md");
-
         cargo_bin_cmd!()
             .arg(test_path)
             .arg("--exclude")
@@ -928,8 +925,6 @@ mod cli {
             .assert()
             .success()
             .stdout(contains("4 Excluded"));
-
-        Ok(())
     }
 
     #[tokio::test]
@@ -1913,7 +1908,7 @@ The config file should contain every possible key for documentation purposes."
     }
 
     #[test]
-    fn test_erroneous_remap_with_redirect_real_world() {
+    fn test_erroneous_remap_with_redirect() {
         cargo_bin_cmd!()
             .arg("-vv")
             .arg("--remap")
@@ -1948,6 +1943,42 @@ The config file should contain every possible key for documentation purposes."
             .stdout(contains("The given URI is invalid, check URI syntax: https://example.com/"));
     }
 
+    #[test]
+    fn test_remap_to_excluded() {
+        let stdout = cargo_bin_cmd!()
+            .arg("--remap=aaa bbb")
+            .arg("--exclude=bbb")
+            .arg("--format=json")
+            .arg("-")
+            .write_stdin("https://aaa.com")
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone();
+
+        let json = stdout_to_json(&stdout);
+        assert_eq!(json["remaps"], 1);
+        assert_eq!(json["excludes"], 1);
+        assert_eq!(
+            json["excluded_map"],
+            json!({
+            "stdin": [
+              {
+                "url": "https://bbb.com/",
+                "status": {
+                  "text": "Excluded",
+                  "details": "This is due to your 'exclude' values | Remapped: https://aaa.com/ --> https://bbb.com/"
+                },
+                "span": {
+                  "line": 1,
+                  "column": 1
+                },
+              }
+            ]})
+        );
+    }
+
     #[test]
     fn test_excluded_paths_regex() {
         let test_path = fixtures_path!().join("exclude-path");
@@ -2574,7 +2605,8 @@ The config file should contain every possible key for documentation purposes."
             assert_eq!(json["total"], 1);
             assert_eq!(json["redirects"], 1); // there was one redirect
             assert_eq!(json["successful"], 1); // which resolved to a success
-            assert_eq!(json["redirect_map"], json!({}));
+            assert_eq!(json["redirect_map"], json!({})); // suppressed in non-verbose mode
+            assert_eq!(json["success_map"], json!({})); // suppressed in non-verbose mode
         })
         .await;
 
@@ -2587,6 +2619,17 @@ The config file should contain every possible key for documentation purposes."
             assert_eq!(
                 json["redirect_map"],
                 json!({
+                "stdin":[{
+                    "origin": redirect_url,
+                    "redirects": [{
+                        "code": 308,
+                        "url": ok_url,
+                    }]
+                }]})
+            );
+            assert_eq!(
+                json["success_map"],
+                json!({
                 "stdin":[{
                     "span": {
                         "column": 1,
@@ -2630,7 +2673,7 @@ The config file should contain every possible key for documentation purposes."
 
             let stderr = str::from_utf8(&output.stderr).unwrap().to_string();
 
-            (stdout_to_json(&output.stdout).unwrap(), stderr)
+            (stdout_to_json(&output.stdout), stderr)
         }
     }
 

lychee-lib/src/types/status.rs

@@ -229,7 +229,7 @@ impl Status {
         matches!(self.innermost(), Status::UnknownStatusCode(_))
     }
 
-    /// Extract the innermost [`Status`], handling nested variants.
+    /// Extract the innermost [`Status`], handling nested variants
     #[must_use]
     pub const fn innermost(&self) -> &Self {
         match self {
@@ -238,6 +238,16 @@ impl Status {
         }
     }
 
+    /// Extract (potentially nested) [`Redirects`]
+    #[must_use]
+    pub const fn redirects(&self) -> Option<&Redirects> {
+        match self {
+            Status::Remapped(inner, _) => inner.redirects(),
+            Status::Redirected(_, redirects) => Some(redirects),
+            _ => None,
+        }
+    }
+
     /// Return a unicode icon to visualize the status
     #[must_use]
     pub const fn icon(&self) -> &str {