test: mixing exclusive-only and external-only

Author: KSXGitHub

tests/hardlinks_deduplication.rs

@@ -675,3 +675,168 @@ fn exclusive_hardlinks_only() {
         expected_hardlinks_summary.trim_end(),
     );
 }
+
+#[test]
+fn exclusive_only_and_external_only_hardlinks() {
+    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/mixed")
+        .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/mixed/link0-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/mixed")
+            .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/mixed").join(file_name))
+            .collect::<HashSet<_>>()
+            .pipe(LinkPathListReflection)
+    };
+
+    let actual_size = tree.size;
+    let expected_size = inode_size("only-hardlinks/mixed") + 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 = iter::empty()
+        .par_bridge()
+        .chain(
+            (0..(files_per_branch / 2))
+                .par_bridge()
+                .map(|index| ReflectionEntry {
+                    ino: file_inode(&format!("link0-{index}.txt")),
+                    size: file_size,
+                    links: 2,
+                    paths: shared_paths(&[&format!("link0-{index}.txt")]),
+                }),
+        )
+        .chain(
+            ((files_per_branch / 2)..files_per_branch)
+                .par_bridge()
+                .map(|index| ReflectionEntry {
+                    ino: file_inode(&format!("link0-{index}.txt")),
+                    size: file_size,
+                    links: 2,
+                    paths: shared_paths(&[
+                        &format!("link0-{index}.txt"),
+                        &format!("link1-{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 / 2)
+        .with_all_links(2 * files_per_branch as u64)
+        .with_detected_links(files_per_branch + files_per_branch / 2)
+        .with_exclusive_links(files_per_branch * 2 / 2)
+        .with_shared_size(files_per_branch * file_size)
+        .with_exclusive_shared_size((files_per_branch / 2) * 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/mixed")
+        .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! Some files have links outside this tree",
+        )
+        .unwrap();
+        writeln!(
+            summary,
+            "* Number of shared inodes: {total} total, {exclusive} exclusive",
+            total = expected_shared_summary.unwrap().inodes,
+            exclusive = expected_shared_summary.unwrap().exclusive_inodes,
+        )
+        .unwrap();
+        writeln!(
+            summary,
+            "* Total number of links: {total} total, {detected} detected, {exclusive} exclusive",
+            total = expected_shared_summary.unwrap().all_links,
+            detected = expected_shared_summary.unwrap().detected_links,
+            exclusive = expected_shared_summary.unwrap().exclusive_links,
+        )
+        .unwrap();
+        writeln!(
+            summary,
+            "* Total shared size: {total} total, {exclusive} exclusive",
+            total = expected_shared_summary
+                .unwrap()
+                .shared_size
+                .display(BytesFormat::MetricUnits),
+            exclusive = expected_shared_summary
+                .unwrap()
+                .exclusive_shared_size
+                .display(BytesFormat::MetricUnits),
+        )
+        .unwrap();
+        summary
+    };
+    assert_eq!(
+        actual_hardlinks_summary.trim_end(),
+        expected_hardlinks_summary.trim_end(),
+    );
+}

tests/hardlinks_without_deduplication.rs

@@ -221,3 +221,57 @@ fn exclusive_hardlinks_only() {
     assert_eq!(tree.shared.details, None);
     assert_eq!(tree.shared.summary, None);
 }
+
+#[test]
+fn exclusive_only_and_external_only_hardlinks() {
+    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/mixed")
+        .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/mixed/link0-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/mixed") + file_size * (files_per_branch + files_per_branch / 2);
+    assert_eq!(actual_size, expected_size);
+
+    assert_eq!(tree.shared.details, None);
+    assert_eq!(tree.shared.summary, None);
+
+    let visualization = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--quantity=apparent-size")
+        .with_arg("only-hardlinks/mixed")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command")
+        .pipe(stdout_text);
+    eprintln!("STDOUT:\n{visualization}");
+    assert!(!visualization.contains("Hardlinks detected!"));
+}