test: deduplicate arguments

Author: KSXGitHub

tests/_utils.rs

@@ -143,6 +143,29 @@ impl SampleWorkspace {
         SampleWorkspace(temp)
     }
 
+    pub fn simple_tree_with_some_symlinks_and_hardlinks(sizes: [usize; 5]) -> Self {
+        use std::os::unix::fs::symlink;
+        let workspace = SampleWorkspace::simple_tree_with_some_hardlinks(sizes);
+
+        macro_rules! symlink {
+            ($link_name:literal -> $target:literal) => {
+                let link_name = $link_name;
+                let target = $target;
+                if let Err(error) = symlink(target, workspace.join(link_name)) {
+                    panic!("Failed create symbolic link {link_name} pointing to {target}: {error}");
+                }
+            };
+        }
+
+        symlink!("workspace-itself" -> ".");
+        symlink!("main/main-itself" -> ".");
+        symlink!("main/parent-of-main" -> "..");
+        symlink!("main-mirror" -> "./main");
+        symlink!("sources-mirror" -> "./main/sources");
+
+        workspace
+    }
+
     /// Set up a temporary directory for tests.
     ///
     /// This directory would have a single file being hard-linked multiple times.

tests/hardlinks_deduplication_multi_args.rs

@@ -384,3 +384,237 @@ fn multiple_hardlinks_to_a_single_file() {
         expected_hardlinks_summary.trim_end(),
     );
 }
+
+#[test]
+fn multiple_duplicated_arguments() {
+    #![expect(clippy::identity_op)]
+
+    let sizes = [200_000, 220_000, 310_000, 110_000, 210_000];
+    let workspace = SampleWorkspace::simple_tree_with_some_symlinks_and_hardlinks(sizes);
+
+    let mut tree = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--deduplicate-hardlinks")
+        .with_arg("--json-output")
+        .with_arg("main/sources") // expected to be kept
+        .with_arg("main/main-itself/sources") // expected to be removed
+        .with_arg("workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks") // expected to be kept
+        .with_arg("main/internal-hardlinks") // expected to be removed
+        .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");
+    sort_reflection_by(&mut tree, |a, b| a.name.cmp(&b.name));
+    let tree = tree;
+
+    let file_size = |name: &str| {
+        workspace
+            .join("main/sources")
+            .join(name)
+            .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("main/sources")
+            .join(name)
+            .pipe_as_ref(read_inode_number)
+            .pipe(InodeNumber::from)
+    };
+
+    let shared_paths = |suffices: &[&str]| {
+        suffices
+            .iter()
+            .map(PathBuf::from)
+            .collect::<HashSet<_>>()
+            .pipe(LinkPathListReflection)
+    };
+
+    let actual_size = tree.size;
+    let expected_size = Bytes::new(0)
+        + inode_size("main/sources")
+        + inode_size("main/internal-hardlinks")
+        + file_size("no-hardlinks.txt")
+        + file_size("one-internal-hardlink.txt")
+        + file_size("two-internal-hardlinks.txt")
+        + file_size("one-external-hardlink.txt")
+        + file_size("one-internal-one-external-hardlinks.txt");
+    assert_eq!(actual_size, expected_size);
+
+    let actual_tree = &tree.tree;
+    let expected_tree = {
+        let mut tree = Command::new(PDU)
+            .with_current_dir(&workspace)
+            .with_arg("--quantity=apparent-size")
+            .with_arg("--deduplicate-hardlinks")
+            .with_arg("--json-output")
+            .with_arg("main")
+            .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")
+            .tree;
+        tree.name = "(total)".to_string();
+        tree.size = expected_size;
+        for child in &mut tree.children {
+            let name = match child.name.as_str() {
+                "sources" => "main/sources",
+                "internal-hardlinks" => {
+                    "workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks"
+                }
+                name => panic!("Unexpected name: {name:?}"),
+            };
+            child.name = name.to_string();
+        }
+        sort_reflection_by(&mut tree, |a, b| a.name.cmp(&b.name));
+        tree
+    };
+    assert_eq!(actual_tree, &expected_tree);
+
+    let actual_shared_details: Vec<_> = tree
+        .shared
+        .details
+        .as_ref()
+        .expect("get details")
+        .iter()
+        .cloned()
+        .collect();
+    let expected_shared_details = [
+        ReflectionEntry {
+            ino: file_inode("one-internal-hardlink.txt"),
+            size: file_size("one-internal-hardlink.txt"),
+            links: 1 + 1,
+            paths: shared_paths(&[
+                "main/sources/one-internal-hardlink.txt",
+                "workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks/link-0.txt",
+            ]),
+        },
+        ReflectionEntry {
+            ino: file_inode("two-internal-hardlinks.txt"),
+            size: file_size("two-internal-hardlinks.txt"),
+            links: 1 + 2,
+            paths: shared_paths(&[
+                "main/sources/two-internal-hardlinks.txt",
+                "workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks/link-1a.txt",
+                "workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks/link-1b.txt",
+            ]),
+        },
+        ReflectionEntry {
+            ino: file_inode("one-external-hardlink.txt"),
+            size: file_size("one-external-hardlink.txt"),
+            links: 1 + 1,
+            paths: shared_paths(&["main/sources/one-external-hardlink.txt"]),
+        },
+        ReflectionEntry {
+            ino: file_inode("one-internal-one-external-hardlinks.txt"),
+            size: file_size("one-internal-one-external-hardlinks.txt"),
+            links: 1 + 1 + 1,
+            paths: shared_paths(&[
+                "main/sources/one-internal-one-external-hardlinks.txt",
+                "workspace-itself/main/parent-of-main/main-mirror/internal-hardlinks/link-3a.txt",
+            ]),
+        },
+    ]
+    .into_sorted_by_key(|item| 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(0 + 1 + 1 + 1 + 1)
+        .with_exclusive_inodes(0 + 1 + 1 + 0 + 0)
+        .with_all_links(0 + 2 + 3 + 2 + 3)
+        .with_detected_links(0 + 2 + 3 + 1 + 2)
+        .with_exclusive_links(0 + 2 + 3 + 0 + 0)
+        .with_shared_size(
+            Bytes::new(0)
+                + file_size("one-internal-hardlink.txt")
+                + file_size("two-internal-hardlinks.txt")
+                + file_size("one-external-hardlink.txt")
+                + file_size("one-internal-one-external-hardlinks.txt"),
+        )
+        .with_exclusive_shared_size(
+            Bytes::new(0)
+                + file_size("one-internal-hardlink.txt")
+                + file_size("two-internal-hardlinks.txt"),
+        )
+        .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("main/sources")
+        .with_arg("main/internal-hardlinks")
+        .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(),
+    );
+}