575 lines
21 KiB
Rust
575 lines
21 KiB
Rust
//! Project discovery for `GET /api/projects` (#54).
|
|
//!
|
|
//! Scans `[spawn].project_roots` (default the whole home) for `.git` entries —
|
|
//! directory or file, so linked worktrees count too — up to
|
|
//! `[spawn].project_scan_depth` levels. Descent stops at the first repo found:
|
|
//! nested independent repos are not discovered, but worktrees of every hit
|
|
//! still are, via `git worktree list`, which also catches linked worktrees
|
|
//! living outside the roots.
|
|
//!
|
|
//! Hidden directories are skipped everywhere; heavy well-known directories
|
|
//! (`node_modules`, `Downloads`, …) are skipped when they sit directly in the
|
|
//! home directory, so scanning all of home stays cheap.
|
|
//!
|
|
//! Results are cached behind a short TTL and refreshed on a slow background
|
|
//! timer ([`ProjectScanner::start_background_refresh`]) — repositories appear
|
|
//! rarely, and `/api/projects` may be polled.
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::time::{Duration, Instant};
|
|
|
|
use chrono::{DateTime, Utc};
|
|
|
|
use crate::spawn_history::RecentDir;
|
|
|
|
/// Directory names never descended when they sit directly in the home dir, so
|
|
/// scanning all of home stays cheap (#54). Hidden dirs are skipped everywhere
|
|
/// regardless.
|
|
pub const DEFAULT_HOME_IGNORE: &[&str] =
|
|
&["node_modules", "Downloads", "Library", "go", "snap", "opt"];
|
|
|
|
/// How long a discovery snapshot is served as-is before the next request
|
|
/// triggers a rescan.
|
|
///
|
|
/// A scan walks the roots and runs one `git worktree list` per hit, holding
|
|
/// the scanner lock throughout, and clients re-request whenever a draft pane
|
|
/// re-mounts — which `multiview.render()` does on unrelated events. Keep this
|
|
/// comfortably longer than [`REFRESH_INTERVAL`] so the background timer is
|
|
/// what refreshes, and a request only rescans when that timer has failed to.
|
|
pub const CACHE_TTL: Duration = Duration::from_secs(180);
|
|
/// Background refresh cadence. Repositories appear rarely; this keeps the
|
|
/// served list eventually fresh without anyone asking.
|
|
pub const REFRESH_INTERVAL: Duration = Duration::from_secs(60);
|
|
|
|
/// One repository or linked worktree found by [`discover`].
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DiscoveredRepo {
|
|
pub path: PathBuf,
|
|
/// Basename of `path`.
|
|
pub name: String,
|
|
pub is_worktree: bool,
|
|
/// The main checkout this worktree belongs to; set only when
|
|
/// [`Self::is_worktree`].
|
|
pub base_repo: Option<PathBuf>,
|
|
/// Mtime of the checkout's git HEAD — "someone committed / checked out
|
|
/// here". The later-of merge with spawn history happens in
|
|
/// [`to_projects`], which also sorts.
|
|
pub head_mtime: Option<DateTime<Utc>>,
|
|
}
|
|
|
|
/// Repo toplevels under each root of `roots`, at most `max_depth` levels deep.
|
|
/// A dir holding `.git` (dir *or* file) is a hit and is not descended into;
|
|
/// hidden directories are never entered, and `DEFAULT_HOME_IGNORE` names are
|
|
/// skipped directly under `home`.
|
|
pub fn scan_roots(roots: &[PathBuf], max_depth: u32, home: &Path) -> Vec<PathBuf> {
|
|
let mut found = Vec::new();
|
|
for root in roots {
|
|
walk(root, 0, max_depth, home, &mut found);
|
|
}
|
|
found.sort();
|
|
found.dedup();
|
|
found
|
|
}
|
|
|
|
fn walk(dir: &Path, depth: u32, max_depth: u32, home: &Path, found: &mut Vec<PathBuf>) {
|
|
let entries = match std::fs::read_dir(dir) {
|
|
Ok(e) => e,
|
|
Err(_) => return,
|
|
};
|
|
let mut subdirs = Vec::new();
|
|
let mut has_git = false;
|
|
for entry in entries.flatten() {
|
|
match entry.file_name().to_string_lossy().into_owned() {
|
|
name if name == ".git" => has_git = true,
|
|
name if name.starts_with('.') => {}
|
|
name if dir == home && DEFAULT_HOME_IGNORE.contains(&name.as_str()) => {}
|
|
_ => {
|
|
if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
|
|
subdirs.push(entry.path());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if has_git {
|
|
// Match `git worktree list` output, which prints real paths.
|
|
found.push(std::fs::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf()));
|
|
return;
|
|
}
|
|
if depth >= max_depth {
|
|
return;
|
|
}
|
|
for sub in subdirs {
|
|
walk(&sub, depth + 1, max_depth, home, found);
|
|
}
|
|
}
|
|
|
|
/// Every discovered project: the scanned repos plus all worktrees their
|
|
/// `git worktree list` reports (linked worktrees can live outside the roots).
|
|
/// A hit whose git invocation fails still lists, un-worktreed.
|
|
pub fn discover(roots: &[PathBuf], max_depth: u32, home: &Path) -> Vec<DiscoveredRepo> {
|
|
let scanned = scan_roots(roots, max_depth, home);
|
|
let mut map: Vec<(PathBuf, PathBuf)> = Vec::new(); // (checkout, main)
|
|
for repo in scanned {
|
|
if map.iter().any(|(c, _)| c == &repo) {
|
|
continue;
|
|
}
|
|
let worktrees = list_worktrees(&repo).unwrap_or_else(|| vec![repo.clone()]);
|
|
let main = worktrees[0].clone();
|
|
for wt in worktrees {
|
|
if !map.iter().any(|(c, _)| c == &wt) {
|
|
map.push((wt, main.clone()));
|
|
}
|
|
}
|
|
}
|
|
map.into_iter()
|
|
.map(|(path, main)| {
|
|
let is_worktree = path != main;
|
|
DiscoveredRepo {
|
|
name: path
|
|
.file_name()
|
|
.map(|n| n.to_string_lossy().into_owned())
|
|
.unwrap_or_default(),
|
|
is_worktree,
|
|
base_repo: is_worktree.then_some(main),
|
|
head_mtime: head_mtime(&path),
|
|
path,
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// `git worktree list --porcelain` from `repo`: absolute paths, main first.
|
|
/// `None` when git fails (broken/bare checkout).
|
|
fn list_worktrees(repo: &Path) -> Option<Vec<PathBuf>> {
|
|
let out = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(repo)
|
|
.args(["worktree", "list", "--porcelain"])
|
|
.output()
|
|
.ok()?;
|
|
if !out.status.success() {
|
|
return None;
|
|
}
|
|
let mut paths = Vec::new();
|
|
for line in String::from_utf8_lossy(&out.stdout).lines() {
|
|
if let Some(p) = line.strip_prefix("worktree ") {
|
|
paths.push(PathBuf::from(p));
|
|
}
|
|
}
|
|
(!paths.is_empty()).then_some(paths)
|
|
}
|
|
|
|
/// Mtime of the checkout's reflog, falling back to `HEAD` itself.
|
|
///
|
|
/// `HEAD` is only rewritten on checkout — committing updates
|
|
/// `refs/heads/<branch>` and appends to `logs/HEAD`, leaving `HEAD` alone. A
|
|
/// repo worked on daily from one long-lived branch would otherwise report its
|
|
/// last *branch switch* as its activity and get dimmed as stale (#54 review).
|
|
///
|
|
/// For a linked worktree `.git` is a file holding a `gitdir:` pointer;
|
|
/// resolve it so worktrees report their own reflog rather than nothing.
|
|
fn head_mtime(repo: &Path) -> Option<DateTime<Utc>> {
|
|
let dot_git = repo.join(".git");
|
|
let head = if dot_git.is_dir() {
|
|
dot_git.join("HEAD")
|
|
} else {
|
|
let ptr = std::fs::read_to_string(&dot_git).ok()?;
|
|
let gitdir = ptr.trim().strip_prefix("gitdir:")?.trim();
|
|
// Relative pointers are relative to the worktree.
|
|
let p = Path::new(gitdir);
|
|
let p = if p.is_absolute() {
|
|
p.to_path_buf()
|
|
} else {
|
|
repo.join(p)
|
|
};
|
|
p.join("HEAD")
|
|
};
|
|
// Prefer the reflog next to whichever HEAD we resolved.
|
|
let reflog = head.with_file_name("logs").join("HEAD");
|
|
let head = if reflog.exists() { reflog } else { head };
|
|
let mtime = std::fs::metadata(head).ok()?.modified().ok()?;
|
|
Some(DateTime::<Utc>::from(mtime))
|
|
}
|
|
|
|
/// Fold spawn history into the discovery snapshot and produce the wire list,
|
|
/// sorted newest-activity-first. `history` must be newest-first (what
|
|
/// [`SpawnHistory::all_recent_dirs`](crate::spawn_history::SpawnHistory)
|
|
/// returns): the first entry whose cwd sits inside a project is its most
|
|
/// recent use.
|
|
pub fn to_projects(
|
|
repos: &[DiscoveredRepo],
|
|
history: &[RecentDir],
|
|
) -> Vec<maestro_protocol::Project> {
|
|
let mut projects: Vec<maestro_protocol::Project> = repos
|
|
.iter()
|
|
.map(|repo| {
|
|
let last_use = history.iter().find(|h| contains(&repo.path, &h.cwd));
|
|
maestro_protocol::Project {
|
|
path: repo.path.clone(),
|
|
name: repo.name.clone(),
|
|
is_worktree: repo.is_worktree,
|
|
base_repo: repo.base_repo.clone(),
|
|
last_activity: max_opt(repo.head_mtime, last_use.map(|u| u.last_used)),
|
|
last_command: last_use.map(|u| u.last_command.clone()),
|
|
}
|
|
})
|
|
.collect();
|
|
projects.sort_by_key(|p| std::cmp::Reverse(p.last_activity));
|
|
projects
|
|
}
|
|
|
|
/// Whether `dir` is `project` itself or anywhere inside it.
|
|
fn contains(project: &Path, dir: &Path) -> bool {
|
|
dir == project || dir.starts_with(project)
|
|
}
|
|
|
|
fn max_opt(a: Option<DateTime<Utc>>, b: Option<DateTime<Utc>>) -> Option<DateTime<Utc>> {
|
|
match (a, b) {
|
|
(Some(a), Some(b)) => Some(a.max(b)),
|
|
(a, b) => a.or(b),
|
|
}
|
|
}
|
|
|
|
/// Cached discovery behind a short TTL plus an optional slow background
|
|
/// refresh. Clone-free shared handle via `Arc` in [`crate::local_api`].
|
|
#[derive(Debug)]
|
|
pub struct ProjectScanner {
|
|
roots: Vec<PathBuf>,
|
|
max_depth: u32,
|
|
home: PathBuf,
|
|
ttl: Duration,
|
|
cache: tokio::sync::Mutex<Option<(Instant, std::sync::Arc<Vec<DiscoveredRepo>>)>>,
|
|
}
|
|
|
|
impl ProjectScanner {
|
|
/// Scanner over the resolved config roots. An empty `roots` list scans
|
|
/// nothing and always serves an empty list.
|
|
pub fn new(roots: Vec<PathBuf>, max_depth: u32, home: PathBuf) -> Self {
|
|
Self {
|
|
roots,
|
|
max_depth,
|
|
home,
|
|
ttl: CACHE_TTL,
|
|
cache: tokio::sync::Mutex::new(None),
|
|
}
|
|
}
|
|
|
|
/// Scanner that never discovers anything — tests and embedders that don't
|
|
/// want the endpoint populated.
|
|
pub fn disabled() -> Self {
|
|
Self::new(Vec::new(), 0, PathBuf::new())
|
|
}
|
|
|
|
/// Cached snapshot, rescanning (off-thread) when the TTL has lapsed.
|
|
/// Also the background timer's entry point: a tick inside the TTL is a
|
|
/// no-op (#75).
|
|
pub async fn repos(&self) -> std::sync::Arc<Vec<DiscoveredRepo>> {
|
|
let mut cache = self.cache.lock().await;
|
|
if let Some((at, repos)) = cache.as_ref() {
|
|
if at.elapsed() < self.ttl {
|
|
return repos.clone();
|
|
}
|
|
}
|
|
let roots = self.roots.clone();
|
|
let max_depth = self.max_depth;
|
|
let home = self.home.clone();
|
|
// Blocking fs walk + git subprocesses must not stall the reactor.
|
|
let repos = std::sync::Arc::new(
|
|
tokio::task::spawn_blocking(move || discover(&roots, max_depth, &home))
|
|
.await
|
|
.unwrap_or_default(),
|
|
);
|
|
*cache = Some((Instant::now(), repos.clone()));
|
|
repos
|
|
}
|
|
|
|
/// One background-refresh tick: rescan only if the cached snapshot has
|
|
/// passed its TTL (#75) — the timer used to bypass it and re-walk the
|
|
/// roots every [`REFRESH_INTERVAL`].
|
|
async fn refresh(&self) {
|
|
self.repos().await;
|
|
}
|
|
|
|
/// Spawn the slow background refresh task. Drop the returned handle to
|
|
/// detach it; it stops when the runtime shuts down.
|
|
pub fn start_background_refresh(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
|
|
let scanner = std::sync::Arc::clone(self);
|
|
tokio::spawn(async move {
|
|
let mut ticker = tokio::time::interval(REFRESH_INTERVAL);
|
|
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
|
ticker.tick().await; // the immediate first tick — wait a full interval
|
|
loop {
|
|
scanner.refresh().await;
|
|
ticker.tick().await;
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::spawn_history::RecentDir;
|
|
|
|
/// Real git repo at `<root>/<name>`, one initial commit so HEAD exists.
|
|
fn make_repo(root: &Path, name: &str) -> PathBuf {
|
|
let path = root.join(name);
|
|
std::fs::create_dir_all(&path).unwrap();
|
|
run_git(&path, &["init", "-q"]);
|
|
std::fs::write(path.join("f.txt"), "x\n").unwrap();
|
|
run_git(&path, &["add", "-A"]);
|
|
run_git(
|
|
&path,
|
|
&[
|
|
"-c",
|
|
"user.email=t@t",
|
|
"-c",
|
|
"user.name=t",
|
|
"commit",
|
|
"-qm",
|
|
"init",
|
|
],
|
|
);
|
|
path
|
|
}
|
|
|
|
fn run_git(dir: &Path, args: &[&str]) {
|
|
let out = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(dir)
|
|
.args(args)
|
|
.output()
|
|
.unwrap();
|
|
assert!(
|
|
out.status.success(),
|
|
"git {args:?} failed: {} | {}",
|
|
String::from_utf8_lossy(&out.stderr),
|
|
String::from_utf8_lossy(&out.stdout)
|
|
);
|
|
}
|
|
|
|
fn names(repos: &[DiscoveredRepo]) -> Vec<String> {
|
|
let mut v: Vec<String> = repos.iter().map(|r| r.name.clone()).collect();
|
|
v.sort();
|
|
v
|
|
}
|
|
|
|
#[test]
|
|
fn scan_finds_repos_and_stops_at_the_first_hit() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let outer = make_repo(tmp.path(), "outer");
|
|
// A nested independent repo inside `outer` is NOT discovered
|
|
// separately: descent stops once a repo is found.
|
|
make_repo(&outer, "vendored");
|
|
std::fs::create_dir_all(tmp.path().join("plain/deep/deeper")).unwrap();
|
|
|
|
let found = scan_roots(
|
|
&[tmp.path().to_path_buf()],
|
|
3,
|
|
Path::new("/nonexistent-home"),
|
|
);
|
|
assert_eq!(found, vec![outer]);
|
|
|
|
let discovered = discover(
|
|
&[tmp.path().to_path_buf()],
|
|
3,
|
|
Path::new("/nonexistent-home"),
|
|
);
|
|
assert_eq!(names(&discovered), ["outer"]);
|
|
assert!(!discovered[0].is_worktree);
|
|
assert_eq!(discovered[0].base_repo, None);
|
|
assert!(discovered[0].head_mtime.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn scan_respects_depth_hidden_dirs_and_home_ignore() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let home = tmp.path().join("home");
|
|
|
|
// Hidden dirs are never entered, at any depth.
|
|
std::fs::create_dir_all(home.join(".secret/.git")).unwrap();
|
|
// node_modules directly under home is not descended…
|
|
let _ignored = make_repo(&home.join("node_modules"), "dep");
|
|
// …but the same name deeper down is fair game.
|
|
let kept = make_repo(&home.join("code/node_modules"), "dep2");
|
|
|
|
// Depth cap: a repo three levels below the root is the last tier —
|
|
// found at depth 3, but a fourth-level repo isn't.
|
|
let at_three = home.join("a/b/c");
|
|
std::fs::create_dir_all(at_three.join(".git")).unwrap();
|
|
std::fs::create_dir_all(home.join("a/b/c/d/.git")).unwrap();
|
|
|
|
let found = scan_roots(std::slice::from_ref(&home), 3, &home);
|
|
assert!(found.iter().all(|p| !p.starts_with(home.join(".secret"))));
|
|
assert!(found
|
|
.iter()
|
|
.all(|p| !p.starts_with(home.join("node_modules"))));
|
|
assert!(found.contains(&kept.canonicalize().unwrap()));
|
|
assert!(found.contains(&at_three.canonicalize().unwrap()));
|
|
assert!(!found.iter().any(|p| p.ends_with("d")));
|
|
}
|
|
|
|
#[test]
|
|
fn worktrees_outside_the_roots_are_discovered_via_git_worktree_list() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let root = tmp.path().join("scan-root");
|
|
std::fs::create_dir_all(&root).unwrap();
|
|
let main = make_repo(&root, "main-repo");
|
|
// Linked worktree deliberately outside the scan root.
|
|
let wt = tmp.path().join("elsewhere/wt-of-main");
|
|
std::fs::create_dir_all(wt.parent().unwrap()).unwrap();
|
|
run_git(
|
|
&main,
|
|
&[
|
|
"worktree",
|
|
"add",
|
|
"-q",
|
|
"-b",
|
|
"feature",
|
|
&wt.to_string_lossy(),
|
|
],
|
|
);
|
|
|
|
let discovered = discover(&[root], 3, Path::new("/nonexistent-home"));
|
|
assert_eq!(names(&discovered), ["main-repo", "wt-of-main"]);
|
|
let wt_entry = discovered.iter().find(|d| d.name == "wt-of-main").unwrap();
|
|
assert!(wt_entry.is_worktree);
|
|
assert_eq!(
|
|
wt_entry.base_repo.as_deref(),
|
|
Some(main.canonicalize().unwrap().as_path())
|
|
);
|
|
let main_entry = discovered.iter().find(|d| d.name == "main-repo").unwrap();
|
|
assert!(!main_entry.is_worktree);
|
|
}
|
|
|
|
#[test]
|
|
fn head_mtime_resolves_a_worktrees_git_file_pointer() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let main = make_repo(tmp.path(), "m");
|
|
let wt = tmp.path().join("wt");
|
|
run_git(
|
|
&main,
|
|
&["worktree", "add", "-q", "-b", "b2", &wt.to_string_lossy()],
|
|
);
|
|
assert!(head_mtime(&wt).is_some());
|
|
}
|
|
|
|
fn recent(cwd: &str, cmd: &str, at: &str) -> RecentDir {
|
|
RecentDir {
|
|
cwd: PathBuf::from(cwd),
|
|
last_command: cmd.into(),
|
|
last_used: DateTime::parse_from_rfc3339(at)
|
|
.unwrap()
|
|
.with_timezone(&Utc),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn to_projects_merges_history_and_sorts_newest_first() {
|
|
let repo_old = DiscoveredRepo {
|
|
path: PathBuf::from("/w/old"),
|
|
name: "old".into(),
|
|
is_worktree: false,
|
|
base_repo: None,
|
|
// Committed recently but never spawned in.
|
|
head_mtime: Some(t("2026-08-23T10:00:00Z")),
|
|
};
|
|
let repo_hist = DiscoveredRepo {
|
|
path: PathBuf::from("/w/hist"),
|
|
name: "hist".into(),
|
|
is_worktree: false,
|
|
base_repo: None,
|
|
// Old commit…
|
|
head_mtime: Some(t("2026-08-01T10:00:00Z")),
|
|
};
|
|
let repo_stale = DiscoveredRepo {
|
|
path: PathBuf::from("/w/stale"),
|
|
name: "stale".into(),
|
|
is_worktree: false,
|
|
base_repo: None,
|
|
head_mtime: None,
|
|
};
|
|
|
|
let history = vec![
|
|
// Newest overall: a subdir of /w/hist (first match wins for it).
|
|
recent("/w/hist/crates", "opencode", "2026-08-22T09:00:00Z"),
|
|
recent("/w/hist", "claude", "2026-08-20T09:00:00Z"),
|
|
];
|
|
let projects = to_projects(&[repo_old, repo_hist, repo_stale], &history);
|
|
|
|
let paths: Vec<&str> = projects.iter().map(|p| p.path.to_str().unwrap()).collect();
|
|
assert_eq!(paths, ["/w/old", "/w/hist", "/w/stale"]);
|
|
|
|
// old: git activity wins (never spawned).
|
|
assert_eq!(projects[0].last_activity, Some(t("2026-08-23T10:00:00Z")));
|
|
assert_eq!(projects[0].last_command, None);
|
|
// hist: spawn history beats the old commit; command from the newest
|
|
// matching entry (the crates/ one, not the repo root one).
|
|
assert_eq!(projects[1].last_activity, Some(t("2026-08-22T09:00:00Z")));
|
|
assert_eq!(projects[1].last_command.as_deref(), Some("opencode"));
|
|
// stale: neither source knows anything.
|
|
assert_eq!(projects[2].last_activity, None);
|
|
assert_eq!(projects[2].last_command, None);
|
|
}
|
|
|
|
fn t(s: &str) -> DateTime<Utc> {
|
|
DateTime::parse_from_rfc3339(s).unwrap().with_timezone(&Utc)
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn scanner_caches_within_ttl_and_rescans_after() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let mut scanner = ProjectScanner::new(
|
|
vec![tmp.path().to_path_buf()],
|
|
3,
|
|
PathBuf::from("/nonexistent"),
|
|
);
|
|
|
|
let empty = scanner.repos().await;
|
|
assert!(empty.is_empty());
|
|
|
|
make_repo(tmp.path(), "late");
|
|
// Within the TTL the cached (empty) snapshot is still served.
|
|
let still_empty = scanner.repos().await;
|
|
assert!(still_empty.is_empty());
|
|
|
|
// After the TTL lapses the rescan sees the new repo.
|
|
scanner.ttl = Duration::ZERO;
|
|
let fresh = scanner.repos().await;
|
|
assert_eq!(fresh.len(), 1);
|
|
assert_eq!(fresh[0].name, "late");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn background_refresh_honours_the_ttl() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let mut scanner = ProjectScanner::new(
|
|
vec![tmp.path().to_path_buf()],
|
|
3,
|
|
PathBuf::from("/nonexistent"),
|
|
);
|
|
|
|
let empty = scanner.repos().await;
|
|
assert!(empty.is_empty());
|
|
|
|
make_repo(tmp.path(), "late");
|
|
// A background tick inside the TTL must not re-walk the filesystem:
|
|
// the new repo stays invisible until the cache expires.
|
|
scanner.refresh().await;
|
|
assert!(scanner.repos().await.is_empty());
|
|
|
|
// Once the TTL lapses, the next tick picks it up.
|
|
scanner.ttl = Duration::ZERO;
|
|
scanner.refresh().await;
|
|
let fresh = scanner.repos().await;
|
|
assert_eq!(fresh.len(), 1);
|
|
assert_eq!(fresh[0].name, "late");
|
|
}
|
|
|
|
#[test]
|
|
fn disabled_scanner_always_serves_empty() {
|
|
let scanner = ProjectScanner::disabled();
|
|
assert_eq!(scanner.roots, Vec::<PathBuf>::new());
|
|
}
|
|
}
|