use globazog::builder::{Options, QueryBuilder};
use globazog::predicate::{Cmp, Leaf};
use globazog::ring::{ContainerId, CqItem, Name, TerminalReason};
use globazog::syntax::dialect::Dialect;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::Path;
fn drain_to_terminal(handle: &globazog::builder::QueryHandle) -> Vec<CqItem> {
let ring = handle.completions();
let mut items = Vec::new();
loop {
let item = ring.wait_pop();
let terminal = matches!(item, CqItem::Terminal(_));
items.push(item);
if terminal {
return items;
}
}
}
fn name_string(name: &Name) -> String {
name.to_string_lossy()
}
fn make_tree(root: &Path) {
fs::write(root.join("a.txt"), b"aa").unwrap();
fs::write(root.join("b.txt"), b"bbbb").unwrap();
fs::write(root.join("note.md"), b"m").unwrap();
fs::create_dir(root.join("sub")).unwrap();
fs::write(root.join("sub/c.txt"), b"c").unwrap();
fs::write(root.join("sub/d.log"), b"dd").unwrap();
fs::create_dir(root.join("sub/deep")).unwrap();
fs::write(root.join("sub/deep/e.txt"), b"e").unwrap();
fs::create_dir(root.join("empty")).unwrap();
}
fn match_names(items: &[CqItem]) -> Vec<String> {
items
.iter()
.filter_map(|i| match i {
CqItem::Match(m) => Some(name_string(&m.name)),
_ => None,
})
.collect()
}
#[test]
fn recursive_txt_match_over_tree() {
let root = tempfile::tempdir().unwrap();
make_tree(root.path());
let handle = QueryBuilder::new()
.root(root.path())
.pattern("**/*.txt", Dialect::Posix, Vec::new())
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let mut names = match_names(&items);
names.sort();
assert_eq!(names, vec!["a.txt", "b.txt", "c.txt", "e.txt"]);
let terminals: Vec<_> = items
.iter()
.filter(|i| matches!(i, CqItem::Terminal(_)))
.collect();
assert_eq!(terminals.len(), 1);
match terminals[0] {
CqItem::Terminal(t) => assert_eq!(t.reason, TerminalReason::Completed),
_ => unreachable!(),
}
}
#[test]
fn container_enter_end_invariants_hold_on_real_tree() {
let root = tempfile::tempdir().unwrap();
make_tree(root.path());
let handle = QueryBuilder::new()
.root(root.path())
.pattern("**/*", Dialect::Posix, Vec::new())
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let mut live: HashMap<ContainerId, Option<ContainerId>> = HashMap::new();
let mut ended: HashSet<ContainerId> = HashSet::new();
let mut enters = 0;
let mut ends = 0;
for item in &items {
match item {
CqItem::ContainerEnter(e) => {
if let Some(p) = e.parent {
assert!(live.contains_key(&p), "child entered before parent");
assert!(!ended.contains(&p), "child entered after parent ended");
}
assert!(live.insert(e.id, e.parent).is_none(), "duplicate enter");
enters += 1;
}
CqItem::Match(m) => {
assert!(
live.contains_key(&m.container),
"match in unknown container"
);
}
CqItem::ContainerEnd(end) => {
let parent = live.remove(&end.id).expect("end without enter");
assert!(
!live.values().any(|p| *p == Some(end.id)),
"container ended while a child was still live"
);
if let Some(p) = parent {
assert!(!ended.contains(&p), "parent ended before child");
}
ended.insert(end.id);
ends += 1;
}
CqItem::Terminal(_) => {
assert!(live.is_empty(), "containers still live at terminal");
}
_ => {}
}
}
assert_eq!(enters, 4);
assert_eq!(ends, 4);
}
#[test]
fn descend_pruning_limits_traversal() {
let root = tempfile::tempdir().unwrap();
make_tree(root.path());
let handle = QueryBuilder::new()
.root(root.path())
.pattern("*.txt", Dialect::Posix, Vec::new())
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let mut names = match_names(&items);
names.sort();
assert_eq!(names, vec!["a.txt", "b.txt"]);
let enters = items
.iter()
.filter(|i| matches!(i, CqItem::ContainerEnter(_)))
.count();
assert_eq!(enters, 1, "no subdirectory should be entered");
}
#[test]
fn per_pattern_emit_filter_applies() {
let root = tempfile::tempdir().unwrap();
make_tree(root.path());
let handle = QueryBuilder::new()
.root(root.path())
.pattern(
"**/*.txt",
Dialect::Posix,
vec![Leaf::Size {
op: Cmp::Gt,
value: 1,
}],
)
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let mut names = match_names(&items);
names.sort();
assert_eq!(names, vec!["a.txt", "b.txt"]);
}
#[test]
fn multi_pattern_bitset_reports_all_matching_patterns() {
let root = tempfile::tempdir().unwrap();
make_tree(root.path());
let handle = QueryBuilder::new()
.root(root.path())
.pattern("*.txt", Dialect::Posix, Vec::new())
.pattern("a.*", Dialect::Posix, Vec::new())
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let a_match = items
.iter()
.find_map(|i| match i {
CqItem::Match(m) if name_string(&m.name) == "a.txt" => Some(m),
_ => None,
})
.expect("a.txt matched");
assert!(a_match.matched.contains(0));
assert!(a_match.matched.contains(1));
let b_match = items
.iter()
.find_map(|i| match i {
CqItem::Match(m) if name_string(&m.name) == "b.txt" => Some(m),
_ => None,
})
.expect("b.txt matched");
assert!(b_match.matched.contains(0));
assert!(!b_match.matched.contains(1));
}
#[test]
fn large_tree_matches_all_and_terminates() {
let root = tempfile::tempdir().unwrap();
for d in 0..20 {
let dir = root.path().join(format!("d{d}"));
fs::create_dir(&dir).unwrap();
for f in 0..50 {
fs::write(dir.join(format!("f{f}.dat")), b"x").unwrap();
}
}
let opts = Options {
permits: 8,
ring_capacity: 64,
..Options::default()
};
let handle = QueryBuilder::new()
.root(root.path())
.options(opts)
.pattern("**/*.dat", Dialect::Posix, Vec::new())
.submit()
.unwrap();
let items = drain_to_terminal(&handle);
let matches = items
.iter()
.filter(|i| matches!(i, CqItem::Match(_)))
.count();
assert_eq!(matches, 1000);
let enters = items
.iter()
.filter(|i| matches!(i, CqItem::ContainerEnter(_)))
.count();
let ends = items
.iter()
.filter(|i| matches!(i, CqItem::ContainerEnd(_)))
.count();
assert_eq!(enters, 21);
assert_eq!(ends, 21);
}
#[test]
fn cancel_terminates_with_cancelled_marker() {
let root = tempfile::tempdir().unwrap();
for d in 0..30 {
let dir = root.path().join(format!("d{d}"));
fs::create_dir(&dir).unwrap();
for f in 0..50 {
fs::write(dir.join(format!("f{f}.dat")), b"x").unwrap();
}
}
let opts = Options {
permits: 4,
ring_capacity: 8,
..Options::default()
};
let handle = QueryBuilder::new()
.root(root.path())
.options(opts)
.pattern("**/*.dat", Dialect::Posix, Vec::new())
.submit()
.unwrap();
handle.cancel();
let items = drain_to_terminal(&handle);
match items.last().unwrap() {
CqItem::Terminal(t) => {
assert!(matches!(
t.reason,
TerminalReason::Cancelled | TerminalReason::Completed
));
}
other => panic!("stream must end with a terminal, got {other:?}"),
}
let terminals = items
.iter()
.filter(|i| matches!(i, CqItem::Terminal(_)))
.count();
assert_eq!(terminals, 1);
}