pub use git_testtools::Result;
mod parse {
use std::collections::HashMap;
use bstr::{BStr, BString, ByteSlice};
use git_attributes::State;
use git_pathspec::{MagicSignature, MatchMode, Pattern};
use once_cell::sync::Lazy;
#[derive(Debug, Clone, PartialEq, Eq)]
struct PatternForTesting {
path: BString,
signature: MagicSignature,
search_mode: MatchMode,
attributes: Vec<(BString, State)>,
}
impl From<Pattern> for PatternForTesting {
fn from(p: Pattern) -> Self {
PatternForTesting {
path: p.path,
signature: p.signature,
search_mode: p.search_mode,
attributes: p
.attributes
.into_iter()
.map(|attr| (attr.name.as_str().into(), attr.state))
.collect(),
}
}
}
static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
let base = git_testtools::scripted_fixture_read_only("generate_pathspec_baseline.sh").unwrap();
(|| -> crate::Result<_> {
let mut map = HashMap::new();
let baseline = std::fs::read(base.join("baseline.git"))?;
let mut lines = baseline.lines();
while let Some(spec) = lines.next() {
let exit_code = lines.next().expect("two lines per baseline").to_str()?.parse()?;
map.insert(spec.into(), exit_code);
}
Ok(map)
})()
.unwrap()
});
#[test]
fn baseline() {
for (pattern, exit_code) in BASELINE.iter() {
let res = git_pathspec::parse(pattern);
assert_eq!(
res.is_ok(),
*exit_code == 0,
"{pattern:?} disagrees with baseline: {res:?}"
)
}
}
mod succeed {
use git_attributes::State;
use git_pathspec::{MagicSignature, MatchMode};
use crate::parse::{
check_valid_inputs, pat, pat_with_attrs, pat_with_path, pat_with_path_and_sig, pat_with_search_mode,
pat_with_sig,
};
#[test]
fn there_is_no_pathspec_pathspec() {
check_valid_inputs(Some((":", pat_with_attrs(vec![]))));
}
#[test]
fn repeated_matcher_keywords() {
let input = vec![
(":(glob,glob)", pat_with_search_mode(MatchMode::PathAwareGlob)),
(":(literal,literal)", pat_with_search_mode(MatchMode::Literal)),
(":(top,top)", pat_with_sig(MagicSignature::TOP)),
(":(icase,icase)", pat_with_sig(MagicSignature::ICASE)),
(":(attr,attr)", pat_with_attrs(vec![])),
(":!^(exclude,exclude)", pat_with_sig(MagicSignature::EXCLUDE)),
];
check_valid_inputs(input);
}
#[test]
fn empty_signatures() {
let inputs = vec![
(".", pat_with_path(".")),
("some/path", pat_with_path("some/path")),
(":some/path", pat_with_path("some/path")),
(":()some/path", pat_with_path("some/path")),
("::some/path", pat_with_path("some/path")),
(":::some/path", pat_with_path(":some/path")),
(":():some/path", pat_with_path(":some/path")),
];
check_valid_inputs(inputs)
}
#[test]
fn whitespace_in_pathspec() {
let inputs = vec![
(" some/path", pat_with_path(" some/path")),
("some/ path", pat_with_path("some/ path")),
("some/path ", pat_with_path("some/path ")),
(": some/path", pat_with_path(" some/path")),
(": !some/path", pat_with_path(" !some/path")),
(": :some/path", pat_with_path(" :some/path")),
(": ()some/path", pat_with_path(" ()some/path")),
(
":! some/path",
pat_with_path_and_sig(" some/path", MagicSignature::EXCLUDE),
),
];
check_valid_inputs(inputs)
}
#[test]
fn short_signatures() {
let inputs = vec![
(":/some/path", pat_with_path_and_sig("some/path", MagicSignature::TOP)),
(
":^some/path",
pat_with_path_and_sig("some/path", MagicSignature::EXCLUDE),
),
(
":!some/path",
pat_with_path_and_sig("some/path", MagicSignature::EXCLUDE),
),
(
":/!some/path",
pat_with_path_and_sig("some/path", MagicSignature::TOP | MagicSignature::EXCLUDE),
),
(
":!/^/:some/path",
pat_with_path_and_sig("some/path", MagicSignature::TOP | MagicSignature::EXCLUDE),
),
];
check_valid_inputs(inputs)
}
#[test]
fn signatures_and_searchmodes() {
let inputs = vec![
(":(top)", pat_with_sig(MagicSignature::TOP)),
(":(icase)", pat_with_sig(MagicSignature::ICASE)),
(":(attr)", pat_with_path("")),
(":(exclude)", pat_with_sig(MagicSignature::EXCLUDE)),
(":(literal)", pat_with_search_mode(MatchMode::Literal)),
(":(glob)", pat_with_search_mode(MatchMode::PathAwareGlob)),
(
":(top,exclude)",
pat_with_sig(MagicSignature::TOP | MagicSignature::EXCLUDE),
),
(
":(icase,literal)",
pat("", MagicSignature::ICASE, MatchMode::Literal, vec![]),
),
(
":!(literal)some/*path",
pat("some/*path", MagicSignature::EXCLUDE, MatchMode::Literal, vec![]),
),
(
":(top,literal,icase,attr,exclude)some/path",
pat("some/path", MagicSignature::all(), MatchMode::Literal, vec![]),
),
(
":(top,glob,icase,attr,exclude)some/path",
pat("some/path", MagicSignature::all(), MatchMode::PathAwareGlob, vec![]),
),
];
check_valid_inputs(inputs);
}
#[test]
fn attributes_in_signature() {
let inputs = vec![
(":(attr:someAttr)", pat_with_attrs(vec![("someAttr", State::Set)])),
(
":(attr:!someAttr)",
pat_with_attrs(vec![("someAttr", State::Unspecified)]),
),
(":(attr:-someAttr)", pat_with_attrs(vec![("someAttr", State::Unset)])),
(
":(attr:someAttr=value)",
pat_with_attrs(vec![("someAttr", State::Value("value".into()))]),
),
(
":(attr:a=one b=)",
pat_with_attrs(vec![("a", State::Value("one".into())), ("b", State::Value("".into()))]),
),
(
":(attr:a= b=two)",
pat_with_attrs(vec![("a", State::Value("".into())), ("b", State::Value("two".into()))]),
),
(
":(attr:a=one b=two)",
pat_with_attrs(vec![
("a", State::Value("one".into())),
("b", State::Value("two".into())),
]),
),
(
":(attr:a=one b=two)",
pat_with_attrs(vec![
("a", State::Value("one".into())),
("b", State::Value("two".into())),
]),
),
(
":(attr:someAttr anotherAttr)",
pat_with_attrs(vec![("someAttr", State::Set), ("anotherAttr", State::Set)]),
),
];
check_valid_inputs(inputs)
}
#[test]
fn attributes_with_escape_chars_in_state_values() {
let inputs = vec![
(
r":(attr:v=one\-)",
pat_with_attrs(vec![("v", State::Value(r"one-".into()))]),
),
(
r":(attr:v=one\_)",
pat_with_attrs(vec![("v", State::Value(r"one_".into()))]),
),
(
r":(attr:v=one\,)",
pat_with_attrs(vec![("v", State::Value(r"one,".into()))]),
),
(
r":(attr:v=one\,two\,three)",
pat_with_attrs(vec![("v", State::Value(r"one,two,three".into()))]),
),
(
r":(attr:a=\d b= c=\d)",
pat_with_attrs(vec![
("a", State::Value(r"d".into())),
("b", State::Value(r"".into())),
("c", State::Value(r"d".into())),
]),
),
];
check_valid_inputs(inputs)
}
}
mod fail {
use git_pathspec::parse::Error;
use crate::parse::check_against_baseline;
#[test]
fn empty_input() {
let input = "";
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::EmptyString));
}
#[test]
fn invalid_short_signatures() {
let inputs = vec![
":\"()", ":#()", ":%()", ":&()", ":'()", ":,()", ":-()", ":;()", ":<()", ":=()", ":>()", ":@()",
":_()", ":`()", ":~()",
];
for input in inputs.into_iter() {
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::Unimplemented { .. }));
}
}
#[test]
fn invalid_keywords() {
let inputs = vec![
":( )some/path",
":(tp)some/path",
":(top, exclude)some/path",
":(top,exclude,icse)some/path",
];
for input in inputs.into_iter() {
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::InvalidKeyword { .. }));
}
}
#[test]
fn invalid_attributes() {
let inputs = vec![
":(attr:+invalidAttr)some/path",
":(attr:validAttr +invalidAttr)some/path",
":(attr:+invalidAttr,attr:valid)some/path",
r":(attr:inva\lid)some/path",
];
for input in inputs {
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err(), "This pathspec did not produce an error {input}");
assert!(matches!(output.unwrap_err(), Error::InvalidAttribute { .. }));
}
}
#[test]
fn invalid_attribute_values() {
let inputs = vec![
r":(attr:v=inva#lid)some/path",
r":(attr:v=inva\\lid)some/path",
r":(attr:v=invalid\\)some/path",
r":(attr:v=invalid\#)some/path",
r":(attr:v=inva\=lid)some/path",
r":(attr:a=valid b=inva\#lid)some/path",
":(attr:v=val��)",
":(attr:pr=pre��x:,)�",
];
for input in inputs {
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err(), "This pathspec did not produce an error {input}");
assert!(
matches!(output.unwrap_err(), Error::InvalidAttributeValue { .. }),
"Errors did not match for pathspec: {input}"
);
}
}
#[test]
fn escape_character_at_end_of_attribute_value() {
let inputs = vec![
r":(attr:v=invalid\)some/path",
r":(attr:v=invalid\ )some/path",
r":(attr:v=invalid\ valid)some/path",
];
for input in inputs {
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err(), "This pathspec did not produce an error {input}");
assert!(matches!(output.unwrap_err(), Error::TrailingEscapeCharacter));
}
}
#[test]
fn empty_attribute_specification() {
let input = ":(attr:)";
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::EmptyAttribute));
}
#[test]
fn multiple_attribute_specifications() {
let input = ":(attr:one,attr:two)some/path";
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::MultipleAttributeSpecifications));
}
#[test]
fn missing_parentheses() {
let input = ":(top";
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::MissingClosingParenthesis { .. }));
}
#[test]
fn glob_and_literal_keywords_present() {
let input = ":(glob,literal)some/path";
assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
let output = git_pathspec::parse(input.as_bytes());
assert!(output.is_err());
assert!(matches!(output.unwrap_err(), Error::IncompatibleSearchModes));
}
}
fn check_valid_inputs<'a>(inputs: impl IntoIterator<Item = (&'a str, PatternForTesting)>) {
for (input, expected) in inputs.into_iter() {
assert!(
check_against_baseline(input),
"This pathspec is invalid in git: {input}"
);
let pattern: PatternForTesting = git_pathspec::parse(input.as_bytes())
.unwrap_or_else(|_| panic!("parsing should not fail with pathspec {input}"))
.into();
assert_eq!(pattern, expected, "while checking input: \"{input}\"");
}
}
fn pat_with_path(path: &str) -> PatternForTesting {
pat_with_path_and_sig(path, MagicSignature::empty())
}
fn pat_with_path_and_sig(path: &str, signature: MagicSignature) -> PatternForTesting {
pat(path, signature, MatchMode::ShellGlob, vec![])
}
fn pat_with_sig(signature: MagicSignature) -> PatternForTesting {
pat("", signature, MatchMode::ShellGlob, vec![])
}
fn pat_with_attrs(attrs: Vec<(&'static str, State)>) -> PatternForTesting {
pat("", MagicSignature::empty(), MatchMode::ShellGlob, attrs)
}
fn pat_with_search_mode(search_mode: MatchMode) -> PatternForTesting {
pat("", MagicSignature::empty(), search_mode, vec![])
}
fn pat(
path: &str,
signature: MagicSignature,
search_mode: MatchMode,
attributes: Vec<(&str, State)>,
) -> PatternForTesting {
PatternForTesting {
path: path.into(),
signature,
search_mode,
attributes: attributes
.into_iter()
.map(|(attr, state)| (attr.into(), state))
.collect(),
}
}
fn check_against_baseline(pathspec: &str) -> bool {
let key: &BStr = pathspec.into();
let base = BASELINE
.get(key)
.unwrap_or_else(|| panic!("missing baseline for pathspec: {pathspec:?}"));
*base == 0
}
}