path-rs 0.1.0

Cross-platform path expansion, normalization, traversal, searching, and caching
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use path_rs::{
    CacheKey, CacheMode, CacheOptions, CachePolicy, CacheValue, DiscoveryCache, MemoryCache,
};
use std::path::PathBuf;
use std::time::{Duration, SystemTime};

fn sample_key(root: &str, pattern: &str) -> CacheKey {
    CacheKey {
        root: PathBuf::from(root),
        patterns: vec![pattern.to_string()],
        exclude_patterns: vec![],
        recursive: true,
        follow_symlinks: false,
        include_hidden: false,
        include_files: true,
        include_directories: true,
        include_symlinks: true,
        max_depth: None,
        sort: path_rs::SortMode::Path,
    }
}

#[test]
fn disabled_cache_noop() {
    let cache = MemoryCache::new(CacheOptions {
        mode: CacheMode::Disabled,
        ..CacheOptions::default()
    });
    let key = sample_key("/tmp", "*.rs");
    cache
        .put(
            key.clone(),
            CacheValue {
                entries: vec![],
                stored_at: SystemTime::now(),
                ttl: None,
            },
        )
        .unwrap();
    assert!(cache.get(&key).unwrap().is_none());
}

#[test]
fn put_get_invalidate_clear() {
    let cache = MemoryCache::new(CacheOptions {
        mode: CacheMode::Memory,
        ttl: None,
        max_entries: 8,
        validate_metadata: false,
    });
    let key = sample_key("/repo", "**/*.rs");
    cache
        .put(
            key.clone(),
            CacheValue {
                entries: vec![],
                stored_at: SystemTime::now(),
                ttl: None,
            },
        )
        .unwrap();
    assert!(cache.get(&key).unwrap().is_some());

    cache.invalidate(std::path::Path::new("/repo")).unwrap();
    assert!(cache.get(&key).unwrap().is_none());

    cache
        .put(
            key.clone(),
            CacheValue {
                entries: vec![],
                stored_at: SystemTime::now(),
                ttl: None,
            },
        )
        .unwrap();
    cache.clear().unwrap();
    assert!(cache.is_empty().unwrap());
}

#[test]
fn ttl_expiration() {
    let cache = MemoryCache::new(CacheOptions {
        mode: CacheMode::Memory,
        ttl: Some(Duration::from_millis(1)),
        max_entries: 8,
        validate_metadata: false,
    });
    let key = sample_key("/repo", "*.txt");
    cache
        .put(
            key.clone(),
            CacheValue {
                entries: vec![],
                stored_at: SystemTime::now() - Duration::from_secs(5),
                ttl: Some(Duration::from_millis(1)),
            },
        )
        .unwrap();
    assert!(cache.get(&key).unwrap().is_none());
}

#[test]
fn different_options_different_keys() {
    let a = sample_key("/repo", "*.rs");
    let mut b = sample_key("/repo", "*.rs");
    b.include_hidden = true;
    assert_ne!(a, b);
}

#[test]
fn max_entries_eviction() {
    let cache = MemoryCache::new(CacheOptions {
        mode: CacheMode::Memory,
        ttl: None,
        max_entries: 2,
        validate_metadata: false,
    });
    for i in 0..3 {
        let key = sample_key("/repo", &format!("p{i}"));
        cache
            .put(
                key,
                CacheValue {
                    entries: vec![],
                    stored_at: SystemTime::now(),
                    ttl: None,
                },
            )
            .unwrap();
    }
    assert!(cache.len().unwrap() <= 2);
}

#[test]
fn cache_policy_enum_defaults() {
    assert_eq!(CachePolicy::default(), CachePolicy::Bypass);
    assert_eq!(CacheMode::default(), CacheMode::Disabled);
}