test: exclusive hardlinks only

Author: KSXGitHub

tests/hardlinks_deduplication.rs

@@ -20,6 +20,7 @@ use parallel_disk_usage::{
 };
 use pipe_trait::Pipe;
 use pretty_assertions::assert_eq;
+use rayon::prelude::*;
 use std::{
     collections::HashSet,
     iter,
@@ -546,3 +547,131 @@ fn hardlinks_and_non_hardlinks() {
         expected_hardlinks_summary.trim_end(),
     );
 }
+
+#[test]
+fn exclusive_hardlinks_only() {
+    let files_per_branch = 2 * 4;
+    let workspace =
+        SampleWorkspace::complex_tree_with_shared_and_unique_files(files_per_branch, 100_000);
+
+    let tree = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--min-ratio=0")
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--json-output")
+        .with_arg("--deduplicate-hardlinks")
+        .with_arg("only-hardlinks/exclusive")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text)
+        .pipe_as_ref(serde_json::from_str::<JsonData>)
+        .expect("parse stdout as JsonData")
+        .body
+        .pipe(JsonTree::<Bytes>::try_from)
+        .expect("get tree of bytes");
+
+    let file_size = workspace
+        .join("only-hardlinks/exclusive/file-0.txt")
+        .pipe_as_ref(read_apparent_size)
+        .pipe(Bytes::new);
+
+    let inode_size = |path: &str| {
+        workspace
+            .join(path)
+            .pipe_as_ref(read_apparent_size)
+            .pipe(Bytes::new)
+    };
+
+    let file_inode = |name: &str| {
+        workspace
+            .join("only-hardlinks/exclusive")
+            .join(name)
+            .pipe_as_ref(read_inode_number)
+            .pipe(InodeNumber::from)
+    };
+
+    let shared_paths = |file_names: &[&str]| {
+        file_names
+            .iter()
+            .map(|file_name| PathBuf::from("only-hardlinks/exclusive").join(file_name))
+            .collect::<HashSet<_>>()
+            .pipe(LinkPathListReflection)
+    };
+
+    let actual_size = tree.size;
+    let expected_size = inode_size("only-hardlinks/exclusive") + file_size * files_per_branch;
+    assert_eq!(actual_size, expected_size);
+
+    let actual_shared_details: Vec<_> = tree
+        .shared
+        .details
+        .as_ref()
+        .unwrap()
+        .iter()
+        .cloned()
+        .collect();
+    let expected_shared_details = (0..files_per_branch)
+        .par_bridge()
+        .map(|index| ReflectionEntry {
+            ino: file_inode(&format!("file-{index}.txt")),
+            size: file_size,
+            links: 2,
+            paths: shared_paths(&[&format!("file-{index}.txt"), &format!("link-{index}.txt")]),
+        })
+        .collect::<Vec<_>>()
+        .into_sorted_by_key(|item: &ReflectionEntry<Bytes>| u64::from(item.ino));
+    assert_eq!(actual_shared_details, expected_shared_details);
+
+    let actual_shared_summary = tree.shared.summary;
+    let expected_shared_summary = Summary::default()
+        .with_inodes(files_per_branch)
+        .with_exclusive_inodes(files_per_branch)
+        .with_all_links(2 * files_per_branch as u64)
+        .with_detected_links(2 * files_per_branch)
+        .with_exclusive_links(2 * files_per_branch)
+        .with_shared_size(files_per_branch * file_size)
+        .with_exclusive_shared_size(files_per_branch * file_size)
+        .pipe(Some);
+    assert_eq!(actual_shared_summary, expected_shared_summary);
+
+    let visualization = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--deduplicate-hardlinks")
+        .with_arg("only-hardlinks/exclusive")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text);
+
+    eprintln!("STDOUT:\n{visualization}");
+
+    let actual_hardlinks_summary = visualization
+        .lines()
+        .skip_while(|line| !line.starts_with("Hardlinks detected!"))
+        .join("\n");
+    let expected_hardlinks_summary = {
+        use parallel_disk_usage::size::Size;
+        use std::fmt::Write;
+        let mut summary = String::new();
+        writeln!(
+            summary,
+            "Hardlinks detected! No files have links outside this tree",
+        )
+        .unwrap();
+        writeln!(summary, "* Number of shared inodes: {files_per_branch}").unwrap();
+        writeln!(summary, "* Total number of links: {}", 2 * files_per_branch).unwrap();
+        writeln!(
+            summary,
+            "* Total shared size: {}",
+            (file_size * files_per_branch).display(BytesFormat::MetricUnits),
+        )
+        .unwrap();
+        summary
+    };
+    assert_eq!(
+        actual_hardlinks_summary.trim_end(),
+        expected_hardlinks_summary.trim_end(),
+    );
+}

tests/hardlinks_without_deduplication.rs

@@ -178,3 +178,46 @@ fn hardlinks_and_non_hardlinks() {
     eprintln!("STDOUT:\n{visualization}");
     assert!(!visualization.contains("Hardlinks detected!"));
 }
+
+#[test]
+fn exclusive_hardlinks_only() {
+    let files_per_branch = 2 * 4;
+    let workspace =
+        SampleWorkspace::complex_tree_with_shared_and_unique_files(files_per_branch, 100_000);
+
+    let tree = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--min-ratio=0")
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--json-output")
+        .with_arg("only-hardlinks/exclusive")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text)
+        .pipe_as_ref(serde_json::from_str::<JsonData>)
+        .expect("parse stdout as JsonData")
+        .body
+        .pipe(JsonTree::<Bytes>::try_from)
+        .expect("get tree of bytes");
+
+    let file_size = workspace
+        .join("only-hardlinks/exclusive/file-0.txt")
+        .pipe_as_ref(read_apparent_size)
+        .pipe(Bytes::new);
+
+    let inode_size = |path: &str| {
+        workspace
+            .join(path)
+            .pipe_as_ref(read_apparent_size)
+            .pipe(Bytes::new)
+    };
+
+    let actual_size = tree.size;
+    let expected_size =
+        inode_size("only-hardlinks/exclusive") + 2usize * file_size * files_per_branch;
+    assert_eq!(actual_size, expected_size);
+
+    assert_eq!(tree.shared.details, None);
+    assert_eq!(tree.shared.summary, None);
+}