Merge pull request #46 from KSXGitHub/integration-tests

Integration tests

Author: KSXGitHub

Cargo.lock

@@ -82,6 +82,7 @@ features = ["derive"]
 
 [dev-dependencies]
 build-fs-tree = "^0.3.0"
+command-extra = "^1.0.0"
 maplit = "^1.0.2"
 pretty_assertions = "^0.7.2"
 rand = "^0.8.4"

Cargo.toml

@@ -7,6 +7,11 @@ impl<Name, Data: Size> DataTree<Name, Data> {
         &self.name
     }
 
+    /// Get mutable reference to name.
+    pub fn name_mut(&mut self) -> &mut Name {
+        &mut self.name
+    }
+
     /// Extract total disk usage
     pub fn data(&self) -> Data {
         self.data

src/data_tree/getters.rs

@@ -23,7 +23,7 @@ where
 
     /// Recursively cull all descendants whose data are too small relative to root.
     #[cfg(feature = "cli")]
-    pub(crate) fn par_cull_insignificant_data(&mut self, min_ratio: f32)
+    pub fn par_cull_insignificant_data(&mut self, min_ratio: f32)
     where
         Data: Into<u64>,
     {

src/data_tree/retain.rs

@@ -1,4 +1,5 @@
 use build_fs_tree::{dir, file, Build, MergeableFileSystemTree};
+use command_extra::CommandExtra;
 use derive_more::{AsRef, Deref};
 use parallel_disk_usage::{
     data_tree::{DataTree, DataTreeReflection},
@@ -16,6 +17,7 @@ use std::{
     fs::{create_dir, metadata, remove_dir_all, Metadata},
     io::Error,
     path::{Path, PathBuf},
+    process::{Command, Output},
 };
 
 /// Representation of a temporary filesystem item.
@@ -42,6 +44,7 @@ impl Temp {
 }
 
 impl Drop for Temp {
+    /// Delete the created temporary directory.
     fn drop(&mut self) {
         let path = &self.0;
         if let Err(error) = remove_dir_all(path) {
@@ -55,6 +58,7 @@ impl Drop for Temp {
 pub struct SampleWorkspace(Temp);
 
 impl Default for SampleWorkspace {
+    /// Set up a temporary directory for tests.
     fn default() -> Self {
         let temp = Temp::new_dir().expect("create working directory for sample workspace");
 
@@ -202,3 +206,116 @@ where
         }),
     );
 }
+
+/// Path to the `pdu` executable
+pub const PDU: &str = env!("CARGO_BIN_EXE_pdu");
+
+/// Representation of a `pdu` command.
+#[derive(Debug, Default, Clone)]
+pub struct CommandRepresentation<'a> {
+    args: Vec<&'a str>,
+}
+
+impl<'a> CommandRepresentation<'a> {
+    /// Add an argument.
+    pub fn arg(mut self, arg: &'a str) -> Self {
+        self.args.push(arg);
+        self
+    }
+}
+
+/// List of `pdu` commands.
+#[derive(Debug, Clone, AsRef, Deref)]
+pub struct CommandList<'a>(Vec<CommandRepresentation<'a>>);
+
+impl<'a> Default for CommandList<'a> {
+    /// Initialize a list with one `pdu` command.
+    fn default() -> Self {
+        CommandRepresentation::default()
+            .pipe(|x| vec![x])
+            .pipe(CommandList)
+    }
+}
+
+impl<'a> CommandList<'a> {
+    /// Duplicate the list with a flag argument.
+    ///
+    /// The resulting list would include the original list with the flag
+    /// followed by the original list without the flag.
+    pub fn flag_matrix(self, name: &'a str) -> Self {
+        Self::assert_flag(name);
+        let CommandList(list) = self;
+        list.clone()
+            .into_iter()
+            .map(|cmd| cmd.arg(name))
+            .chain(list)
+            .collect::<Vec<_>>()
+            .pipe(CommandList)
+    }
+
+    /// Duplicate the list with one or many option argument(s).
+    ///
+    /// The resulting list would include the original list with the option(s)
+    /// followed by the original list without the option(s).
+    pub fn option_matrix<const LEN: usize>(self, name: &'a str, values: [&'a str; LEN]) -> Self {
+        Self::assert_flag(name);
+        let CommandList(tail) = self;
+        let mut head: Vec<_> = values
+            .iter()
+            .copied()
+            .flat_map(|value| {
+                tail.clone()
+                    .into_iter()
+                    .map(move |cmd| cmd.arg(name).arg(value))
+            })
+            .collect();
+        head.extend(tail);
+        CommandList(head)
+    }
+
+    /// Create a list of `pdu` [command](Command).
+    pub fn commands(&'a self) -> impl Iterator<Item = Command> + 'a {
+        self.iter()
+            .map(|cmd| Command::new(PDU).with_args(&cmd.args))
+    }
+
+    /// Make sure a flag name has valid syntax.
+    fn assert_flag(name: &str) {
+        match name.len() {
+            0 | 1 => panic!("{:?} is not a valid flag", name),
+            2 => assert!(name.starts_with('-'), "{:?} is not a valid flag", name),
+            _ => assert!(name.starts_with("--"), "{:?} is not a valid flag", name),
+        }
+    }
+}
+
+/// Make sure that status code is 0, print stderr if it's not empty,
+/// and turn stdin into a string.
+pub fn stdout_text(
+    Output {
+        status,
+        stdout,
+        stderr,
+    }: Output,
+) -> String {
+    inspect_stderr(&stderr);
+    assert!(
+        status.success(),
+        "progress exits with non-zero status: {:?}",
+        status
+    );
+    stdout
+        .pipe(String::from_utf8)
+        .expect("parse stdout as UTF-8")
+        .trim_end()
+        .to_string()
+}
+
+/// Print stderr if it's not empty.
+pub fn inspect_stderr(stderr: &[u8]) {
+    let text = String::from_utf8_lossy(stderr);
+    let text = text.trim();
+    if !text.is_empty() {
+        eprintln!("STDERR:\n{}\n", text);
+    }
+}

tests/_utils.rs

@@ -1,4 +1,5 @@
 #![cfg(feature = "cli")]
+
 use parallel_disk_usage::args::fraction::{ConversionError::*, Fraction, FromStrError::*};
 use pretty_assertions::assert_eq;
 

tests/args_fraction.rs

@@ -0,0 +1,66 @@
+#![cfg(feature = "cli")]
+
+pub mod _utils;
+pub use _utils::*;
+
+use command_extra::CommandExtra;
+use pipe_trait::Pipe;
+use pretty_assertions::assert_eq;
+use std::process::{Command, Output, Stdio};
+
+fn stdio(command: Command) -> Command {
+    command
+        .with_stdin(Stdio::null())
+        .with_stdout(Stdio::piped())
+        .with_stderr(Stdio::piped())
+}
+
+#[test]
+fn min_ratio_1() {
+    let workspace = SampleWorkspace::default();
+    let Output {
+        status,
+        stdout,
+        stderr,
+    } = Command::new(PDU)
+        .with_current_dir(workspace.as_path())
+        .with_arg("--min-ratio=1")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command");
+    let stderr = String::from_utf8(stderr).expect("parse stderr as UTF-8");
+    let stderr = stderr.trim();
+    dbg!(&status);
+    eprintln!("STDERR:\n{}\n", stderr);
+    assert!(!status.success());
+    assert_eq!(
+        stderr,
+        "error: Invalid value for '--min-ratio <min-ratio>': greater than or equal to 1"
+    );
+    assert_eq!(&stdout, &[] as &[u8]);
+}
+
+#[test]
+fn max_depth_0() {
+    let workspace = SampleWorkspace::default();
+    let Output {
+        status,
+        stdout,
+        stderr,
+    } = Command::new(PDU)
+        .with_current_dir(workspace.as_path())
+        .with_arg("--max-depth=0")
+        .pipe(stdio)
+        .output()
+        .expect("spawn command");
+    let stderr = String::from_utf8(stderr).expect("parse stderr as UTF-8");
+    let stderr = stderr.trim();
+    dbg!(&status);
+    eprintln!("STDERR:\n{}\n", stderr);
+    assert!(!status.success());
+    assert_eq!(
+        stderr,
+        "error: Invalid value for '--max-depth <max-depth>': number would be zero for non-zero type"
+    );
+    assert_eq!(&stdout, &[] as &[u8]);
+}

tests/cli_errors.rs

@@ -0,0 +1,38 @@
+#![cfg(feature = "cli")]
+
+pub mod _utils;
+pub use _utils::*;
+
+use command_extra::CommandExtra;
+use std::process::Stdio;
+
+/// There are branches of similar shapes in `/src/app.rs` that call
+/// the `sub!` macro. This test suite is to ensure that no combination
+/// of variant is left out by programmer's mistake.
+#[test]
+fn flag_combinations() {
+    #[cfg(unix)]
+    let quantity = ["len", "blksize", "blocks"];
+    #[cfg(windows)]
+    let quantity = ["len"];
+
+    let list = CommandList::default()
+        .option_matrix("--quantity", quantity)
+        .flag_matrix("--progress");
+
+    for command in list.commands() {
+        dbg!(&command);
+        let workspace = SampleWorkspace::default();
+        dbg!(workspace.as_path());
+        let output = command
+            .with_current_dir(workspace.as_path())
+            .with_stdin(Stdio::null())
+            .with_stdout(Stdio::null())
+            .with_stderr(Stdio::piped())
+            .output()
+            .expect("execute command");
+        inspect_stderr(&output.stderr);
+        let status = output.status;
+        assert!(status.success(), "status: {:?}", status.code())
+    }
+}