mirror of
https://github.com/sharkdp/fd.git
synced 2024-11-19 02:10:34 +01:00
8fc3a83d92
Previously, we were using the relative path to extract the search string. For the current directory, the returned relative path was equal to `""`. This is why the current directory did not show in the search results (see #81). This commit also changes the way that `--full-path` works, which was previously working on relative paths. It seems more useful to search the absolute path, though. Otherwise, search results could change just by calling fd (with a given search path) from a different directory.
410 lines
8 KiB
Rust
410 lines
8 KiB
Rust
//! Integration tests for the CLI interface of fd.
|
|
|
|
mod testenv;
|
|
|
|
use testenv::TestEnv;
|
|
|
|
/// Simple tests
|
|
#[test]
|
|
fn test_simple() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(&["a.foo"], "a.foo");
|
|
te.assert_output(&["b.foo"], "one/b.foo");
|
|
te.assert_output(&["d.foo"], "one/two/three/d.foo");
|
|
|
|
te.assert_output(
|
|
&["foo"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&[],
|
|
"a.foo
|
|
one
|
|
one/b.foo
|
|
one/two
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo
|
|
symlink",
|
|
);
|
|
}
|
|
|
|
/// Explicit root path
|
|
#[test]
|
|
fn test_explicit_root_path() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["foo", "one"],
|
|
"one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["foo", "one/two/three"],
|
|
"one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output_subdirectory(
|
|
"one/two",
|
|
&["foo", "../../"],
|
|
"../../a.foo
|
|
../b.foo
|
|
c.foo
|
|
C.Foo2
|
|
three/d.foo
|
|
three/directory_foo",
|
|
);
|
|
|
|
te.assert_output_subdirectory(
|
|
"one/two/three",
|
|
&["", ".."],
|
|
".
|
|
../c.foo
|
|
../C.Foo2
|
|
d.foo
|
|
directory_foo",
|
|
);
|
|
}
|
|
|
|
/// Regex searches
|
|
#[test]
|
|
fn test_regex_searches() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["[a-c].foo"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--case-sensitive", "[a-c].foo"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo",
|
|
);
|
|
}
|
|
|
|
/// Smart case
|
|
#[test]
|
|
fn test_smart_case() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["c.foo"],
|
|
"one/two/c.foo
|
|
one/two/C.Foo2",
|
|
);
|
|
|
|
te.assert_output(&["C.Foo"], "one/two/C.Foo2");
|
|
|
|
te.assert_output(&["Foo"], "one/two/C.Foo2");
|
|
}
|
|
|
|
/// Case sensitivity (--case-sensitive)
|
|
#[test]
|
|
fn test_case_sensitive() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(&["--case-sensitive", "c.foo"], "one/two/c.foo");
|
|
|
|
te.assert_output(&["--case-sensitive", "C.Foo"], "one/two/C.Foo2");
|
|
|
|
te.assert_output(
|
|
&["--ignore-case", "--case-sensitive", "C.Foo"],
|
|
"one/two/C.Foo2",
|
|
);
|
|
}
|
|
|
|
/// Case insensitivity (--ignore-case)
|
|
#[test]
|
|
fn test_case_insensitive() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--ignore-case", "C.Foo"],
|
|
"one/two/c.foo
|
|
one/two/C.Foo2",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--case-sensitive", "--ignore-case", "C.Foo"],
|
|
"one/two/c.foo
|
|
one/two/C.Foo2",
|
|
);
|
|
}
|
|
|
|
/// Full path search (--full-path)
|
|
#[test]
|
|
fn test_full_path() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--full-path", "three.*foo"],
|
|
"one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
}
|
|
|
|
/// Hidden files (--hidden)
|
|
#[test]
|
|
fn test_hidden() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--hidden", "foo"],
|
|
".hidden.foo
|
|
a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
}
|
|
|
|
/// Ignored files (--no-ignore)
|
|
#[test]
|
|
fn test_no_ignore() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--no-ignore", "foo"],
|
|
"a.foo
|
|
ignored.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--hidden", "--no-ignore", "foo"],
|
|
".hidden.foo
|
|
a.foo
|
|
ignored.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
}
|
|
|
|
/// Ignored files with ripgrep aliases (-u / -uu)
|
|
#[test]
|
|
fn test_no_ignore_aliases() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["-u", "foo"],
|
|
"a.foo
|
|
ignored.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["-uu", "foo"],
|
|
".hidden.foo
|
|
a.foo
|
|
ignored.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo
|
|
one/two/three/directory_foo",
|
|
);
|
|
}
|
|
|
|
/// Symlinks (--follow)
|
|
#[test]
|
|
fn test_follow() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--follow", "c.foo"],
|
|
"one/two/c.foo
|
|
one/two/C.Foo2
|
|
symlink/c.foo
|
|
symlink/C.Foo2",
|
|
);
|
|
}
|
|
|
|
/// Null separator (--print0)
|
|
#[test]
|
|
fn test_print0() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--print0", "foo"],
|
|
"a.fooNULL
|
|
one/b.fooNULL
|
|
one/two/C.Foo2NULL
|
|
one/two/c.fooNULL
|
|
one/two/three/d.fooNULL
|
|
one/two/three/directory_fooNULL",
|
|
);
|
|
}
|
|
|
|
/// Maximum depth (--max-depth)
|
|
#[test]
|
|
fn test_max_depth() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--max-depth", "3"],
|
|
"a.foo
|
|
one
|
|
one/b.foo
|
|
one/two
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three
|
|
symlink",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--max-depth", "2"],
|
|
"a.foo
|
|
one
|
|
one/b.foo
|
|
one/two
|
|
symlink",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--max-depth", "1"],
|
|
"a.foo
|
|
one
|
|
symlink",
|
|
);
|
|
}
|
|
|
|
/// Absolute paths (--absolute-path)
|
|
#[test]
|
|
fn test_absolute_path() {
|
|
let te = TestEnv::new();
|
|
|
|
let abs_path = te.root()
|
|
.canonicalize()
|
|
.expect("absolute path")
|
|
.to_str()
|
|
.expect("string")
|
|
.to_string();
|
|
|
|
#[cfg(windows)]
|
|
let abs_path = abs_path.trim_left_matches(r"\\?\");
|
|
|
|
te.assert_output(
|
|
&["--absolute-path"],
|
|
&format!(
|
|
"{abs_path}/a.foo
|
|
{abs_path}/one
|
|
{abs_path}/one/b.foo
|
|
{abs_path}/one/two
|
|
{abs_path}/one/two/c.foo
|
|
{abs_path}/one/two/C.Foo2
|
|
{abs_path}/one/two/three
|
|
{abs_path}/one/two/three/d.foo
|
|
{abs_path}/one/two/three/directory_foo
|
|
{abs_path}/symlink",
|
|
abs_path = abs_path
|
|
),
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--absolute-path", "foo"],
|
|
&format!(
|
|
"{abs_path}/a.foo
|
|
{abs_path}/one/b.foo
|
|
{abs_path}/one/two/c.foo
|
|
{abs_path}/one/two/C.Foo2
|
|
{abs_path}/one/two/three/d.foo
|
|
{abs_path}/one/two/three/directory_foo",
|
|
abs_path = abs_path
|
|
),
|
|
);
|
|
|
|
te.assert_output(
|
|
&["foo", &abs_path],
|
|
&format!(
|
|
"{abs_path}/a.foo
|
|
{abs_path}/one/b.foo
|
|
{abs_path}/one/two/c.foo
|
|
{abs_path}/one/two/C.Foo2
|
|
{abs_path}/one/two/three/d.foo
|
|
{abs_path}/one/two/three/directory_foo",
|
|
abs_path = abs_path
|
|
),
|
|
);
|
|
}
|
|
|
|
/// File type filter (--type)
|
|
#[test]
|
|
fn test_type() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--type", "f"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/C.Foo2
|
|
one/two/three/d.foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--type", "d"],
|
|
"one
|
|
one/two
|
|
one/two/three
|
|
one/two/three/directory_foo",
|
|
);
|
|
|
|
te.assert_output(&["--type", "l"], "symlink");
|
|
}
|
|
|
|
/// File extension (--extension)
|
|
#[test]
|
|
fn test_extension() {
|
|
let te = TestEnv::new();
|
|
|
|
te.assert_output(
|
|
&["--extension", "foo"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/three/d.foo",
|
|
);
|
|
|
|
te.assert_output(
|
|
&["--extension", ".foo"],
|
|
"a.foo
|
|
one/b.foo
|
|
one/two/c.foo
|
|
one/two/three/d.foo",
|
|
);
|
|
|
|
te.assert_output(&["--extension", "foo2"], "one/two/C.Foo2");
|
|
}
|