test: multiple hardlinks to a single file

Author: KSXGitHub

tests/_utils.rs

@@ -16,7 +16,7 @@ use rand::{distr::Alphanumeric, rng, Rng};
 use rayon::prelude::*;
 use std::{
     env::temp_dir,
-    fs::{create_dir, metadata, remove_dir_all},
+    fs::{create_dir, metadata, remove_dir_all, symlink_metadata},
     io::Error,
     path::{Path, PathBuf},
     process::{Command, Output},
@@ -96,6 +96,28 @@ impl Default for SampleWorkspace {
     }
 }
 
+/// POSIX-exclusive functions
+#[cfg(unix)]
+impl SampleWorkspace {
+    /// Set up a temporary directory for tests.
+    ///
+    /// This directory would have a single file being hard-linked multiple times.
+    pub fn multiple_hardlinks_to_a_single_file() -> Self {
+        use std::fs::{hard_link, write as write_file};
+        let temp = Temp::new_dir().expect("create working directory for sample workspace");
+
+        let file_path = temp.join("file.txt");
+        write_file(&file_path, "a".repeat(100_000)).expect("create file.txt");
+
+        for num in 0..10 {
+            hard_link(&file_path, temp.join(format!("link.{num}")))
+                .unwrap_or_else(|error| panic!("Failed to create 'link.{num}': {error}"));
+        }
+
+        SampleWorkspace(temp)
+    }
+}
+
 /// Make the snapshot of a [`TreeReflection`] testable.
 ///
 /// The real filesystem is often messy, causing `children` to mess up its order.
@@ -332,3 +354,10 @@ pub fn inspect_stderr(stderr: &[u8]) {
         eprintln!("STDERR:\n{text}\n");
     }
 }
+
+/// Read [apparent size](std::fs::Metadata::len) of a path.
+pub fn read_apparent_size(path: &Path) -> u64 {
+    path.pipe(symlink_metadata)
+        .unwrap_or_else(|error| panic!("Can't read metadata at {path:?}: {error}"))
+        .len()
+}

tests/deduplicate_hardlinks.rs

@@ -0,0 +1,85 @@
+#![cfg(unix)] // This feature is not available in Windows
+#![cfg(feature = "cli")]
+
+pub mod _utils;
+pub use _utils::*;
+
+use command_extra::CommandExtra;
+use parallel_disk_usage::{
+    json_data::{JsonData, UnitAndTree},
+    size::Bytes,
+};
+use pipe_trait::Pipe;
+use pretty_assertions::assert_eq;
+use std::{
+    ops::{Add, Mul},
+    process::{Command, Stdio},
+};
+
+fn stdio(command: Command) -> Command {
+    command
+        .with_stdin(Stdio::null())
+        .with_stdout(Stdio::piped())
+        .with_stderr(Stdio::piped())
+}
+
+#[test]
+fn deduplicate_multiple_hardlinks_to_a_single_file() {
+    let workspace = SampleWorkspace::multiple_hardlinks_to_a_single_file();
+
+    let json = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--deduplicate-hardlinks")
+        .with_arg("--json-output")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text)
+        .pipe_as_ref(serde_json::from_str::<JsonData>)
+        .expect("parse stdout as JsonData");
+
+    let actual_size = match &json.unit_and_tree {
+        UnitAndTree::Blocks(_) => panic!("expecting Bytes, but got {:?}", &json.unit_and_tree),
+        UnitAndTree::Bytes(tree) => tree.size,
+    };
+
+    let expected_size = workspace
+        .join("file.txt")
+        .pipe_as_ref(read_apparent_size)
+        .mul(2) // TODO: fix the algorithm and remove this line
+        .add(read_apparent_size(&workspace))
+        .pipe(Bytes::new);
+
+    assert_eq!(actual_size, expected_size);
+}
+
+#[test]
+fn do_not_deduplicate_multiple_hardlinks_to_a_single_file() {
+    let workspace = SampleWorkspace::multiple_hardlinks_to_a_single_file();
+
+    let json = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--json-output")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text)
+        .pipe_as_ref(serde_json::from_str::<JsonData>)
+        .expect("parse stdout as JsonData");
+
+    let actual_size = match &json.unit_and_tree {
+        UnitAndTree::Blocks(_) => panic!("expecting Bytes, but got {:?}", &json.unit_and_tree),
+        UnitAndTree::Bytes(tree) => tree.size,
+    };
+
+    let expected_size = workspace
+        .join("file.txt")
+        .pipe_as_ref(read_apparent_size)
+        .mul(11)
+        .add(read_apparent_size(&workspace))
+        .pipe(Bytes::new);
+
+    assert_eq!(actual_size, expected_size);
+}