test: Create --sort=size test cases

Author: DeflateAwning

tests/testenv/mod.rs

@@ -68,6 +68,46 @@ fn create_working_directory(
     Ok(temp_dir)
 }
 
+/// Create the working directory and the test files.
+fn create_test_directory_with_sized_files(
+    directories: &[&'static str],
+    files: &[(&'static str, usize)],
+) -> Result<TempDir, io::Error> {
+    let temp_dir = tempfile::Builder::new().prefix("fd-tests").tempdir()?;
+
+    {
+        let root = temp_dir.path();
+
+        // Pretend that this is a Git repository in order for `.gitignore` files to be respected
+        fs::create_dir_all(root.join(".git"))?;
+
+        for directory in directories {
+            fs::create_dir_all(root.join(directory))?;
+        }
+
+        for (file, size) in files {
+            let fp = fs::File::create(root.join(file))?;
+
+            // Create a file with the specified size.
+            fp.set_len(*size as u64)?;
+        }
+
+        #[cfg(unix)]
+        unix::fs::symlink(root.join("one/two"), root.join("symlink"))?;
+
+        // Note: creating symlinks on Windows requires the `SeCreateSymbolicLinkPrivilege` which
+        // is by default only granted for administrators.
+        #[cfg(windows)]
+        windows::fs::symlink_dir(root.join("one/two"), root.join("symlink"))?;
+
+        fs::File::create(root.join(".fdignore"))?.write_all(b"fdignored.foo")?;
+
+        fs::File::create(root.join(".gitignore"))?.write_all(b"gitignored.foo")?;
+    }
+
+    Ok(temp_dir)
+}
+
 fn create_config_directory_with_global_ignore(ignore_file_content: &str) -> io::Result<TempDir> {
     let config_dir = tempfile::Builder::new().prefix("fd-config").tempdir()?;
     let fd_dir = config_dir.path().join("fd");
@@ -159,6 +199,7 @@ fn trim_lines(s: &str) -> String {
 }
 
 impl TestEnv {
+    /// Create a test environment with a temporary folder, empty files, directories, and symlinks.
     pub fn new(directories: &[&'static str], files: &[&'static str]) -> TestEnv {
         let temp_dir = create_working_directory(directories, files).expect("working directory");
         let fd_exe = find_fd_exe();
@@ -172,6 +213,23 @@ impl TestEnv {
         }
     }
 
+    pub fn new_with_sized_files(
+        directories: &[&'static str],
+        files: &[(&'static str, usize)],
+    ) -> TestEnv {
+        let temp_dir =
+            create_test_directory_with_sized_files(directories, files).expect("working directory");
+        let fd_exe = find_fd_exe();
+
+        TestEnv {
+            temp_dir,
+            fd_exe,
+            normalize_line: false,
+            allow_random_result_order: true,
+            config_dir: None,
+        }
+    }
+
     /// Sets whether output lines should be normalized before comparison.
     ///
     /// Normalization sorts whitespace-separated elements in each line to ensure consistent comparison.

tests/tests.rs

@@ -28,6 +28,18 @@ static DEFAULT_FILES: &[&str] = &[
     "e1 e2",
 ];
 
+static DEFAULT_FILES_WITH_SIZES: &[(&str, usize)] = &[
+    ("a.foo", 437),
+    ("one/b.foo", 823),
+    ("one/two/c.foo", 91),
+    ("one/two/C.Foo2", 614),
+    ("one/two/three/d.foo", 259),
+    ("fdignored.foo", 748),
+    ("gitignored.foo", 183),
+    (".hidden.foo", 502),
+    ("e1 e2", 376),
+];
+
 #[allow(clippy::let_and_return)]
 fn get_absolute_root_path(env: &TestEnv) -> String {
     let path = env
@@ -2049,6 +2061,23 @@ fn test_sort_by_path() {
     );
 }
 
+#[test]
+fn test_sort_by_size() {
+    let te = TestEnv::new_with_sized_files(DEFAULT_DIRS, DEFAULT_FILES_WITH_SIZES)
+        .allow_random_result_order(false);
+
+    // --exec with --sort should produce output in sorted order.
+    te.assert_output(
+        &["foo", "--sort=size"],
+        "one/two/three/directory_foo/
+        one/two/c.foo
+        one/two/three/d.foo
+        a.foo
+        one/two/C.Foo2
+        one/b.foo",
+    );
+}
+
 /// Shell script execution with --sort (--exec)
 #[cfg(not(windows))]
 #[test]
@@ -2058,13 +2087,32 @@ fn test_sort_by_path_with_exec() {
 
     // --exec with --sort should produce output in sorted order.
     te.assert_output(
-        &["foo", "--sort=path", "--exec", "echo", "File: {}"],
-        "File: ./a.foo
-        File: ./one/b.foo
-        File: ./one/two/C.Foo2
-        File: ./one/two/c.foo
-        File: ./one/two/three/d.foo
-        File: ./one/two/three/directory_foo",
+        &["foo", "--sort=path", "--exec", "echo", "Item: {}"],
+        "Item: ./a.foo
+        Item: ./one/b.foo
+        Item: ./one/two/C.Foo2
+        Item: ./one/two/c.foo
+        Item: ./one/two/three/d.foo
+        Item: ./one/two/three/directory_foo",
+    );
+}
+
+/// Shell script execution with --sort (--exec)
+#[cfg(not(windows))]
+#[test]
+fn test_sort_by_size_with_exec() {
+    let te = TestEnv::new_with_sized_files(DEFAULT_DIRS, DEFAULT_FILES_WITH_SIZES)
+        .allow_random_result_order(false);
+
+    // --exec with --sort should produce output in sorted order.
+    te.assert_output(
+        &["foo", "--sort=size", "--exec", "echo", "Item: {}"],
+        "Item: ./one/two/three/directory_foo
+        Item: ./one/two/c.foo
+        Item: ./one/two/three/d.foo
+        Item: ./a.foo
+        Item: ./one/two/C.Foo2
+        Item: ./one/b.foo",
     );
 }