use super::*;
use std::path::Path;
use std::process::Command;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
use tempfile::TempDir;
use crate::source::{
GitBackend, HttpBackend, ResolvePolicy, ResolveRequest, ResolvedSource, RevisionSpec,
RouterBackend, SnapshotId, SourceDirectoryEntry, SourceEntry, SourceError, SourceInventory,
SourceLocation, SourcePath, SourceStore, WorktreeDeployRequest, digest_snapshot,
worktree_admin_id,
};
use crate::sync::state::{Ejection, FileStateStore, HookState, StateError, StateStore};
type SourceResult<T> = std::result::Result<T, SourceError>;
type StoreResult<T> = std::result::Result<T, StateError>;
fn sn(name: &str) -> crate::source::SourceName {
crate::source::SourceName::trusted(name)
}
fn resolve_git_source(
store: &dyn SourceStore,
name: &str,
url: &str,
revision: RevisionSpec,
policy: ResolvePolicy,
) -> ResolvedSource {
store
.resolve(
&ResolveRequest {
name: sn(name),
location: SourceLocation::Git {
url: url.to_owned(),
},
revision,
},
policy,
)
.expect("resolve fixture Git source")
}
fn seed_git_mirror(store: &dyn SourceStore, name: &str, url: &str) {
let _ = resolve_git_source(
store,
name,
url,
RevisionSpec::Default,
ResolvePolicy::Refresh,
);
}
fn canonical_fixture_target(path: &Path) -> PathBuf {
path.canonicalize()
.unwrap_or_else(|error| panic!("canonicalize fixture target {}: {error}", path.display()))
}
fn one_commit(
parsed: &BTreeMap<String, ParsedSource>,
name: &str,
commit: &str,
) -> BTreeMap<(String, String), String> {
let key = (
name.to_owned(),
crate::lock::encode_ref(&parsed[name].refspec()),
);
std::iter::once((key, commit.to_owned())).collect()
}
fn one_resolved_source(
name: &str,
resolved_commit: &str,
resolved: ResolvedSource,
) -> ResolvedSourceMap {
let key = (name.to_owned(), resolved_commit.to_owned());
std::iter::once((key, resolved)).collect()
}
fn resolved_git_map(
store: &dyn SourceStore,
name: &str,
url: &str,
commit: &str,
) -> ResolvedSourceMap {
one_resolved_source(
name,
commit,
resolve_git_source(
store,
name,
url,
RevisionSpec::Commit(commit.parse().expect("fixture commit is valid")),
ResolvePolicy::CachedOnly,
),
)
}
fn resolved_worktree_map(store: &dyn SourceStore, name: &str, root: &Path) -> ResolvedSourceMap {
let resolved = store
.resolve(
&ResolveRequest {
name: sn(name),
location: SourceLocation::Worktree {
root: root.to_path_buf(),
follow_symlinks: false,
},
revision: RevisionSpec::None,
},
ResolvePolicy::Refresh,
)
.expect("capture fixture worktree");
one_resolved_source(name, "link", resolved)
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn run_git(cwd: &Path, args: &[&str]) {
crate::sync::state::locking::assert_git_sandboxed(cwd);
let _serial = crate::sync::state::locking::guard_git_fork();
let out = Command::new("git")
.args(args)
.current_dir(cwd)
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.env("GIT_CONFIG_SYSTEM", "/dev/null")
.env("GIT_CONFIG_NOSYSTEM", "1")
.env("GIT_AUTHOR_DATE", "@1700000000 +0000")
.env("GIT_COMMITTER_DATE", "@1700000000 +0000")
.output()
.unwrap();
assert!(
out.status.success(),
"git {args:?} failed: {}",
String::from_utf8_lossy(&out.stderr)
);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn rev_parse(cwd: &Path, rev: &str) -> String {
let _serial = crate::sync::state::locking::guard_git_fork();
let out = Command::new("git")
.args(["rev-parse", rev])
.current_dir(cwd)
.output()
.unwrap();
assert!(out.status.success(), "rev-parse {rev} failed");
String::from_utf8(out.stdout).unwrap().trim().to_string()
}
fn git_show_path(cwd: &Path, commit: &str, path: &str) -> Option<Vec<u8>> {
let _serial = crate::sync::state::locking::guard_git_fork();
let spec = format!("{commit}:{path}");
let output = Command::new("git")
.args(["show", spec.as_str()])
.current_dir(cwd)
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.env("GIT_CONFIG_SYSTEM", "/dev/null")
.env("GIT_CONFIG_NOSYSTEM", "1")
.output()
.expect("run git show for fixture premise");
if output.status.success() {
Some(output.stdout)
} else {
None
}
}
struct SyncFixture {
src: TempDir,
git_dir: TempDir,
_state_dir: TempDir,
backend: GitBackend,
registry: FileStateStore,
url: String,
head_sha: String,
}
fn test_protected(cwd: &Path) -> super::confine::ProtectedPathSet {
super::confine::ProtectedPathSet::resolve(&crate::config::Paths::default(), cwd)
.expect("protected set")
}
fn linked_flat_record(target: &str, source: &str, artifact: &str) -> ArtifactRecord {
ArtifactRecord {
version: 1,
key: artifact_key(target, source, artifact),
source: source.to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
projected_at: "2026-06-08T12:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: true,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
}
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_sync_fixture() -> SyncFixture {
let src = TempDir::new().unwrap();
let src_path = src.path();
run_git(src_path, &["init", "-b", "main", "."]);
run_git(src_path, &["config", "user.email", "test@example.com"]);
run_git(src_path, &["config", "user.name", "Test"]);
std::fs::create_dir_all(src_path.join("editor")).unwrap();
std::fs::write(src_path.join("editor/init.lua"), b"-- init\n").unwrap();
std::fs::write(src_path.join("editor/notes.bak"), b"scratch\n").unwrap();
std::fs::create_dir_all(src_path.join("docs")).unwrap();
std::fs::write(src_path.join("docs/readme.md"), b"# docs\n").unwrap();
run_git(src_path, &["add", "-A"]);
run_git(src_path, &["commit", "-m", "initial"]);
let head_sha = rev_parse(src_path, "HEAD");
let git_dir = TempDir::new().unwrap();
let state_dir = TempDir::new().unwrap();
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry =
FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry over tempdir");
let url = src_path.to_string_lossy().into_owned();
SyncFixture {
src,
git_dir,
_state_dir: state_dir,
backend,
registry,
url,
head_sha,
}
}
impl SyncFixture {
#[expect(
clippy::unwrap_used,
reason = "fixture mutation fails loudly; git CLI is assumed present"
)]
fn advance_head(&self) -> String {
std::fs::write(self.src.path().join("editor/extra.lua"), b"-- extra\n").unwrap();
run_git(self.src.path(), &["add", "-A"]);
run_git(self.src.path(), &["commit", "-m", "second"]);
rev_parse(self.src.path(), "HEAD")
}
}
struct FullScanCountingRegistry<'a> {
inner: &'a FileStateStore,
full_scans: AtomicUsize,
}
impl<'a> FullScanCountingRegistry<'a> {
fn new(inner: &'a FileStateStore) -> Self {
Self {
inner,
full_scans: AtomicUsize::new(0),
}
}
fn reset(&self) {
self.full_scans.store(0, AtomicOrdering::SeqCst);
}
fn full_scan_count(&self) -> usize {
self.full_scans.load(AtomicOrdering::SeqCst)
}
fn count_full_scan(&self) {
self.full_scans.fetch_add(1, AtomicOrdering::SeqCst);
}
}
impl crate::sync::state::StateStore for FullScanCountingRegistry<'_> {
fn artifact(
&self,
key: &crate::sync::state::ArtifactKey,
) -> StoreResult<Option<ArtifactRecord>> {
crate::sync::state::StateStore::artifact(self.inner, key)
}
fn put_artifact(&self, record: &ArtifactRecord) -> StoreResult<()> {
crate::sync::state::StateStore::put_artifact(self.inner, record)
}
fn remove_artifact(&self, key: &crate::sync::state::ArtifactKey) -> StoreResult<()> {
crate::sync::state::StateStore::remove_artifact(self.inner, key)
}
fn target_artifacts(&self, target: &str) -> StoreResult<Vec<ArtifactRecord>> {
crate::sync::state::StateStore::target_artifacts(self.inner, target)
}
fn all_artifacts(&self) -> StoreResult<Vec<ArtifactRecord>> {
self.count_full_scan();
crate::sync::state::StateStore::all_artifacts(self.inner)
}
fn ejections(&self, target: &str) -> StoreResult<Vec<Ejection>> {
crate::sync::state::StateStore::ejections(self.inner, target)
}
fn save_ejections(&self, target: &str, entries: &[Ejection]) -> StoreResult<()> {
crate::sync::state::StateStore::save_ejections(self.inner, target, entries)
}
fn hook_state(&self, target: &str) -> StoreResult<Vec<HookState>> {
crate::sync::state::StateStore::hook_state(self.inner, target)
}
fn record_hook_success(
&self,
target: &str,
hook_id: &str,
digest_set: &BTreeSet<String>,
) -> StoreResult<()> {
crate::sync::state::StateStore::record_hook_success(self.inner, target, hook_id, digest_set)
}
fn acquire_lock(&self) -> StoreResult<crate::sync::state::locking::StateLock> {
crate::sync::state::StateStore::acquire_lock(self.inner)
}
fn journal_root(&self) -> PathBuf {
crate::sync::state::StateStore::journal_root(self.inner)
}
}
struct CountingBackend<'a> {
inner: &'a GitBackend,
fetches: AtomicUsize,
resolves: AtomicUsize,
reads: AtomicUsize,
total_reads: AtomicUsize,
seen_reads: Mutex<BTreeSet<(String, String, String)>>,
discovers: AtomicUsize,
}
impl<'a> CountingBackend<'a> {
fn new(inner: &'a GitBackend) -> Self {
Self {
inner,
fetches: AtomicUsize::new(0),
resolves: AtomicUsize::new(0),
reads: AtomicUsize::new(0),
total_reads: AtomicUsize::new(0),
seen_reads: Mutex::new(BTreeSet::new()),
discovers: AtomicUsize::new(0),
}
}
fn fetch_count(&self) -> usize {
self.fetches.load(AtomicOrdering::SeqCst)
}
fn resolve_count(&self) -> usize {
self.resolves.load(AtomicOrdering::SeqCst)
}
fn read_count(&self) -> usize {
self.reads.load(AtomicOrdering::SeqCst)
}
fn total_read_count(&self) -> usize {
self.total_reads.load(AtomicOrdering::SeqCst)
}
fn reset_read_probe(&self) {
self.reads.store(0, AtomicOrdering::SeqCst);
self.seen_reads.lock().expect("seen reads").clear();
}
fn discover_count(&self) -> usize {
self.discovers.load(AtomicOrdering::SeqCst)
}
}
impl SourceStore for CountingBackend<'_> {
fn plan_refresh(&self, plan: &crate::source::RefreshPlan) {
SourceStore::plan_refresh(self.inner, plan);
}
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
if policy == ResolvePolicy::Refresh {
self.fetches.fetch_add(1, AtomicOrdering::SeqCst);
}
if !matches!(&request.revision, RevisionSpec::Commit(_)) {
self.resolves.fetch_add(1, AtomicOrdering::SeqCst);
}
SourceStore::resolve(self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
self.discovers.fetch_add(1, AtomicOrdering::SeqCst);
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
self.total_reads.fetch_add(1, AtomicOrdering::SeqCst);
let key = (
snapshot.mirror().as_str().to_owned(),
snapshot.commit().to_string(),
path.as_str().to_owned(),
);
if !self.seen_reads.lock().expect("seen reads").insert(key) {
self.reads.fetch_add(1, AtomicOrdering::SeqCst);
}
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
#[test]
fn sync_reads_one_projection_inventory_across_drop_deploy_and_prune() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target(
"editor-src",
&fx.url,
"dest",
&td.target_path(),
"by-source",
);
let counting = CountingBackend::new(&fx.backend);
let mut request = input(&cfg, None, None, None, false);
request.fast_forward = true;
request.prune = true;
sync(&request, &counting, &fx.registry)
.expect("a fresh fast-forward + prune sync must succeed");
assert_eq!(
counting.discover_count(),
2,
"the final store performs exactly one inventory for lock digest selection and exactly one \
to build the Projection. The projection inventory must then be threaded through \
fast-forward/drop guarding, deploy/observe/reconcile/apply, and prune; any third inventory \
would reopen the phase-local TOCTOU window"
);
}
fn config_with_source(name: &str, url: &str) -> Config {
let toml = format!("version = 1\n\n[sources.{name}]\ngit = \"{url}\"\nbranch = \"main\"\n");
Config::parse(&toml).expect("source-only config parses")
}
fn config_with_scoped_source(name: &str, url: &str) -> Config {
let toml = format!(
"version = 1\n\n[sources.{name}]\ngit = \"{url}\"\nbranch = \"main\"\n\
root = \"editor\"\ninclude = [\"init.lua\"]\nexclude = [\"**/*.bak\"]\n"
);
Config::parse(&toml).expect("scoped source config parses")
}
fn input<'a>(
base: &'a Config,
local: Option<&'a Config>,
base_lock: Option<Lock>,
local_lock: Option<Lock>,
force: bool,
) -> SyncInput<'a> {
SyncInput {
base_config: base,
local_config: local,
base_lock,
local_lock,
force,
interactive: false,
prune: false,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
}
}
fn expected_digest(fx: &SyncFixture, name: &str, commit: &str) -> String {
let resolved = resolve_git_source(
&fx.backend,
name,
&fx.url,
RevisionSpec::Commit(commit.parse().expect("fixture commit")),
ResolvePolicy::CachedOnly,
);
let inventory = fx
.backend
.inventory(&resolved.snapshot, None)
.expect("inventory fixture tree");
let leaves: Vec<SourcePath> = inventory
.entries
.into_iter()
.map(|entry| entry.path)
.collect();
digest_snapshot(&fx.backend, &resolved.snapshot, &leaves)
.expect("digest computes over fixture tree")
}
struct RootedFixtureStore<'a> {
inner: &'a dyn SourceStore,
root: SourcePath,
}
impl RootedFixtureStore<'_> {
fn prefixed(&self, path: &SourcePath) -> SourcePath {
SourcePath::new(&format!("{}/{}", self.root.as_str(), path.as_str()))
.expect("rooted fixture path")
}
}
impl SourceStore for RootedFixtureStore<'_> {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
self.inner.resolve(request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
self.inner.inventory(snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
let mut entry = self.inner.read(snapshot, &self.prefixed(path))?;
entry.meta.path = path.clone();
Ok(entry)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
let prefixed = path.map(|path| self.prefixed(path));
self.inner.list_directory(snapshot, prefixed.as_ref())
}
}
fn expected_digest_for_source(
fx: &SyncFixture,
source: &ParsedSource,
name: &str,
commit: &str,
) -> String {
let resolved = resolve_git_source(
&fx.backend,
name,
&fx.url,
RevisionSpec::Commit(commit.parse().expect("fixture commit")),
ResolvePolicy::CachedOnly,
);
let inventory = fx
.backend
.inventory(&resolved.snapshot, None)
.expect("inventory fixture tree");
let candidates: Vec<&str> = inventory
.entries
.iter()
.map(|entry| entry.path.as_str())
.collect();
let selection = crate::projection::offer::OfferSelection::compile(
source.includes(),
source.excludes(),
source.root.as_deref(),
)
.expect("source selection compiles");
let leaves: Vec<SourcePath> = selection
.select(&candidates)
.into_iter()
.map(|path| SourcePath::new(&path).expect("selected fixture path"))
.collect();
match source.root.as_deref() {
Some(root) => digest_snapshot(
&RootedFixtureStore {
inner: &fx.backend,
root: SourcePath::new(&root.to_string_lossy()).expect("fixture root"),
},
&resolved.snapshot,
&leaves,
)
.expect("scoped digest computes over fixture tree"),
None => digest_snapshot(&fx.backend, &resolved.snapshot, &leaves)
.expect("selected digest computes over fixture tree"),
}
}
fn parsed_of(cfg: &Config, name: &str) -> ParsedSource {
let raw = cfg.sources.get(name).expect("source present");
ParsedSource::parse(name, raw).expect("source parses to typed form")
}
fn config_digest_of(cfg: &Config, name: &str) -> String {
parsed_of(cfg, name).config_digest()
}
#[test]
fn resolves_source_with_no_prior_lock_into_base_lock() {
let fx = build_sync_fixture();
let cfg = config_with_scoped_source("editor-src", &fx.url);
let source = parsed_of(&cfg, "editor-src");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync resolves a fresh source");
let locked = out
.base_lock
.find_source("editor-src")
.expect("resolved source lands in the base lock");
assert_eq!(
locked.commit, fx.head_sha,
"branch main resolves to the fixture's HEAD commit"
);
assert_eq!(
locked.commit.len(),
40,
"resolved commit must be a full 40-hex sha"
);
assert!(
locked.commit.chars().all(|c| c.is_ascii_hexdigit()),
"commit must be hex"
);
assert_eq!(
locked.resolved, "main",
"resolved field records the refspec string"
);
assert_eq!(locked.git, fx.url, "locked git url matches the source");
assert_eq!(
locked.digest,
expected_digest_for_source(&fx, &source, "editor-src", &fx.head_sha),
"digest must equal compute_digest with the source's own root + include/exclude"
);
assert_ne!(
locked.digest,
expected_digest(&fx, "editor-src", &fx.head_sha),
"sync must propagate root/include/exclude: scoping to editor/ and dropping *.bak \
must yield a different digest than an empty matcher over the whole tree"
);
assert!(
locked.digest.starts_with("blake3:"),
"digest carries the blake3: prefix, got {}",
locked.digest
);
assert_eq!(
locked.config_digest,
config_digest_of(&cfg, "editor-src"),
"config_digest must equal the source's config digest"
);
}
fn config_with_link_source(name: &str, url: &str) -> Config {
let toml = format!(
"version = 1\n\n[sources.{name}]\ngit = \"{url}\"\nbranch = \"main\"\ndeploy = \"link\"\n"
);
Config::parse(&toml).expect("link source config parses")
}
#[test]
fn link_source_resolves_without_mirror_into_audit_lock_entry() {
let fx = build_sync_fixture();
let cfg = config_with_link_source("dev-src", &fx.url);
let counting = CountingBackend::new(&fx.backend);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let routed = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
None,
&counting,
false,
false,
None,
crate::sync::progress::SILENT,
)
.expect("link source resolves with no reachable mirror");
let (_name, locked) = routed
.locks
.iter()
.find(|(n, _)| n == "dev-src")
.expect("link source routed into a lock entry");
assert_eq!(
locked.resolved, "link",
"a link entry is marked with the \"link\" sentinel in `resolved`"
);
assert_eq!(
locked.git, fx.url,
"link entry records the local working-tree path as its git source"
);
assert_eq!(
locked.commit, fx.head_sha,
"link entry commit is HEAD read directly from the local repo, not a mirror clone"
);
assert_eq!(
locked.config_digest,
config_digest_of(&cfg, "dev-src"),
"config_digest is recorded as usual"
);
}
#[test]
fn link_source_skips_fetch_and_mirror_digest() {
let fx = build_sync_fixture();
let cfg = config_with_link_source("dev-src", &fx.url);
let counting = CountingBackend::new(&fx.backend);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let _ = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
None,
&counting,
false,
false,
None,
crate::sync::progress::SILENT,
)
.expect("link source resolves without touching the mirror");
assert_eq!(
counting.fetch_count(),
0,
"a link source must not fetch the git mirror"
);
assert_eq!(
counting.read_count(),
0,
"a link source must not read a mirror snapshot to compute a digest"
);
}
#[test]
fn matching_lock_reuses_commit_without_refetch() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let source = parsed_of(&cfg, "editor-src");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let prior = Lock {
version: 1,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: fx.url.clone(),
resolved: source.refspec().to_string(),
commit: fx.head_sha.clone(),
digest: expected_digest(&fx, "editor-src", &fx.head_sha),
config_digest: source.config_digest(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let new_head = fx.advance_head();
assert_ne!(new_head, fx.head_sha, "fixture HEAD must have moved");
let counting = CountingBackend::new(&fx.backend);
let in_ = input(&cfg, None, Some(prior), None, false);
let out = sync(&in_, &counting, &fx.registry).expect("sync reuses the matching lock");
assert_eq!(
counting.fetch_count(),
0,
"a matching lock must suppress fetch entirely"
);
assert_eq!(
counting.resolve_count(),
0,
"a matching lock must reuse the locked commit, not re-resolve the cached mirror"
);
let locked = out
.base_lock
.find_source("editor-src")
.expect("source still in base lock");
assert_eq!(
locked.commit, fx.head_sha,
"matched source must keep the locked commit, not re-resolve to the new HEAD"
);
assert_ne!(
locked.commit, new_head,
"no refetch means the advanced HEAD must not leak into the lock"
);
}
#[test]
fn matching_lock_reuses_digest_but_invalidated_lock_recomputes_it() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let source = parsed_of(&cfg, "editor-src");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let real_digest = expected_digest(&fx, "editor-src", &fx.head_sha);
let sentinel_digest =
"blake3:0000000000000000000000000000000000000000000000000000000000000000".to_owned();
assert_ne!(sentinel_digest, real_digest, "sentinel must be stale");
let matching = Lock {
version: crate::lock::LOCK_SCHEMA_VERSION,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: fx.url.clone(),
resolved: source.refspec().to_string(),
commit: fx.head_sha.clone(),
digest: sentinel_digest.clone(),
config_digest: source.config_digest(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let mut invalidated = matching.clone();
invalidated.sources[0].config_digest = "blake3:invalidated".to_owned();
let invalidated_backend = CountingBackend::new(&fx.backend);
let invalidated_out = sync(
&input(&cfg, None, Some(invalidated), None, false),
&invalidated_backend,
&fx.registry,
)
.expect("invalidated locked source syncs");
let recomputed = invalidated_out
.base_lock
.find_source("editor-src")
.expect("invalidated source is relocked");
assert_eq!(
recomputed.commit, fx.head_sha,
"the invalidated source still resolves to the same commit"
);
assert_eq!(
recomputed.digest, real_digest,
"recomputing the unchanged snapshot replaces the stale locked digest"
);
assert!(
invalidated_backend.total_read_count() > 0,
"a nonmatching config digest must still read blobs to recompute the source digest"
);
let matching_backend = CountingBackend::new(&fx.backend);
let matching_out = sync(
&input(&cfg, None, Some(matching), None, false),
&matching_backend,
&fx.registry,
)
.expect("matching locked source syncs");
assert_eq!(
matching_out
.base_lock
.find_source("editor-src")
.expect("matching source remains locked")
.digest,
sentinel_digest,
"a matching unchanged source preserves its locked digest"
);
assert_eq!(
matching_backend.total_read_count(),
0,
"a matching unchanged source must reuse its locked digest without reading blobs"
);
}
#[test]
fn non_matching_lock_triggers_fetch() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let stale = Lock {
version: 1,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: "https://github.com/other/repo.git".to_owned(),
resolved: "main".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:stale".to_owned(),
config_digest: "blake3:stale".to_owned(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let counting = CountingBackend::new(&fx.backend);
let in_ = input(&cfg, None, Some(stale), None, false);
let out = sync(&in_, &counting, &fx.registry).expect("sync re-resolves a stale source");
assert!(
counting.fetch_count() >= 1,
"a non-matching lock must fetch at least once"
);
let locked = out
.base_lock
.find_source("editor-src")
.expect("source resolved");
assert_eq!(
locked.commit, fx.head_sha,
"stale lock must be replaced by the freshly resolved HEAD"
);
}
struct DenyNetworkBackend<'a> {
inner: &'a GitBackend,
}
impl SourceStore for DenyNetworkBackend<'_> {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
if policy == ResolvePolicy::Refresh {
return Err(SourceError::Source("frozen must not fetch".to_owned()));
}
SourceStore::resolve(self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
#[test]
fn frozen_errors_naming_source_when_no_lock_entry() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let backend = DenyNetworkBackend { inner: &fx.backend };
let err = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
None,
&backend,
false,
true,
None,
crate::sync::progress::SILENT,
)
.err()
.expect("frozen with no lock entry must hard-error instead of fetching");
assert!(
err.to_string().contains("editor-src"),
"the frozen diagnostic must name the missing source, got: {err}"
);
}
#[test]
fn frozen_reuses_matching_lock_without_touching_network() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let source = parsed_of(&cfg, "editor-src");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let prior = Lock {
version: crate::lock::LOCK_SCHEMA_VERSION,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: fx.url.clone(),
resolved: source.refspec().to_string(),
commit: fx.head_sha.clone(),
digest: expected_digest(&fx, "editor-src", &fx.head_sha),
config_digest: source.config_digest(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let backend = DenyNetworkBackend { inner: &fx.backend };
let routed = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
Some(&prior),
&backend,
false,
true,
None,
crate::sync::progress::SILENT,
)
.expect("frozen with a matching lock must reuse it without fetch/resolve");
let (_name, locked) = routed
.locks
.iter()
.find(|(n, _)| n == "editor-src")
.expect("the matched source is routed from the lock");
assert_eq!(
locked.commit, fx.head_sha,
"frozen must reuse the locked commit, proving it never resolved the cached mirror"
);
}
#[test]
fn frozen_errors_on_drifted_lock_entry() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let drifted = Lock {
version: crate::lock::LOCK_SCHEMA_VERSION,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: "https://github.com/other/repo.git".to_owned(),
resolved: "main".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:stale".to_owned(),
config_digest: "blake3:stale".to_owned(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let backend = DenyNetworkBackend { inner: &fx.backend };
let err = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
Some(&drifted),
&backend,
false,
true,
None,
crate::sync::progress::SILENT,
)
.err()
.expect("frozen with a drifted lock entry must hard-error, not re-resolve");
assert!(
err.to_string().contains("editor-src"),
"the frozen drift diagnostic must name the drifted source, got: {err}"
);
}
#[test]
fn non_frozen_reresolves_drifted_lock_entry() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let drifted = Lock {
version: crate::lock::LOCK_SCHEMA_VERSION,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: "https://github.com/other/repo.git".to_owned(),
resolved: "main".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:stale".to_owned(),
config_digest: "blake3:stale".to_owned(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let counting = CountingBackend::new(&fx.backend);
let routed = resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
Some(&drifted),
&counting,
false,
false,
None,
crate::sync::progress::SILENT,
)
.expect("without --frozen a drifted lock must re-resolve, not error");
let (_name, locked) = routed
.locks
.iter()
.find(|(n, _)| n == "editor-src")
.expect("source re-resolved");
assert_eq!(
locked.commit, fx.head_sha,
"non-frozen drift must re-resolve to the fixture HEAD, replacing the stale lock"
);
}
#[test]
fn force_keeps_the_locked_commit_when_upstream_moves() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let source = parsed_of(&cfg, "editor-src");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let matching = Lock {
version: 1,
sources: vec![crate::lock::LockedSource {
name: "editor-src".to_owned(),
git: fx.url.clone(),
resolved: source.refspec().to_string(),
commit: fx.head_sha.clone(),
digest: expected_digest(&fx, "editor-src", &fx.head_sha),
config_digest: source.config_digest(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let new_head = fx.advance_head();
assert_ne!(new_head, fx.head_sha, "fixture HEAD must have moved to C2");
let counting = CountingBackend::new(&fx.backend);
let in_ = input(&cfg, None, Some(matching), None, true);
let out = sync(&in_, &counting, &fx.registry).expect("forced sync succeeds");
assert_eq!(
counting.fetch_count(),
0,
"force must not fetch when the lock matches"
);
let locked = out
.base_lock
.find_source("editor-src")
.expect("forced source still in base lock");
assert_eq!(
locked.commit, fx.head_sha,
"force must keep the locked commit C"
);
assert_ne!(
locked.commit, new_head,
"force must not advance to the new HEAD (C2); that is `update`"
);
}
#[test]
fn local_only_source_routes_into_the_local_lock() {
let fx = build_sync_fixture();
let base = config_with_source("base-src", &fx.url);
let local = config_with_source("local-src", &fx.url);
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync resolves base and local");
assert!(
out.base_lock.find_source("base-src").is_some(),
"a base-only source must land in the base lock"
);
assert!(
out.base_lock.find_source("local-src").is_none(),
"a locally-defined source must NOT appear in the base lock"
);
let local_lock = out
.local_lock
.expect("a local source produces a local lock");
assert!(
local_lock.find_source("local-src").is_some(),
"the locally-defined source must route into the local lock"
);
assert!(
local_lock.find_source("base-src").is_none(),
"a base-only source must NOT appear in the local lock"
);
}
#[test]
fn overridden_source_routes_to_local_lock() {
let fx = build_sync_fixture();
let base = config_with_source("editor-src", &fx.url);
let local = {
let toml = format!(
"version = 1\n\n[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n",
fx.url
);
Config::parse(&toml).expect("local override config parses")
};
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync resolves the overridden source");
assert!(
out.base_lock.find_source("editor-src").is_none(),
"a source overridden in local must NOT appear in the base lock"
);
let local_lock = out
.local_lock
.expect("an overridden source produces a local lock");
assert!(
local_lock.find_source("editor-src").is_some(),
"a source present in BOTH base and local must route into the local lock"
);
}
#[test]
fn base_only_run_produces_no_local_lock() {
let fx = build_sync_fixture();
let cfg = config_with_source("editor-src", &fx.url);
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync resolves a base-only config");
assert!(
out.local_lock.is_none(),
"with no local config there must be no local lock"
);
}
use std::path::PathBuf;
use crate::sync::journal::JournalEntry;
use crate::sync::inspect::ArtifactState;
use crate::sync::state::{ArtifactKey, ArtifactRecord, ManifestFile, RecordKind};
struct TargetDir {
_parent: TempDir,
parent_path: PathBuf,
}
impl TargetDir {
fn new() -> Self {
let parent = TempDir::new().expect("target parent tempdir");
let parent_path = parent.path().to_path_buf();
Self {
_parent: parent,
parent_path,
}
}
fn target_path(&self) -> PathBuf {
self.parent_path.join("dest")
}
fn artifact_dst(
&self,
layout: &crate::config::LayoutConfig,
source: &str,
artifact: &str,
) -> PathBuf {
self.target_path()
.join(layout.artifact_path(source, artifact))
}
fn has_phora_leftover(&self) -> bool {
std::fs::read_dir(&self.parent_path)
.expect("read target parent")
.filter_map(std::result::Result::ok)
.any(|e| e.file_name().to_string_lossy().starts_with(".phora-"))
}
}
fn contains_phora_metadata(dir: &Path) -> bool {
walkdir::WalkDir::new(dir)
.into_iter()
.filter_map(std::result::Result::ok)
.any(|e| e.file_name().to_string_lossy().starts_with(".phora"))
}
fn config_one_source_one_target(
source: &str,
url: &str,
target: &str,
target_path: &Path,
layout: &str,
) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.{target}]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n",
target_path.display(),
);
Config::parse(&toml).expect("one-source one-target config parses")
}
fn artifact_key(target: &str, source: &str, artifact: &str) -> ArtifactKey {
ArtifactKey {
target: target.to_owned(),
source: source.to_owned(),
artifact: artifact.to_owned(),
}
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_named_artifact_repo(artifact: &str, file: &str, content: &[u8]) -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join(artifact)).unwrap();
std::fs::write(p.join(artifact).join(file), content).unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn flat_layout() -> crate::config::LayoutConfig {
crate::config::LayoutConfig::default()
}
struct FailingReadBackend<'a> {
inner: &'a GitBackend,
fail_artifact: String,
reads_by_path: Mutex<BTreeMap<String, usize>>,
}
impl<'a> FailingReadBackend<'a> {
fn new(inner: &'a GitBackend, fail_artifact: &str) -> Self {
Self {
inner,
fail_artifact: fail_artifact.to_owned(),
reads_by_path: Mutex::new(BTreeMap::new()),
}
}
}
impl SourceStore for FailingReadBackend<'_> {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
SourceStore::resolve(self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
if path.as_str().split('/').next() == Some(self.fail_artifact.as_str()) {
let mut reads = self.reads_by_path.lock().expect("read counters");
let count = reads.entry(path.as_str().to_owned()).or_default();
*count += 1;
if *count > 1 {
return Err(SourceError::Source(format!(
"injected staging read failure for {}",
self.fail_artifact
)));
}
}
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
#[test]
fn sync_deploys_missing_artifact_files_into_target() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync deploys the source");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua present"),
b"-- init\n",
"a Missing artifact must be exported and its files materialized at the target dst"
);
assert!(
!out.had_failures,
"a clean single-artifact deploy must report no failures"
);
}
#[test]
fn sync_records_the_deployed_artifact_in_the_registry() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &fx.backend, &fx.registry).expect("sync deploys the source");
let rec = fx
.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get must not error")
.expect("deploy must persist a registry record for (dest,editor-src,editor)");
assert_eq!(rec.key.target, "dest");
assert_eq!(rec.key.source, "editor-src");
assert_eq!(rec.key.artifact, "editor");
assert!(
rec.files.iter().any(|f| f.path == *Path::new("init.lua")),
"the persisted record must list the exported init.lua, got {:?}",
rec.files
);
}
#[test]
fn sync_leaves_no_phora_metadata_inside_the_target() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &fx.backend, &fx.registry).expect("sync deploys the source");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
dst.join("init.lua").exists(),
"premise: the artifact must actually be deployed before the no-metadata check is meaningful"
);
assert!(
!contains_phora_metadata(&td.target_path()),
"the deployed target must contain NO .phora-* bookkeeping (no-target-metadata invariant), \
found phora metadata under {}",
td.target_path().display()
);
assert!(
!td.has_phora_leftover(),
"after a successful sync the target parent must hold no .phora-* staging/backup leftover"
);
}
#[test]
fn sync_skips_clean_artifact_on_second_run_without_re_export() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let counting = CountingBackend::new(&fx.backend);
let first = sync(
&input(&cfg, None, None, None, false),
&counting,
&fx.registry,
)
.expect("first sync deploys");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
dst.join("init.lua").exists(),
"premise: the first sync must actually deploy the artifact"
);
let staging_reads_after_first = counting.read_count();
assert!(
staging_reads_after_first >= 1,
"premise: the first run of a Missing artifact must read its source leaves again for \
staging after digesting, got {staging_reads_after_first} repeated reads"
);
counting.reset_read_probe();
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&counting,
&fx.registry,
)
.expect("second sync runs cleanly");
assert!(!second.had_failures, "second clean sync must not fail");
assert_eq!(
counting.read_count(),
0,
"a Clean artifact must NOT be re-staged on the second run: \
each immutable source leaf may be read once for digesting, but none may be read \
again for staging"
);
}
#[test]
fn sync_errors_on_flat_layout_collision_naming_artifact_sources_and_target() {
let fx_a = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let fx_b = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.src-a]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[sources.src-b]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"src-a\", \"src-b\"]\nlayout = \"flat\"\n",
fx_a.1,
fx_b.1,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-source flat-layout config parses");
let in_ = input(&cfg, None, None, None, false);
let Err(err) = sync(&in_, &backend, ®istry) else {
panic!("two sources exposing `shared` into a flat target must collide (return Err)");
};
assert_cross_binding_collision(&err.to_string(), "shared");
drop(fx_a);
drop(fx_b);
}
fn assert_overlap_rejected(
result: Result<SyncOutput>,
registry: &FileStateStore,
targets: (&str, &str),
overlap: &str,
absent_roots: &[PathBuf],
) {
let Err(err) = result else {
panic!(
"R4: targets `{}` and `{}` whose physical destinations overlap must hard-error \
sync-side (SelectionDiagnostic-shaped) BEFORE any staging/mutation — today sync \
warns+skips or deploys",
targets.0, targets.1
);
};
let msg = err.to_string();
assert!(
msg.contains(targets.0) && msg.contains(targets.1),
"R4: the overlap diagnostic must name BOTH offending targets `{}` and `{}`; got: {msg}",
targets.0,
targets.1
);
assert!(
msg.contains(overlap),
"R4: the overlap diagnostic must name the overlapping physical path `{overlap}`; got: {msg}"
);
let records = registry
.all_artifacts()
.expect("list_all after a pre-mutation rejection");
assert!(
records.is_empty(),
"R4: zero mutation — registry.all_artifacts() must be empty after the pre-mutation overlap \
check errs, got {records:?}"
);
for root in absent_roots {
assert!(
!root.exists(),
"R4: no target root/artifact may reach disk before the overlap check errs: {}",
root.display()
);
}
}
#[test]
fn sync_rejects_two_targets_with_equal_physical_destinations() {
let (sa, url_a) = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{0}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{0}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
base.display(),
);
let cfg = Config::parse(&toml).expect("equal-destination two-target config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"shared",
&[base.clone(), base.join("shared")],
);
drop(sa);
drop(sb);
}
#[test]
fn sync_rejects_overlap_with_outer_target_lexically_first() {
let (so, url_o) = build_named_artifact_repo("od", "f.txt", b"outer\n");
let (si, url_i) = build_named_artifact_repo("id", "g.txt", b"inner\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let toml = format!(
"version = 1\n\n\
[sources.so]\ngit = \"{url_o}\"\nbranch = \"main\"\n\n\
[sources.si]\ngit = \"{url_i}\"\nbranch = \"main\"\n\n\
[targets.a_outer]\npath = \"{}\"\nsources = [\"so\"]\nlayout = \"flat\"\n\n\
[targets.b_inner]\npath = \"{}\"\nsources = [\"si\"]\nlayout = \"flat\"\n",
base.display(),
base.join("od").display(),
);
let cfg = Config::parse(&toml).expect("outer-lexically-first containment config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("a_outer", "b_inner"),
"od",
&[base.clone(), base.join("od")],
);
drop(so);
drop(si);
}
#[test]
fn sync_rejects_overlap_with_inner_target_lexically_first() {
let (so, url_o) = build_named_artifact_repo("od", "f.txt", b"outer\n");
let (si, url_i) = build_named_artifact_repo("id", "g.txt", b"inner\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let toml = format!(
"version = 1\n\n\
[sources.so]\ngit = \"{url_o}\"\nbranch = \"main\"\n\n\
[sources.si]\ngit = \"{url_i}\"\nbranch = \"main\"\n\n\
[targets.a_inner]\npath = \"{}\"\nsources = [\"si\"]\nlayout = \"flat\"\n\n\
[targets.b_outer]\npath = \"{}\"\nsources = [\"so\"]\nlayout = \"flat\"\n",
base.join("od").display(),
base.display(),
);
let cfg = Config::parse(&toml).expect("inner-lexically-first containment config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("a_inner", "b_outer"),
"od",
&[base.clone(), base.join("od")],
);
drop(so);
drop(si);
}
#[cfg(unix)]
#[test]
fn sync_repeats_disjoint_link_targets_sharing_files_or_directories() {
for collapse in [false, true] {
let (source, url) = build_named_artifact_repo("shared", "f.txt", b"linked\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let alpha = td.target_path().join("alpha");
let beta = td.target_path().join("beta");
let cfg = Config::parse(&format!(
"version = 1\n\n\
[sources.linked]\npath = '{url}'\ndeploy = 'link'\n\n\
[targets.alpha]\npath = '{}'\nlayout = 'flat'\n\
[targets.alpha.sources]\nlinked = {{ collapse = {collapse} }}\n\n\
[targets.beta]\npath = '{}'\nlayout = 'flat'\n\
[targets.beta.sources]\nlinked = {{ collapse = {collapse} }}\n",
alpha.display(),
beta.display(),
))
.expect("shared link-source config parses");
let first = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first link sync succeeds");
assert!(!first.had_failures);
let second = sync(
&input(&cfg, None, Some(first.base_lock), None, false),
&backend,
®istry,
)
.expect("repeat link sync keeps distinct destination identities");
assert!(!second.had_failures);
for target in [&alpha, &beta] {
let artifact = if collapse { "shared" } else { "shared/f.txt" };
assert!(target.join(artifact).is_symlink());
assert_eq!(
std::fs::read(target.join("shared/f.txt")).expect("read linked content"),
b"linked\n"
);
}
assert_eq!(
std::fs::read(source.path().join("shared/f.txt")).expect("read source"),
b"linked\n"
);
}
}
#[cfg(unix)]
#[test]
fn sync_rejects_link_targets_sharing_a_destination_or_symlinked_parent() {
for alias_parent in [false, true] {
let (source, _url) = build_named_artifact_repo("shared", "f.txt", b"linked\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let physical = td.target_path().join("physical");
std::fs::create_dir_all(&physical).expect("create target parent");
let second = if alias_parent {
let alias = td.target_path().join("alias");
std::os::unix::fs::symlink(&physical, &alias).expect("alias target parent");
alias
} else {
physical.clone()
};
let cfg = config_link_source_two_targets("linked", source.path(), &physical, &second);
assert_overlap_rejected(
sync(&input(&cfg, None, None, None, false), &backend, ®istry),
®istry,
("first", "second"),
"shared",
&[physical.join("linked/shared")],
);
}
}
#[test]
fn sync_allows_two_targets_with_disjoint_physical_roots() {
let (so, url_o) = build_named_artifact_repo("shared", "f.txt", b"outer\n");
let (si, url_i) = build_named_artifact_repo("x", "g.txt", b"inner\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let toml = format!(
"version = 1\n\n\
[sources.so]\ngit = \"{url_o}\"\nbranch = \"main\"\n\n\
[sources.si]\ngit = \"{url_i}\"\nbranch = \"main\"\n\n\
[targets.a_side]\npath = \"{}\"\nsources = [\"so\"]\nlayout = \"flat\"\n\n\
[targets.b_side]\npath = \"{}\"\nsources = [\"si\"]\nlayout = \"flat\"\n",
base.join("a").display(),
base.join("b").display(),
);
let cfg = Config::parse(&toml).expect("disjoint two-target config parses");
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("two targets with disjoint physical roots must sync cleanly");
assert!(
base.join("a/shared/f.txt").exists() && base.join("b/x/g.txt").exists(),
"disjoint targets both deploy — the overlap check must not reject non-overlapping roots"
);
drop(so);
drop(si);
}
#[test]
fn sync_rejects_two_targets_aliasing_one_destination_via_relative_and_absolute_spelling() {
let (sa, url_a) = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let cwd = std::env::current_dir().expect("resolve process cwd for the aliasing spelling");
let rel = format!("phora-r4-alias-{}", std::process::id());
let abs = cwd.join(&rel);
assert!(
!abs.exists(),
"premise: the aliased destination must not pre-exist in the run cwd: {}",
abs.display()
);
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{rel}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
abs.display(),
);
let cfg = Config::parse(&toml).expect("relative/absolute aliasing two-target config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"shared",
&[abs.clone(), abs.join("shared")],
);
drop(sa);
drop(sb);
}
#[cfg(unix)]
#[test]
fn sync_rejects_targets_aliasing_through_an_existing_directory_symlink_before_mutation() {
use std::os::unix::fs::symlink;
let (sa, url_a) = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let physical = base.join("physical");
let alias = base.join("alias");
std::fs::create_dir_all(&physical).expect("create existing physical target root");
symlink(&physical, &alias).expect("create directory symlink alias for target root");
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
physical.display(),
alias.display(),
);
let cfg = Config::parse(&toml).expect("directory-symlink alias config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"shared",
&[physical.join("shared")],
);
drop(sa);
drop(sb);
}
#[test]
fn sync_rejects_equivalent_target_roots_with_parent_components_before_mutation() {
let (sa, url_a) = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let physical = base.join("physical");
let parent_spelling = base.join("existing").join("..").join("physical");
std::fs::create_dir_all(base.join("existing"))
.expect("create the existing prefix needed to traverse a parent component");
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
physical.display(),
parent_spelling.display(),
);
let cfg = Config::parse(&toml).expect("parent-component alias config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"shared",
&[physical.clone(), physical.join("shared")],
);
drop(sa);
drop(sb);
}
#[cfg(unix)]
#[test]
fn sync_rejects_symlink_then_parent_alias_with_nonexistent_artifact_tail_before_mutation() {
use std::os::unix::fs::symlink;
let (sa, url_a) = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let physical = base.join("physical");
let symlink_destination = physical.join("child");
let alias = base.join("jump");
std::fs::create_dir_all(&symlink_destination)
.expect("create the existing directory reached by the symlink");
symlink(&symlink_destination, &alias)
.expect("create directory symlink before parent component");
let through_symlink_then_parent = alias.join("..");
let shared = physical.join("shared");
assert!(
!shared.exists(),
"premise: the aliased artifact tail must not exist before overlap validation"
);
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
physical.display(),
through_symlink_then_parent.display(),
);
let cfg = Config::parse(&toml).expect("symlink-then-parent alias config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"shared",
&[shared, base.join("shared")],
);
drop(sa);
drop(sb);
}
#[test]
fn sync_rejects_nonexistent_case_variant_placements_on_case_insensitive_filesystems() {
let (sa, url_a) = build_named_artifact_repo("Shared", "a.txt", b"from-a\n");
let (sb, url_b) = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let case_probe = base.join("PhoraCaseProbe");
std::fs::create_dir_all(&case_probe).expect("create filesystem case-sensitivity probe");
if !base.join("phoracaseprobe").is_dir() {
return;
}
let upper_root = base.join("TargetCase");
let lower_root = base.join("targetcase");
assert!(
!upper_root.exists() && !lower_root.exists(),
"premise: both case-variant target roots must be nonexistent before validation"
);
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n",
upper_root.display(),
lower_root.display(),
);
let cfg = Config::parse(&toml).expect("case-variant placement config parses");
let result = sync(&input(&cfg, None, None, None, false), &backend, ®istry);
assert_overlap_rejected(
result,
®istry,
("alpha", "beta"),
"hared",
&[upper_root.clone(), upper_root.join("Shared"), lower_root],
);
drop(sa);
drop(sb);
}
#[test]
fn sync_allows_targets_whose_roots_share_a_string_prefix_but_no_ancestor_relation() {
let (so, url_o) = build_named_artifact_repo("od", "f.txt", b"outer\n");
let (si, url_i) = build_named_artifact_repo("id", "g.txt", b"inner\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let base = td.target_path();
let toml = format!(
"version = 1\n\n\
[sources.so]\ngit = \"{url_o}\"\nbranch = \"main\"\n\n\
[sources.si]\ngit = \"{url_i}\"\nbranch = \"main\"\n\n\
[targets.s_a]\npath = \"{}\"\nsources = [\"so\"]\nlayout = \"flat\"\n\n\
[targets.s_b]\npath = \"{}\"\nsources = [\"si\"]\nlayout = \"flat\"\n",
base.join("shared").display(),
base.join("shared-other").display(),
);
let cfg = Config::parse(&toml).expect("prefix-sibling two-target config parses");
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("targets whose roots share a string prefix but no path-ancestor relation sync Ok");
assert!(
base.join("shared/od/f.txt").exists() && base.join("shared-other/id/g.txt").exists(),
"R4 must use path-component ancestor semantics (touches()), not naive string-prefix — \
`<base>/shared` and `<base>/shared-other` are siblings, not overlapping"
);
drop(so);
drop(si);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_multi_root_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("nvim/init")).unwrap();
std::fs::write(p.join("nvim/init/config.lua"), b"-- nvim\n").unwrap();
std::fs::create_dir_all(p.join("tmux/conf")).unwrap();
std::fs::write(p.join("tmux/conf/tmux.conf"), b"# tmux\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn fresh_backend_registry() -> (TempDir, TempDir, GitBackend, FileStateStore) {
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
(git_dir, state_dir, backend, registry)
}
#[test]
fn aliased_binding_records_underlying_source_at_identity_path() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\nroot = \"nvim\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ nvim = {{ source = \"dotfiles\" }} }}\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("aliased-binding config parses");
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("sync over an aliased binding must succeed");
let rec = registry
.artifact(&artifact_key("dest", "nvim", "init"))
.expect("registry get")
.expect("the record must be keyed by identity `nvim` at …/artifacts/nvim/init.toml");
assert_eq!(
rec.key.source, "nvim",
"key.source is the binding IDENTITY (the `as`), which keys the on-disk record path"
);
assert_eq!(
rec.source, "dotfiles",
"the new `source` field must carry the UNDERLYING source name `dotfiles`, not the identity"
);
drop(src);
}
#[test]
fn prefixed_custom_separator_persists_on_record_and_reconstructs_orphan_path() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\n\
layout = {{ type = \"prefixed\", separator = \"_\" }}\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("prefixed custom-separator config parses");
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("prefixed deploy must succeed");
let rec = fx
.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get")
.expect("the editor artifact must record under the prefixed layout");
assert_eq!(
rec.layout, "prefixed",
"the record must carry the canonical `prefixed` label; got {rec:?}"
);
assert_eq!(
rec.layout_separator.as_deref(),
Some("_"),
"a prefixed record must persist its custom `_` separator so orphan paths reconstruct \
exactly; got {rec:?}"
);
let deploy_root = rec
.deploy_root
.clone()
.expect("prefixed record persists deploy_root");
assert_eq!(
super::orphan_artifact_path(&rec),
Some(Path::new(&deploy_root).join("editor-src_editor")),
"the orphan path must join deploy_root with <source>_<artifact> using the persisted `_`, \
not a hardcoded dash"
);
}
#[test]
fn two_aliases_of_one_source_each_record_the_shared_underlying_source() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
one = {{ source = \"dotfiles\" }},\n\
two = {{ source = \"dotfiles\" }},\n\
}}\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-alias config parses");
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("two aliases of one source must deploy without collision");
let nvim = registry
.artifact(&artifact_key("dest", "one", "nvim"))
.expect("registry get")
.expect("the record keyed by identity `one` must exist at its own identity path");
let tmux = registry
.artifact(&artifact_key("dest", "two", "tmux"))
.expect("registry get")
.expect("the record keyed by identity `tmux` must exist at its own identity path");
assert_eq!(
nvim.source, "dotfiles",
"the nvim alias must record the shared underlying source `dotfiles`"
);
assert_eq!(
tmux.source, "dotfiles",
"the tmux alias must record the same underlying source `dotfiles`"
);
drop(src);
}
#[test]
fn bare_binding_records_source_equal_to_identity() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("bare-binding sync deploys");
let rec = fx
.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get")
.expect("bare binding must record at …/artifacts/editor-src/editor.toml");
assert_eq!(
rec.key.source, "editor-src",
"a bare binding keys by the source name (identity == source)"
);
assert_eq!(
rec.source, "editor-src",
"a bare binding's underlying `source` equals its identity"
);
}
#[test]
fn rebuild_round_trips_aliased_underlying_source() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\nroot = \"nvim\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ nvim = {{ source = \"dotfiles\" }} }}\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("aliased-binding config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("seeding sync over an aliased binding must succeed");
let key = artifact_key("dest", "nvim", "init");
registry
.remove_artifact(&key)
.expect("drop the aliased record");
assert!(
registry.artifact(&key).expect("get after remove").is_none(),
"premise: the record must be gone before rebuild"
);
rebuild_registry(&cfg, &out.base_lock, &backend, ®istry)
.expect("rebuild reconstructs the aliased record");
let rebuilt = registry
.artifact(&key)
.expect("registry get")
.expect("rebuild must reconstruct the record at the IDENTITY path …/artifacts/nvim/");
assert_eq!(
rebuilt.key.source, "nvim",
"rebuild must key by identity `nvim`, preserving the on-disk path"
);
assert_eq!(
rebuilt.source, "dotfiles",
"rebuild must reconstruct the UNDERLYING source `dotfiles` in the `source` field"
);
drop(src);
}
#[test]
fn rebuild_by_source_spares_managed_identity_dir_but_reports_a_stray() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\nroot = \"nvim\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ nvim = {{ source = \"dotfiles\" }} }}\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("by-source config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("seeding sync over a by-source binding must succeed");
let stray = td.target_path().join("stray");
std::fs::create_dir_all(&stray).expect("mkdir stray dir");
std::fs::write(stray.join("x.txt"), b"hand-made\n").expect("write stray file");
let report = rebuild_registry(&cfg, &out.base_lock, &backend, ®istry)
.expect("rebuild must not error");
let managed_identity = td.target_path().join("nvim");
assert!(
!report.foreign.iter().any(|p| p == &managed_identity),
"the by-source identity dir `{}` holds only managed children and must NOT be reported \
foreign — scan_foreign must compose destinations with the binding identity, not an empty \
identity; got {:?}",
managed_identity.display(),
report.foreign
);
assert!(
report.foreign.iter().any(|p| p.ends_with("stray")),
"a genuinely unmanaged top-level dir must still be reported foreign; got {:?}",
report.foreign
);
drop(src);
}
#[test]
fn flat_layout_collision_detected_between_two_aliases_sharing_a_destination() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dots]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
one = {{ source = \"dots\" }},\n\
two = {{ source = \"dots\" }},\n\
}}\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-alias flat config parses");
let Err(err) = sync(&input(&cfg, None, None, None, false), &backend, ®istry) else {
panic!("two aliases of one source into a flat target must collide on the destination");
};
assert_cross_binding_collision(&err.to_string(), "nvim");
drop(src);
}
fn assert_cross_binding_collision(rendered: &str, shared_key: &str) {
use crate::diagnostic::{MATCHED_AGAINST, REMEDY, SELECTION};
for phrase in [SELECTION, MATCHED_AGAINST, REMEDY] {
assert!(
rendered.contains(phrase),
"the cross-binding dup-dest rejection must render `{phrase}`; got:\n{rendered}"
);
}
assert!(
rendered.contains(shared_key),
"the rejection must name the shared destination key `{shared_key}`; got:\n{rendered}"
);
assert!(
rendered.contains("same destination"),
"the rejection must state the two bindings resolve to the same destination; got:\n{rendered}"
);
}
#[test]
fn same_identity_bindings_sharing_a_destination_still_collide() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[sources.dots]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
a = {{ source = \"dots\" }},\n\
b = {{ source = \"dots\" }},\n\
}}\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two bare same-source bindings parse");
let Err(err) = sync(&input(&cfg, None, None, None, false), &backend, ®istry) else {
panic!(
"two bindings of one source sharing a default identity and projecting `nvim` into a \
flat target must collide on the destination, not silently overwrite"
);
};
assert_cross_binding_collision(&err.to_string(), "nvim");
drop(src);
}
fn preplace_foreign(dst: &Path, marker: &[u8]) {
std::fs::create_dir_all(dst).expect("mkdir foreign dst");
std::fs::write(dst.join("local-only.txt"), marker).expect("write foreign marker");
}
#[test]
fn sync_without_force_leaves_foreign_content_untouched() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
preplace_foreign(&dst, b"hand-written, not phora-managed\n");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&fx.head_sha,
);
assert!(
matches!(st, ArtifactState::Foreign),
"premise: pre-placed unmanaged content must read as Foreign, got {st:?}"
);
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Foreign artifact without --force");
assert!(
!out.had_failures,
"skipping a Foreign artifact is not a failure"
);
assert_eq!(
std::fs::read(dst.join("local-only.txt")).expect("foreign marker still present"),
b"hand-written, not phora-managed\n",
"without --force a Foreign artifact must be skipped, leaving the local content intact"
);
assert!(
!dst.join("init.lua").exists(),
"without --force the upstream editor/init.lua must NOT overwrite Foreign content"
);
}
#[test]
fn sync_with_force_overwrites_foreign_content_with_upstream() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
preplace_foreign(&dst, b"hand-written, not phora-managed\n");
let out = sync(
&input(&cfg, None, None, None, true),
&fx.backend,
&fx.registry,
)
.expect("forced sync deploys over Foreign content");
assert!(!out.had_failures, "forced deploy must succeed");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("upstream init.lua deployed"),
b"-- init\n",
"--force must overwrite Foreign content with the upstream artifact"
);
assert!(
!dst.join("local-only.txt").exists(),
"--force replaces the whole artifact dir; the foreign-only file must be gone"
);
}
#[test]
fn sync_without_force_skips_modified_registry_artifact() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get must not error")
.is_some(),
"premise: the first sync must create a registry record so the artifact is MANAGED"
);
let edited = b"-- locally edited, do not clobber\n";
std::fs::write(dst.join("init.lua"), edited).expect("edit deployed file");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: an edited managed artifact must read as Modified, got {st:?}"
);
let out = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Modified artifact without --force");
assert!(
!out.had_failures,
"skipping a Modified artifact is not a failure"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("edited file still present"),
edited,
"without --force a Modified artifact must be skipped, preserving the local edit"
);
}
#[test]
fn sync_with_force_overwrites_modified_registry_artifact() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get must not error")
.is_some(),
"premise: the first sync must create a registry record so the artifact is MANAGED"
);
let edited = b"-- locally edited, force should clobber\n";
std::fs::write(dst.join("init.lua"), edited).expect("edit deployed file");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: an edited managed artifact must read as Modified, got {st:?}"
);
let out = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, true),
&fx.backend,
&fx.registry,
)
.expect("forced sync redeploys over a Modified artifact");
assert!(!out.had_failures, "forced redeploy must succeed");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("upstream init.lua redeployed"),
b"-- init\n",
"--force must replace the local edit with the upstream artifact content"
);
}
fn config_one_source_one_target_link(
source: &str,
url: &str,
target: &str,
target_path: &Path,
layout: &str,
) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{url}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.{target}]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n",
target_path.display(),
);
Config::parse(&toml).expect("one-source one-target link config parses")
}
fn is_symlink(path: &Path) -> bool {
std::fs::symlink_metadata(path).is_ok_and(|m| m.file_type().is_symlink())
}
#[test]
fn ejected_copy_to_link_mode_transition_is_a_silent_skip_never_redeploys() {
let (src, url) = build_named_artifact_repo("editor", "init.lua", b"-- init\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let cfg =
config_one_source_one_target_link("editor-src", &url, "dest", &td.target_path(), "flat");
let dst = seed_managed_artifact(
&td,
®istry,
"editor-src",
"editor",
"init.lua",
b"-- ejected, do not touch\n",
);
assert!(
!is_symlink(&dst) && dst.is_dir(),
"premise: the ejected artifact is a real copy directory on disk"
);
eject(&cfg, ®istry, "editor", "editor-src", "dest", &backend)
.expect("eject the managed artifact");
let key = artifact_key("dest", "editor-src", "editor");
let ejected = registry.ejections("dest").expect("load ejected");
assert!(
ejected
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"premise: (editor-src, editor) must be ejected before the sync"
);
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("a sync whose ejected cell carries a mode transition must not error");
assert!(!out.had_failures, "a silent ejected skip is not a failure");
assert!(
!is_symlink(&dst) && dst.is_dir(),
"R7: the mode transition must NOT redeploy over ejected content as a symlink"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("ejected file still present"),
b"-- ejected, do not touch\n",
"R7: ejected content must be left byte-for-byte untouched"
);
assert!(
registry
.ejections("dest")
.expect("reload ejected")
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"R7: ejection stays authoritative — the entry must survive the sync"
);
assert!(
registry.artifact(&key).expect("registry get").is_some(),
"R7: the ejected record must be kept, not dropped"
);
drop(src);
}
#[test]
fn frozen_lockless_ejected_mode_transition_is_write_free() {
let (src, url) = build_named_artifact_repo("editor", "init.lua", b"-- init\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let td = TargetDir::new();
let cfg =
config_one_source_one_target_link("editor-src", &url, "dest", &td.target_path(), "flat");
let dst = seed_managed_artifact(
&td,
®istry,
"editor-src",
"editor",
"init.lua",
b"-- ejected, do not touch\n",
);
eject(&cfg, ®istry, "editor", "editor-src", "dest", &backend)
.expect("eject the managed artifact");
let out = sync(
&frozen_lockless_input(&cfg, None, false),
&backend,
®istry,
)
.expect(
"a frozen+lockless sync whose only pending cell is Ejected+mode_transition must be \
write-free, not refuse with a read-only error",
);
assert!(
!out.had_failures,
"a write-free frozen sync is not a failure"
);
assert!(
!is_symlink(&dst) && dst.is_dir(),
"the frozen run must not redeploy the ejected dst as a symlink"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("ejected file still present"),
b"-- ejected, do not touch\n",
"the frozen run must leave the ejected content untouched"
);
drop(src);
}
fn read_mtime_secs(path: &Path) -> u64 {
std::fs::metadata(path)
.expect("metadata")
.modified()
.expect("modified time")
.duration_since(std::time::UNIX_EPOCH)
.expect("after epoch")
.as_secs()
}
fn touch_to_mtime(path: &Path, secs: u64) {
filetime::set_file_mtime(
path,
filetime::FileTime::from_unix_time(secs.cast_signed(), 0),
)
.expect("set mtime");
}
fn manifest_file<'a>(rec: &'a ArtifactRecord, rel: &str) -> &'a ManifestFile {
rec.files
.iter()
.find(|f| f.path == *Path::new(rel))
.unwrap_or_else(|| panic!("record must list {rel}, got {:?}", rec.files))
}
fn assert_record_level_fields_unchanged(before: &ArtifactRecord, after: &ArtifactRecord) {
assert_eq!(
after.commit, before.commit,
"a stat refresh must leave the record-level commit untouched"
);
assert_eq!(
after.digest, before.digest,
"a stat refresh must leave the record-level digest untouched"
);
assert_eq!(
after.vars_digest, before.vars_digest,
"a stat refresh must leave vars_digest untouched"
);
assert_eq!(
after.linked, before.linked,
"a stat refresh must leave the linked flag untouched"
);
assert_eq!(
after.kind, before.kind,
"a stat refresh must leave the record kind untouched"
);
assert_eq!(
after
.files
.iter()
.find(|f| f.path == *Path::new("notes.bak")),
before
.files
.iter()
.find(|f| f.path == *Path::new("notes.bak")),
"an untouched sibling file's record entry must be unchanged by the single-file refresh"
);
}
#[test]
fn sync_refreshes_record_stat_for_touched_but_identical_file() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let before = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after first sync");
let recorded = manifest_file(&before, "init.lua").clone();
let touched_mtime = recorded.mtime + 1000;
let file_on_disk = dst.join("init.lua");
touch_to_mtime(&file_on_disk, touched_mtime);
assert_eq!(
read_mtime_secs(&file_on_disk),
touched_mtime,
"premise: the on-disk mtime must actually move so the file stat-diverges"
);
assert_eq!(
std::fs::read(&file_on_disk)
.expect("read deployed file")
.len() as u64,
recorded.size,
"premise: only mtime moved — the byte length must be unchanged"
);
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("second sync over a touched-but-identical artifact must not error");
assert!(
!second.had_failures,
"a Revalidated artifact is clean-like and must not be a failure"
);
let after = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after second sync");
let refreshed = manifest_file(&after, "init.lua");
assert_eq!(
refreshed.mtime, touched_mtime,
"the sync write-path must persist the revalidated file's NEW mtime so it returns to the \
fast path — pre-DGI-003 the record keeps the stale mtime"
);
assert_eq!(
refreshed.size, recorded.size,
"a byte-identical revalidation must carry size through unchanged"
);
assert_eq!(
refreshed.blake3, recorded.blake3,
"the refresh must rewrite ONLY size+mtime — blake3 must never be touched"
);
assert_record_level_fields_unchanged(&before, &after);
let mut expected = before.clone();
let expected_init = expected
.files
.iter_mut()
.find(|f| f.path == *Path::new("init.lua"))
.expect("cloned record must list init.lua");
expected_init.size = recorded.size;
expected_init.mtime = touched_mtime;
assert_eq!(
after, expected,
"a stat refresh must change NOTHING except init.lua's size+mtime — every record-level \
field (projected_at, key, source, layout, allow_symlinks, preserve_executable) and \
every other file entry must be byte-for-byte identical to the pre-sync record"
);
}
#[test]
fn second_sync_after_revalidation_hits_fast_path_without_reexport() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let counting = CountingBackend::new(&fx.backend);
let first = sync(
&input(&cfg, None, None, None, false),
&counting,
&fx.registry,
)
.expect("first sync deploys the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let recorded = manifest_file(
&fx.registry
.artifact(&key)
.expect("get")
.expect("record after first sync"),
"init.lua",
)
.clone();
let touched_mtime = recorded.mtime + 1000;
touch_to_mtime(&dst.join("init.lua"), touched_mtime);
let reval = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&counting,
&fx.registry,
)
.expect("revalidating sync must not error");
assert!(
!reval.had_failures,
"a revalidated artifact is not a failure"
);
let state = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(state, ArtifactState::Clean),
"once the write-path persists the revalidated stat the record matches disk, so the \
artifact must read Clean (fast path, no re-hash) — pre-DGI-003 the stale record \
re-escalates to Revalidated, got {state:?}"
);
let refreshed_record = fx
.registry
.artifact(&key)
.expect("get")
.expect("record after revalidating sync");
counting.reset_read_probe();
let third = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&counting,
&fx.registry,
)
.expect("third sync over an untouched refreshed artifact must not error");
assert!(
!third.had_failures,
"an untouched refreshed artifact must be a no-op, not a failure"
);
assert_eq!(
counting.read_count(),
0,
"the fast-path sync must NOT re-stage a Clean (refreshed) artifact: each immutable source \
leaf may be read once for digesting, but none may be read again for staging"
);
assert_eq!(
fx.registry
.artifact(&key)
.expect("get")
.expect("record after third sync"),
refreshed_record,
"a no-op fast-path sync must not rewrite the record"
);
}
#[test]
fn genuine_content_change_reads_modified_and_persists_no_refresh() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let before = fx
.registry
.artifact(&key)
.expect("get")
.expect("record after first sync");
std::fs::write(
dst.join("init.lua"),
b"-- genuinely edited, real content change\n",
)
.expect("rewrite the deployed file with different bytes");
let state = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(state, ArtifactState::Modified { .. }),
"a real content change must read Modified, got {state:?}"
);
let out = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Modified artifact without --force");
assert!(
!out.had_failures,
"skipping a Modified artifact without --force is not a failure"
);
let after = fx
.registry
.artifact(&key)
.expect("get")
.expect("record after skip");
assert_eq!(
after, before,
"a Modified artifact must never persist a stat refresh — the record must be byte-identical"
);
}
#[test]
fn read_only_target_detail_never_refreshes_the_record() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let before = fx
.registry
.artifact(&key)
.expect("get")
.expect("record after first sync");
let recorded = manifest_file(&before, "init.lua").clone();
touch_to_mtime(&dst.join("init.lua"), recorded.mtime + 1000);
let _detail = crate::cli::target_detail(&cfg, &fx.registry, &fx.backend, "dest")
.expect("read-only target detail must not error");
let after = fx
.registry
.artifact(&key)
.expect("get")
.expect("record after the read-only query");
assert_eq!(
after, before,
"the read-only query path must never persist a refresh on a stat-stale-identical file — \
the record must be byte-for-byte unchanged"
);
}
#[test]
fn phora_verify_report_unchanged_by_stat_refresh() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let verify_before = super::verify::verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify before must not error");
assert!(
verify_before.is_clean(),
"a freshly deployed artifact must verify clean, got {verify_before:?}"
);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let recorded = manifest_file(
&fx.registry.artifact(&key).expect("get").expect("record"),
"init.lua",
)
.clone();
touch_to_mtime(&dst.join("init.lua"), recorded.mtime + 1000);
sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("revalidating sync must not error");
let verify_after = super::verify::verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify after must not error");
assert_eq!(
verify_after, verify_before,
"a stat-only refresh must not change phora verify's report — blake3 stays untouched"
);
assert!(
verify_after.is_clean(),
"verify must still pass after a stat refresh, got {verify_after:?}"
);
}
#[test]
fn sync_refreshes_every_touched_identical_file_in_a_multi_file_artifact() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let before = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after first sync");
let init_before = manifest_file(&before, "init.lua").clone();
let notes_before = manifest_file(&before, "notes.bak").clone();
let init_new_mtime = init_before.mtime + 1000;
let notes_new_mtime = notes_before.mtime + 2000;
assert_ne!(
init_new_mtime, notes_new_mtime,
"premise: the two files must move to DISTINCT mtimes so a swap would be detectable"
);
touch_to_mtime(&dst.join("init.lua"), init_new_mtime);
touch_to_mtime(&dst.join("notes.bak"), notes_new_mtime);
assert_eq!(
read_mtime_secs(&dst.join("init.lua")),
init_new_mtime,
"premise: init.lua mtime must actually move"
);
assert_eq!(
read_mtime_secs(&dst.join("notes.bak")),
notes_new_mtime,
"premise: notes.bak mtime must actually move"
);
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("second sync over two touched-but-identical files must not error");
assert!(
!second.had_failures,
"both files hash-match, so the artifact is Revalidated (clean-like), not a failure"
);
let after = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after second sync");
let init_after = manifest_file(&after, "init.lua");
let notes_after = manifest_file(&after, "notes.bak");
assert_eq!(
init_after.mtime, init_new_mtime,
"the write-path must refresh init.lua to ITS new on-disk mtime — pre-DGI-003 it keeps the \
stale mtime"
);
assert_eq!(
notes_after.mtime, notes_new_mtime,
"the write-path must refresh notes.bak to ITS new on-disk mtime — every touched-identical \
file in the overlay must be persisted, not just the first"
);
assert_eq!(
init_after.size, init_before.size,
"init.lua size must carry through unchanged"
);
assert_eq!(
notes_after.size, notes_before.size,
"notes.bak size must carry through unchanged"
);
assert_eq!(
init_after.blake3, init_before.blake3,
"init.lua blake3 must never be touched by a stat refresh"
);
assert_eq!(
notes_after.blake3, notes_before.blake3,
"notes.bak blake3 must never be touched by a stat refresh"
);
let mut expected = before.clone();
for f in &mut expected.files {
if f.path == *Path::new("init.lua") {
f.mtime = init_new_mtime;
} else if f.path == *Path::new("notes.bak") {
f.mtime = notes_new_mtime;
}
}
assert_eq!(
after, expected,
"each file must be matched to its OWN fresh stat by path (no swap), and nothing else in \
the record may change"
);
}
#[test]
fn sync_modified_artifact_persists_no_refresh_for_touched_identical_sibling() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let key = artifact_key("dest", "editor-src", "editor");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let before = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after first sync");
let init_before = manifest_file(&before, "init.lua").clone();
let notes_before = manifest_file(&before, "notes.bak").clone();
let edited = b"-- edit\n";
assert_eq!(
edited.len() as u64,
init_before.size,
"premise: the edit must keep init.lua's byte-length so only blake3 (not size) trips"
);
std::fs::write(dst.join("init.lua"), edited).expect("genuinely edit init.lua");
filetime::set_file_mtime(
dst.join("init.lua"),
filetime::FileTime::from_unix_time((init_before.mtime + 1000).cast_signed(), 0),
)
.expect("bump edited file mtime");
let notes_new_mtime = notes_before.mtime + 2000;
touch_to_mtime(&dst.join("notes.bak"), notes_new_mtime);
assert_eq!(
read_mtime_secs(&dst.join("notes.bak")),
notes_new_mtime,
"premise: the sibling notes.bak mtime must actually move, bytes untouched"
);
let state = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(state, ArtifactState::Modified { .. }),
"one genuinely edited file (hash-miss) makes the whole artifact Modified, got {state:?}"
);
let out = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Modified artifact without --force");
assert!(
!out.had_failures,
"skipping a Modified artifact without --force is not a failure"
);
let after = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("record after the skip");
assert_eq!(
after, before,
"a Modified artifact must NEVER half-persist: the touched-identical notes.bak sibling must \
keep its stale stat — the write-path refresh fires only on Revalidated, never on Modified"
);
}
fn assert_linked_artifact_state(dst: &Path, registry: &FileStateStore) {
let state = check_artifact_state(
dst,
"editor-src",
"link",
&[],
"editor",
registry,
&artifact_key("dest", "editor-src", "editor"),
None,
)
.expect("check_artifact_state on the linked dst");
assert!(
matches!(state, ArtifactState::Linked),
"premise: a deployed symlink with a linked record must read Linked, got {state:?}"
);
}
#[test]
fn second_deploy_over_correct_link_is_a_noop() {
use std::os::unix::fs::symlink;
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_link_source_one_target_with_layout(
"editor-src",
fx.src.path(),
&td.target_path(),
"flat",
);
let target = cfg.targets.get("dest").expect("dest target present");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
std::fs::create_dir_all(dst.parent().expect("dst parent")).expect("mkdir dst parent");
symlink(fx.src.path().join("editor"), &dst).expect("deploy artifact as a symlink");
fx.registry
.put_artifact(&linked_flat_record("dest", "editor-src", "editor"))
.expect("seed linked registry record");
let counting = CountingBackend::new(&fx.backend);
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let commits = one_commit(&parsed, "editor-src", "link");
let resolved_sources = resolved_worktree_map(&counting, "editor-src", fx.src.path());
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&counting,
&commits,
&resolved_sources,
)
.expect("projection builds from the live link inventory");
let target_projection = projection
.targets
.iter()
.find(|projected| projected.target == "dest")
.expect("projection contains dest");
let protected = test_protected(fx.src.path());
assert_linked_artifact_state(&dst, &fx.registry);
let si = input(&cfg, None, None, None, false);
let ctx = DeployAll {
config: &cfg,
parsed: &parsed,
remotes: &remotes,
resolved_sources: &resolved_sources,
projection: &projection,
protected: &protected,
content_store: None,
input: &si,
backend: &counting,
registry: &fx.registry,
journal: &journal,
};
let observed = super::observe::observe_workspace(&ctx, &projection)
.expect("live observation pass succeeds");
let changeset = reconcile::reconcile(
&projection,
&observed,
&ReconciliationPolicy {
force: false,
prune: false,
follow_moved_pin: false,
},
)
.expect("live reconcile pass succeeds");
let reconciliation = Reconciliation::new(&changeset, &observed, &[], BTreeMap::new());
let run = TargetRun {
parsed: &parsed,
target_name: "dest",
target,
remotes: &remotes,
resolved_sources: &resolved_sources,
vars: &BTreeMap::new(),
protected: &protected,
content_store: None,
};
let had_failures = deploy_reconciled_target(
run,
target_projection,
&reconciliation,
&counting,
&fx.registry,
&journal,
)
.expect("deploy pass over a linked artifact must not error");
assert!(!had_failures, "a no-op linked pass is not a failure");
assert_eq!(
counting.read_count(),
0,
"a correct linked artifact must NOT be re-exported on a second sync (H1 re-deploy)"
);
assert!(
std::fs::symlink_metadata(&dst)
.expect("dst still present")
.file_type()
.is_symlink(),
"the deployed symlink must be left intact — a re-deploy would replace it with a copy"
);
}
fn first_commit(out: &SyncOutput) -> String {
out.base_lock
.find_source("editor-src")
.expect("editor-src present in base lock after sync")
.commit
.clone()
}
fn check_state_at(
dst: &Path,
reg: &FileStateStore,
target: &str,
source: &str,
artifact: &str,
commit: &str,
) -> ArtifactState {
crate::sync::inspect::check_artifact_state(
dst,
source,
commit,
&[],
artifact,
reg,
&artifact_key(target, source, artifact),
None,
)
.expect("check_artifact_state")
}
#[test]
fn sync_warns_and_continues_when_one_artifact_export_fails() {
let (src, url) = {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/init.lua"), b"-- init\n").expect("write editor");
std::fs::create_dir_all(p.join("lint")).expect("mkdir lint");
std::fs::write(p.join("lint/rules.toml"), b"[rules]\n").expect("write lint");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
};
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let inner = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = FailingReadBackend::new(&inner, "lint");
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &url, "dest", &td.target_path(), "by-source");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &backend, ®istry)
.expect("a per-artifact export failure must NOT abort the whole run");
assert!(
out.had_failures,
"a failed per-artifact deploy must set had_failures=true"
);
let editor_dst = td.target_path().join("multi").join("editor");
assert_eq!(
std::fs::read(editor_dst.join("init.lua")).expect("good artifact deployed"),
b"-- init\n",
"the artifact whose export succeeded must still be deployed despite the sibling failure"
);
assert!(
registry
.artifact(&artifact_key("dest", "multi", "editor"))
.expect("get good record")
.is_some(),
"the successfully deployed artifact must have a registry record"
);
assert!(
registry
.artifact(&artifact_key("dest", "multi", "lint"))
.expect("get failed record")
.is_none(),
"the failed artifact must NOT leave a registry record"
);
drop(src);
}
fn seed_orphan(
td: &TargetDir,
reg: &FileStateStore,
layout: &crate::config::LayoutConfig,
) -> PathBuf {
let dst = td.artifact_dst(layout, "gone-src", "obsolete");
std::fs::create_dir_all(&dst).expect("mkdir orphan dst");
std::fs::write(dst.join("old.txt"), b"stale\n").expect("write orphan file");
let record = ArtifactRecord {
version: 1,
key: artifact_key("dest", "gone-src", "obsolete"),
source: "gone-src".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:orphan".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("old.txt"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 6,
mtime: 1_700_000_000,
blake3: "blake3:orphan".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
reg.put_artifact(&record).expect("seed orphan record");
dst
}
fn frozen_lockless_input(base: &Config, base_lock: Option<Lock>, prune: bool) -> SyncInput<'_> {
SyncInput {
base_config: base,
local_config: None,
base_lock,
local_lock: None,
force: false,
interactive: false,
prune,
no_hooks: false,
no_transitive_hooks: false,
frozen: true,
lockless: true,
fast_forward: false,
resolver: None,
jobs: None,
}
}
#[test]
fn frozen_lockless_prune_with_a_pending_orphan_refuses_before_deleting_files() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("initial writable sync deploys editor cleanly");
assert!(!first.had_failures, "premise: the initial deploy is clean");
let orphan_dst = seed_orphan(&td, &fx.registry, &flat_layout());
assert!(
orphan_dst.exists(),
"premise: the orphan's files are on disk before the frozen run"
);
let result = sync(
&frozen_lockless_input(&cfg, Some(first.base_lock.clone()), true),
&fx.backend,
&fx.registry,
);
let Err(err) = result else {
panic!("a frozen lockless --prune with a pending orphan must fail early, not delete");
};
let msg = err.to_string();
assert!(
msg.contains(&fx.registry.state_root().display().to_string())
&& msg.to_lowercase().contains("read-only"),
"the refusal must name the read-only state root, got: {msg}"
);
assert!(
orphan_dst.exists(),
"zero mutation: the orphan's files must survive a refused frozen prune"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "gone-src", "obsolete"))
.expect("get orphan record")
.is_some(),
"the orphan's registry record must remain — nothing was pruned"
);
}
#[test]
fn frozen_lockless_fast_forward_with_pending_drops_refuses_before_pruning() {
let fx = build_sync_fixture();
let cwd = TempDir::new().expect("cwd tempdir");
let protected = test_protected(cwd.path());
let cfg = Config::parse("version = 1\n").expect("empty config parses");
let drops = vec![ArtifactRecord {
version: 1,
key: artifact_key("dest", "gone-src", "obsolete"),
source: "gone-src".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:drop".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
}];
let projection = Projection {
targets: Vec::new(),
warnings: Vec::new(),
};
let mut events = SyncEvents::discarding();
let err = prune_fast_forward_drops_report(
&projection,
&cfg,
&fx.registry,
&protected,
&drops,
true,
&mut events,
)
.expect_err("a read-only fast-forward carrying pending drops must refuse before any delete");
let msg = err.to_string();
assert!(
msg.contains(&fx.registry.state_root().display().to_string())
&& msg.to_lowercase().contains("read-only"),
"the refusal must name the read-only state root, got: {msg}"
);
}
#[test]
fn frozen_lockless_sync_refuses_a_would_fire_on_change_hook_before_spawning_it() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let plain =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&plain, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("initial writable sync deploys editor without any hook");
assert!(
!first.had_failures,
"premise: clean deploy, no hook recorded"
);
let hooked = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!("\"{}\"", append_cmd(&log, "fired").replace('"', "\\\"")),
);
let result = sync(
&frozen_lockless_input(&hooked, Some(first.base_lock.clone()), false),
&fx.backend,
&fx.registry,
);
let Err(err) = result else {
panic!("a frozen lockless sync must refuse a would-fire on_change hook, not spawn it");
};
let msg = err.to_string();
assert!(
msg.contains(&fx.registry.state_root().display().to_string())
&& msg.to_lowercase().contains("read-only"),
"the refusal must name the read-only state root, got: {msg}"
);
assert!(
log_lines(&log).is_empty(),
"zero side effects: the on_change hook must NOT run before the write is refused"
);
}
#[test]
fn sync_with_prune_removes_orphan_files_and_record_but_keeps_current() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let orphan_dst = seed_orphan(&td, &fx.registry, &flat_layout());
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
let out = sync(&in_, &fx.backend, &fx.registry).expect("prune sync runs");
assert!(!out.had_failures, "prune run must succeed");
assert!(
!orphan_dst.exists(),
"--prune must remove the orphan's files from disk"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "gone-src", "obsolete"))
.expect("get orphan record")
.is_none(),
"--prune must remove the orphan's registry record"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("get current record")
.is_some(),
"a still-current artifact must NOT be pruned"
);
let current_dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
current_dst.join("init.lua").exists(),
"the current artifact's deployed files must survive prune"
);
}
#[test]
fn sync_skips_prune_when_a_deploy_failed() {
let (src, url) = {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/init.lua"), b"-- init\n").expect("write editor");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
};
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let inner = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = FailingReadBackend::new(&inner, "editor");
let td = TargetDir::new();
let cfg = config_one_source_one_target("only", &url, "dest", &td.target_path(), "flat");
let orphan_dst = seed_orphan(&td, ®istry, &flat_layout());
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
let out = sync(&in_, &backend, ®istry).expect("sync runs despite the export failure");
assert!(
out.had_failures,
"premise: the only artifact's export failed, so had_failures must be true"
);
assert!(
orphan_dst.exists(),
"--prune must be SKIPPED when had_failures: the orphan's files must remain on disk"
);
assert!(
registry
.artifact(&artifact_key("dest", "gone-src", "obsolete"))
.expect("get orphan record")
.is_some(),
"--prune must be SKIPPED on failure: the orphan's registry record must remain"
);
drop(src);
}
fn seed_orphan_record(reg: &FileStateStore, source: &str, artifact: &str) {
let record = ArtifactRecord {
version: 1,
key: artifact_key("dest", source, artifact),
source: source.to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:orphan".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("init.lua"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 6,
mtime: 1_700_000_000,
blake3: "blake3:orphan".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
reg.put_artifact(&record)
.expect("seed overlapping orphan record");
}
#[test]
fn prune_keeps_record_when_orphan_path_overlaps_a_live_dest() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
seed_orphan_record(&fx.registry, "gone-src", "editor");
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
let out = sync(&in_, &fx.backend, &fx.registry).expect("prune sync runs");
assert!(!out.had_failures, "prune run must succeed");
let live_dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
live_dst.join("init.lua").exists(),
"the live destination overlapping the orphan must NOT be deleted by prune"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "gone-src", "editor"))
.expect("get overlapping orphan record")
.is_some(),
"when prune skips the physical delete because the orphan overlaps a live dest, the file \
stays on disk and its record MUST be kept so the file remains tracked"
);
}
#[test]
fn prune_drops_record_when_orphan_path_is_already_absent() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
seed_orphan_record(&fx.registry, "gone-src", "obsolete");
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
let out = sync(&in_, &fx.backend, &fx.registry).expect("prune sync runs");
assert!(!out.had_failures, "prune run must succeed");
assert!(
fx.registry
.artifact(&artifact_key("dest", "gone-src", "obsolete"))
.expect("get absent-path orphan record")
.is_none(),
"an orphan whose path is already absent has nothing to keep tracked, so its record MUST \
be removed even though prune skipped the physical delete"
);
}
#[test]
fn prune_deletes_file_and_drops_record_for_a_normal_orphan() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let orphan_dst = seed_orphan(&td, &fx.registry, &flat_layout());
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
let out = sync(&in_, &fx.backend, &fx.registry).expect("prune sync runs");
assert!(!out.had_failures, "prune run must succeed");
assert!(
!orphan_dst.exists(),
"a non-overlapping orphan's files must be deleted by prune"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "gone-src", "obsolete"))
.expect("get normal orphan record")
.is_none(),
"a non-overlapping orphan's record must be removed once its files are deleted"
);
}
#[test]
fn sync_errors_on_target_referencing_undefined_source() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\", \"ghost\"]\nlayout = \"flat\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("config naming an undefined source still parses");
let in_ = input(&cfg, None, None, None, false);
let result = sync(&in_, &fx.backend, &fx.registry);
let Err(err) = result else {
panic!(
"a target referencing an undefined source `ghost` must return Err, not Ok \
(and must not panic while indexing the source map)"
);
};
assert!(
err.to_string().contains("ghost"),
"the error must name the undefined source `ghost`, got: {err}"
);
}
#[test]
fn sync_cleans_staging_when_export_fails() {
let (src, url) = build_named_artifact_repo("editor", "init.lua", b"-- init\n");
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let inner = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = FailingReadBackend::new(&inner, "editor");
let td = TargetDir::new();
let cfg = config_one_source_one_target("only", &url, "dest", &td.target_path(), "flat");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &backend, ®istry)
.expect("a per-artifact export failure must NOT abort the whole run");
assert!(
out.had_failures,
"premise: the only artifact's export failed, so had_failures must be true"
);
assert!(
!td.has_phora_leftover(),
"a failed export must clean its partial .phora-stage; \
no staging cruft may remain in the target parent {}",
td.parent_path.display()
);
drop(src);
}
struct ScriptedResolver {
verdict: Resolution,
consulted: AtomicUsize,
seen: Mutex<Vec<Conflict>>,
}
impl ScriptedResolver {
fn new(verdict: Resolution) -> Self {
Self {
verdict,
consulted: AtomicUsize::new(0),
seen: Mutex::new(Vec::new()),
}
}
fn consulted(&self) -> usize {
self.consulted.load(AtomicOrdering::SeqCst)
}
fn last_conflict(&self) -> Conflict {
self.seen
.lock()
.expect("seen mutex")
.last()
.cloned()
.expect("resolver was consulted on at least one conflict")
}
}
impl ConflictResolver for ScriptedResolver {
fn resolve(&self, conflict: &Conflict) -> Resolution {
self.consulted.fetch_add(1, AtomicOrdering::SeqCst);
self.seen.lock().expect("seen mutex").push(conflict.clone());
self.verdict
}
}
fn interactive_input<'a>(
cfg: &'a Config,
base_lock: Option<Lock>,
resolver: &'a dyn ConflictResolver,
) -> SyncInput<'a> {
SyncInput {
base_config: cfg,
local_config: None,
base_lock,
local_lock: None,
force: false,
interactive: true,
prune: false,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: Some(resolver),
jobs: None,
}
}
fn deploy_then_modify(fx: &SyncFixture, td: &TargetDir, cfg: &Config) -> Lock {
let first = sync(
&input(cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!first.had_failures, "premise: first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
std::fs::write(dst.join("init.lua"), b"-- locally edited\n").expect("edit deployed file");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: edited managed artifact must read Modified, got {st:?}"
);
first.base_lock
}
#[test]
fn frozen_lockless_conflict_refuses_before_consulting_the_resolver() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let base_lock = deploy_then_modify(&fx, &td, &cfg);
let resolver = ScriptedResolver::new(Resolution::Abort);
let mut request = interactive_input(&cfg, Some(base_lock), &resolver);
request.frozen = true;
request.lockless = true;
let result = sync(&request, &fx.backend, &fx.registry);
let Err(error) = result else {
panic!("pending work against frozen read-only state must be refused");
};
let rendered = error.to_string();
assert!(
rendered.to_lowercase().contains("read-only")
&& rendered.contains(&fx.registry.state_root().display().to_string()),
"readonly refusal must win over an interactive answer for a run that cannot write; got: \
{rendered}"
);
assert_eq!(
resolver.consulted(),
0,
"a frozen lockless run with pending conflict work must refuse before prompting: the \
caller cannot make an impossible read-only run writable"
);
}
#[test]
fn conflict_abort_preflight_runs_before_pre_deploy_hooks() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let plain =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let base_lock = deploy_then_modify(&fx, &td, &plain);
let log = td.parent_path.join("pre-deploy.log");
let hook = append_cmd(&log, "ran").replace('"', "\\\"");
let hooked = Config::parse(&format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\npre_deploy = \"{hook}\"\n",
fx.url,
td.target_path().display(),
))
.expect("pre_deploy fixture config parses");
let resolver = ScriptedResolver::new(Resolution::Abort);
let result = sync(
&interactive_input(&hooked, Some(base_lock), &resolver),
&fx.backend,
&fx.registry,
);
let Err(error) = result else {
panic!("the whole ChangeSet Abort must surface before the per-target hook phase");
};
assert!(
matches!(error, Error::Aborted),
"the whole ChangeSet Abort must surface before the per-target hook phase; got {error:?}"
);
assert_eq!(
resolver.consulted(),
1,
"the complete conflict preflight must consult the supplied resolver"
);
assert!(
log_lines(&log).is_empty(),
"resolve-before-hooks preserves whole-run Abort atomicity: pre_deploy must not run"
);
}
#[test]
fn successful_pre_deploy_creation_rechecks_missing_and_preserves_local_content_without_force() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let local_file = dst.join("hook-created.txt");
let hook = format!(
"mkdir -p '{}' && printf '%s' 'created by pre-deploy' > '{}'",
dst.display(),
local_file.display(),
)
.replace('"', "\\\"");
let cfg = Config::parse(&format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\npre_deploy = \"{hook}\"\n",
fx.url,
td.target_path().display(),
))
.expect("hook-created Missing fixture config parses");
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("an unforced hook-created Foreign artifact must retain skip semantics");
assert!(
!out.had_failures,
"skipping content created by a successful pre_deploy hook is not a failure"
);
assert_eq!(
std::fs::read(&local_file).ok(),
Some(b"created by pre-deploy".to_vec()),
"the destination was Missing when first observed, but content created by pre_deploy must \
be reclassified as Foreign and preserved without --force"
);
assert!(
!dst.join("init.lua").exists(),
"no upstream file may be deployed after pre_deploy turns Missing into Foreign"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry lookup after hook-created skip")
.is_none(),
"a skipped hook-created Foreign artifact must not gain a managed registry record"
);
}
#[test]
fn successful_pre_deploy_edit_rechecks_outdated_and_preserves_local_content_without_force() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let plain =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&plain, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the original commit");
assert!(!first.had_failures, "premise: first deploy must succeed");
let key = artifact_key("dest", "editor-src", "editor");
let record_before = fx
.registry
.artifact(&key)
.expect("registry lookup before source advance")
.expect("first sync records the managed artifact");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let new_head = fx.advance_head();
let before_hook = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&new_head,
);
assert!(
matches!(before_hook, ArtifactState::Outdated),
"premise: an unchanged managed destination at the advanced commit must be Outdated, got \
{before_hook:?}"
);
let hook = format!(
"printf '%s' 'edited by pre-deploy' > '{}'",
dst.join("init.lua").display(),
)
.replace('"', "\\\"");
let hooked = Config::parse(&format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\npre_deploy = \"{hook}\"\n",
fx.url,
td.target_path().display(),
))
.expect("hook-edited Outdated fixture config parses");
let out = sync(
&input(&hooked, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("an unforced hook-modified Outdated artifact must retain skip semantics");
assert_eq!(
first_commit(&out),
new_head,
"premise: the second sync must resolve the advanced source commit"
);
assert!(
!out.had_failures,
"skipping an Outdated artifact modified by a successful pre_deploy hook is not a failure"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).ok(),
Some(b"edited by pre-deploy".to_vec()),
"pre_deploy changed the observed Outdated artifact to Modified; without --force or an \
overwrite decision, the hook's local value must be preserved"
);
assert!(
!dst.join("extra.lua").exists(),
"a post-hook Modified artifact must be skipped as a unit; no file from the advanced \
source may be partially deployed"
);
assert_eq!(
fx.registry
.artifact(&key)
.expect("registry lookup after hook-modified skip"),
Some(record_before),
"skipping the post-hook Modified artifact must leave its prior registry record unchanged"
);
}
fn pre_deploy_hook_table(target: &str, hook: Option<(&str, Option<&str>)>) -> String {
let Some((command, on_fail)) = hook else {
return String::new();
};
let on_fail = on_fail
.map(|value| format!("pre_deploy_on_fail = \"{value}\"\n"))
.unwrap_or_default();
format!(
"\n[targets.{target}.hooks]\npre_deploy = \"{}\"\n{on_fail}",
command.replace('"', "\\\""),
)
}
fn config_two_source_targets_with_pre_deploy_hooks(
alpha_url: &str,
beta_url: &str,
alpha_path: &Path,
beta_path: &Path,
alpha_hook: Option<(&str, Option<&str>)>,
beta_hook: Option<(&str, Option<&str>)>,
) -> Config {
let alpha_hooks = pre_deploy_hook_table("alpha", alpha_hook);
let beta_hooks = pre_deploy_hook_table("beta", beta_hook);
let toml = format!(
"version = 1\n\n\
[sources.sa]\ngit = \"{alpha_url}\"\nbranch = \"main\"\n\n\
[sources.sb]\ngit = \"{beta_url}\"\nbranch = \"main\"\n\n\
[targets.alpha]\npath = \"{}\"\nsources = [\"sa\"]\nlayout = \"flat\"\n\n\
[targets.beta]\npath = \"{}\"\nsources = [\"sb\"]\nlayout = \"flat\"\n\
{alpha_hooks}{beta_hooks}",
alpha_path.display(),
beta_path.display(),
);
Config::parse(&toml).expect("two-source target-hook config parses")
}
#[test]
fn successful_earlier_target_hook_rechecks_later_target_without_a_hook() {
let (sa, url_a) = build_named_artifact_repo("alpha-art", "a.txt", b"from-alpha\n");
let (sb, url_b) = build_named_artifact_repo("beta-art", "b.txt", b"from-beta\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let alpha = TargetDir::new();
let beta = TargetDir::new();
let alpha_dst = alpha.target_path().join("alpha-art");
let beta_dst = beta.target_path().join("beta-art");
let beta_local = beta_dst.join("created-by-alpha-hook.txt");
let hook = format!(
"mkdir -p '{}' && printf '%s' 'alpha hook value' > '{}'",
beta_dst.display(),
beta_local.display(),
);
let cfg = config_two_source_targets_with_pre_deploy_hooks(
&url_a,
&url_b,
&alpha.target_path(),
&beta.target_path(),
Some((&hook, None)),
None,
);
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("an unforced cross-target hook conflict retains skip semantics");
assert!(
!out.had_failures,
"skipping beta after alpha's successful hook creates Foreign content is not a failure"
);
assert!(
alpha_dst.join("a.txt").exists(),
"alpha remains deployable after its successful hook"
);
assert_eq!(
std::fs::read(&beta_local).ok(),
Some(b"alpha hook value".to_vec()),
"alpha's hook changed beta from Missing to Foreign; beta has no hook of its own but must \
still be reobserved and preserve the local value"
);
assert!(
!beta_dst.join("b.txt").exists(),
"beta must not deploy upstream content over alpha's hook side effect without --force"
);
assert!(
registry
.artifact(&artifact_key("beta", "sb", "beta-art"))
.expect("lookup beta after cross-target skip")
.is_none(),
"the skipped beta artifact must not gain a registry record"
);
drop(sa);
drop(sb);
}
#[test]
fn failed_earlier_target_hook_with_skip_rechecks_later_target_side_effect() {
let (sa, url_a) = build_named_artifact_repo("alpha-art", "a.txt", b"from-alpha\n");
let (sb, url_b) = build_named_artifact_repo("beta-art", "b.txt", b"from-beta\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let alpha = TargetDir::new();
let beta = TargetDir::new();
let alpha_dst = alpha.target_path().join("alpha-art");
let beta_dst = beta.target_path().join("beta-art");
let beta_local = beta_dst.join("left-by-failed-alpha-hook.txt");
let hook = format!(
"mkdir -p '{}' && printf '%s' 'failed hook value' > '{}' && exit 7",
beta_dst.display(),
beta_local.display(),
);
let cfg = config_two_source_targets_with_pre_deploy_hooks(
&url_a,
&url_b,
&alpha.target_path(),
&beta.target_path(),
Some((&hook, Some("skip"))),
None,
);
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("pre_deploy_on_fail=skip continues to later targets");
assert_eq!(
std::fs::read(&beta_local).ok(),
Some(b"failed hook value".to_vec()),
"a failed alpha hook can leave a real side effect before skip; beta must reobserve and \
preserve that Foreign value"
);
assert!(
!beta_dst.join("b.txt").exists(),
"beta must not trust its pre-hook Missing observation after alpha's failed hook"
);
assert!(
!alpha_dst.exists(),
"pre_deploy_on_fail=skip must skip alpha's own deployment"
);
assert!(
registry
.all_artifacts()
.expect("list artifact records after failed-hook skips")
.is_empty(),
"neither skipped target may mutate the artifact registry"
);
drop(sa);
drop(sb);
}
#[test]
fn successful_hook_cannot_bless_modified_bytes_with_a_stale_metadata_refresh() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let plain =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let first = sync(
&input(&plain, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys the metadata-refresh fixture");
assert!(!first.had_failures, "premise: first deploy must succeed");
let key = artifact_key("dest", "editor-src", "editor");
let record_before = fx
.registry
.artifact(&key)
.expect("lookup record before metadata change")
.expect("first sync records the artifact");
let init_before = manifest_file(&record_before, "init.lua").clone();
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let init = dst.join("init.lua");
let refreshed_mtime = init_before.mtime + 1000;
touch_to_mtime(&init, refreshed_mtime);
let mtime_reference = td.parent_path.join("mtime-reference");
std::fs::write(&mtime_reference, b"reference").expect("write mtime reference file");
touch_to_mtime(&mtime_reference, refreshed_mtime);
let before_hook = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(before_hook, ArtifactState::Revalidated { .. }),
"premise: changed mtime with identical bytes must classify as \
MetadataChangedButContentClean/Revalidated, got {before_hook:?}"
);
let hook = format!(
"printf '%s' 'changed!' > '{}' && touch -r '{}' '{}'",
init.display(),
mtime_reference.display(),
init.display(),
)
.replace('"', "\\\"");
let hooked = Config::parse(&format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\npre_deploy = \"{hook}\"\n",
fx.url,
td.target_path().display(),
))
.expect("metadata-refresh hook config parses");
let out = sync(
&input(&hooked, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("an unforced metadata-clean-to-Modified transition retains skip semantics");
assert!(
!out.had_failures,
"skipping content modified by a successful pre_deploy hook is not a failure"
);
assert_eq!(
std::fs::read(&init).ok(),
Some(b"changed!".to_vec()),
"premise: the hook must leave its same-size modified bytes on disk"
);
let after_state = check_state_at(
&dst,
&fx.registry,
"dest",
"editor-src",
"editor",
&first_commit(&first),
);
assert!(
matches!(after_state, ArtifactState::Modified { .. }),
"the hook changed bytes while restoring the refreshed size+mtime; a stale metadata \
refresh must not bless those bytes as Clean, got {after_state:?}"
);
assert_eq!(
fx.registry
.artifact(&key)
.expect("lookup record after hook-modified metadata refresh"),
Some(record_before),
"the conflict skip must leave the pre-hook artifact record byte-identical"
);
}
#[test]
fn later_target_post_hook_abort_leaves_earlier_target_and_registry_untouched() {
let (sa, url_a) = build_named_artifact_repo("alpha-art", "a.txt", b"from-alpha\n");
let (sb, url_b) = build_named_artifact_repo("beta-art", "b.txt", b"from-beta\n");
let (_g, _s, backend, registry) = fresh_backend_registry();
let alpha = TargetDir::new();
let beta = TargetDir::new();
let alpha_dst = alpha.target_path().join("alpha-art");
let beta_dst = beta.target_path().join("beta-art");
let beta_local = beta_dst.join("created-before-abort.txt");
let hook = format!(
"mkdir -p '{}' && printf '%s' 'beta hook value' > '{}'",
beta_dst.display(),
beta_local.display(),
);
let cfg = config_two_source_targets_with_pre_deploy_hooks(
&url_a,
&url_b,
&alpha.target_path(),
&beta.target_path(),
None,
Some((&hook, None)),
);
let records_before = registry
.all_artifacts()
.expect("snapshot empty artifact registry before abort");
let resolver = ScriptedResolver::new(Resolution::Abort);
let result = sync(
&interactive_input(&cfg, None, &resolver),
&backend,
®istry,
);
let Err(error) = result else {
panic!("beta's post-hook Foreign conflict resolved as Abort must abort the whole run");
};
assert!(
matches!(error, Error::Aborted),
"the post-hook conflict must surface Error::Aborted, got {error:?}"
);
assert_eq!(
resolver.consulted(),
1,
"only beta's hook-created Foreign conflict requires a decision"
);
assert_eq!(
resolver.last_conflict().target,
"beta",
"the post-hook conflict must identify the later beta target"
);
assert!(
!alpha_dst.exists(),
"whole-run Abort atomicity: alpha must not deploy before beta's post-hook conflict is \
resolved"
);
assert_eq!(
std::fs::read(&beta_local).ok(),
Some(b"beta hook value".to_vec()),
"Abort must not roll back or overwrite the external side effect that exposed the conflict"
);
assert!(
!beta_dst.join("b.txt").exists(),
"beta's upstream content must not deploy after its conflict resolves Abort"
);
assert_aborted_zero_mutation(
®istry,
&records_before,
&[("alpha", &alpha), ("beta", &beta)],
);
drop(sa);
drop(sb);
}
#[test]
fn interactive_overwrite_redeploys_modified_with_upstream() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let base_lock = deploy_then_modify(&fx, &td, &cfg);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let resolver = ScriptedResolver::new(Resolution::Overwrite);
let out = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&fx.backend,
&fx.registry,
)
.expect("interactive overwrite must not error");
assert!(!out.had_failures, "an overwrite resolution must succeed");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("read redeployed init.lua"),
b"-- init\n",
"Overwrite must replace the local edit with the upstream artifact content"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get must not error")
.is_some(),
"Overwrite must leave the registry record in place for the redeployed artifact"
);
}
#[test]
fn interactive_skip_preserves_local_content() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let base_lock = deploy_then_modify(&fx, &td, &cfg);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let resolver = ScriptedResolver::new(Resolution::Skip);
let out = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&fx.backend,
&fx.registry,
)
.expect("interactive skip must not error");
assert!(!out.had_failures, "a skip resolution must not fail the run");
assert_eq!(
resolver.consulted(),
1,
"interactive sync must CONSULT the resolver for the Modified artifact (it did not)"
);
let conflict = resolver.last_conflict();
assert_eq!(
(
conflict.target.as_str(),
conflict.source.as_str(),
conflict.artifact.as_str()
),
("dest", "editor-src", "editor"),
"the Conflict handed to the resolver must identify (target, source, artifact), got {conflict:?}"
);
let ConflictKind::Modified { changed } = &conflict.kind else {
panic!(
"an edited managed artifact must surface as ConflictKind::Modified, got {:?}",
conflict.kind
);
};
assert_eq!(
changed.as_slice(),
[PathBuf::from("init.lua")],
"the Modified conflict must name the changed path (the edited init.lua), got {changed:?}"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("read preserved init.lua"),
b"-- locally edited\n",
"Skip must preserve the local edit, leaving the artifact untouched"
);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_nested_artifact_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor").join("lua")).unwrap();
std::fs::write(p.join("editor/init.lua"), b"-- init\n").unwrap();
std::fs::write(p.join("editor/lua/keymaps.lua"), b"-- keymaps\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
#[test]
fn interactive_foreign_eject_persists_entry_keeps_files_without_a_record() {
let (src, url) = build_nested_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let cfg = config_one_source_one_target("editor-src", &url, "dest", &td.target_path(), "flat");
let first = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync deploys the nested artifact");
assert!(!first.had_failures, "premise: first deploy must succeed");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
dst.join("lua").join("keymaps.lua").exists(),
"premise: the nested file must deploy so the eject keep-files check is meaningful"
);
let edited = b"-- locally edited\n";
std::fs::write(dst.join("init.lua"), edited).expect("edit deployed file");
registry
.remove_artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("remove managed record to make the existing content Foreign");
let resolver = ScriptedResolver::new(Resolution::Eject);
let out = sync(
&interactive_input(&cfg, Some(first.base_lock.clone()), &resolver),
&backend,
®istry,
)
.expect("interactive eject must not error");
assert!(
!out.had_failures,
"an eject resolution must not fail the run"
);
let ejected = registry.ejections("dest").expect("load ejected");
assert!(
ejected
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"Eject must persist an Ejection for (editor-src, editor), got {ejected:?}"
);
assert!(
registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry get must not error")
.is_none(),
"Foreign Eject must persist without requiring or recreating a managed record"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("read kept init.lua"),
b"-- locally edited\n",
"Eject must leave the edited top-level file untouched (keep local content)"
);
assert_eq!(
std::fs::read(dst.join("lua").join("keymaps.lua")).expect("read kept nested file"),
b"-- keymaps\n",
"Eject must keep EVERY on-disk file, including the nested lua/keymaps.lua, not just the top-level one"
);
drop(src);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_two_artifact_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/init.lua"), b"-- init\n").unwrap();
std::fs::create_dir_all(p.join("widget")).unwrap();
std::fs::write(p.join("widget/conf.toml"), b"[w]\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
#[test]
fn interactive_abort_stops_sync_without_processing_remaining() {
let (src, url) = build_two_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &url, "dest", &td.target_path(), "by-source");
let editor_dst = td.target_path().join("multi").join("editor");
let widget_dst = td.target_path().join("multi").join("widget");
preplace_foreign(&editor_dst, b"hand-written editor\n");
preplace_foreign(&widget_dst, b"hand-written widget\n");
let resolver = ScriptedResolver::new(Resolution::Abort);
let result = sync(
&interactive_input(&cfg, None, &resolver),
&backend,
®istry,
);
let Err(err) = result else {
panic!("an Abort resolution must stop the sync and return Err, got Ok");
};
assert!(
matches!(err, Error::Aborted),
"Abort must surface as Error::Aborted, got {err:?}"
);
assert_eq!(
resolver.consulted(),
2,
"whole-run preflight resolves EVERY conflict before the global Abort check: both Foreign \
conflicts are consulted, then the Abort verdict fails the run (got {})",
resolver.consulted()
);
assert!(
!editor_dst.join("init.lua").exists() && !widget_dst.join("conf.toml").exists(),
"Abort must make NO changes: neither artifact may be deployed over the Foreign content"
);
assert_eq!(
std::fs::read(editor_dst.join("local-only.txt"))
.expect("preexisting editor Foreign file still present after abort"),
b"hand-written editor\n",
"Abort must not touch the preexisting Foreign content it stopped at"
);
assert_eq!(
std::fs::read(widget_dst.join("local-only.txt"))
.expect("preexisting widget Foreign file still present after abort"),
b"hand-written widget\n",
"Abort must not delete the not-yet-processed artifact's preexisting content either"
);
drop(src);
}
#[test]
fn non_interactive_still_warns_and_skips_modified_without_resolver() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let base_lock = deploy_then_modify(&fx, &td, &cfg);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let out = sync(
&input(&cfg, None, Some(base_lock), None, false),
&fx.backend,
&fx.registry,
)
.expect("non-interactive sync must not error on a Modified artifact");
assert!(
!out.had_failures,
"non-interactive skip of a Modified artifact is not a failure"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("read preserved init.lua"),
b"-- locally edited\n",
"without interactive mode a Modified artifact must still be skipped, preserving the edit"
);
}
fn phora_staging_present(dirs: &[PathBuf]) -> bool {
dirs.iter().any(|dir| dir_has_phora_descendant(dir))
}
fn dir_has_phora_descendant(dir: &Path) -> bool {
let Ok(entries) = std::fs::read_dir(dir) else {
return false;
};
entries.flatten().any(|entry| {
entry.file_name().to_string_lossy().starts_with(".phora-")
|| (entry.file_type().is_ok_and(|t| t.is_dir())
&& dir_has_phora_descendant(&entry.path()))
})
}
#[test]
fn phora_staging_probe_detects_a_nested_staging_path() {
let root = TempDir::new().expect("probe root");
let nested = root.path().join("dest").join("multi");
std::fs::create_dir_all(&nested).expect("mkdir nested target subtree");
let roots = [root.path().to_path_buf()];
assert!(
!phora_staging_present(&roots),
"a clean target subtree must not read as staged"
);
std::fs::create_dir_all(nested.join(".phora-stage")).expect("plant staging dir");
assert!(
phora_staging_present(&roots),
"a .phora-stage planted at <root>/dest/multi — the real by-source staging depth \
(target_parent(artifact_dst).join(\".phora-stage\")) — must be detected: the probe walks \
the whole subtree, not just the root's direct children"
);
}
struct OrderedResolver {
verdicts: Vec<Resolution>,
staging_dirs: Vec<PathBuf>,
consulted: AtomicUsize,
seen: Mutex<Vec<Conflict>>,
staging_seen: Mutex<bool>,
}
impl OrderedResolver {
fn new(verdicts: Vec<Resolution>, staging_dirs: Vec<PathBuf>) -> Self {
Self {
verdicts,
staging_dirs,
consulted: AtomicUsize::new(0),
seen: Mutex::new(Vec::new()),
staging_seen: Mutex::new(false),
}
}
fn consulted(&self) -> usize {
self.consulted.load(AtomicOrdering::SeqCst)
}
fn staging_seen(&self) -> bool {
*self.staging_seen.lock().expect("staging mutex")
}
}
impl ConflictResolver for OrderedResolver {
fn resolve(&self, conflict: &Conflict) -> Resolution {
let n = self.consulted.fetch_add(1, AtomicOrdering::SeqCst);
self.seen.lock().expect("seen mutex").push(conflict.clone());
if phora_staging_present(&self.staging_dirs) {
*self.staging_seen.lock().expect("staging mutex") = true;
}
*self
.verdicts
.get(n)
.or_else(|| self.verdicts.last())
.expect("OrderedResolver needs at least one verdict")
}
}
struct StageWatchResolver {
probes: Vec<(PathBuf, Vec<u8>)>,
staging_dirs: Vec<PathBuf>,
max_staged_at_resolve: Mutex<usize>,
consulted: AtomicUsize,
staging_seen: Mutex<bool>,
}
impl StageWatchResolver {
fn new(probes: Vec<(PathBuf, Vec<u8>)>, staging_dirs: Vec<PathBuf>) -> Self {
Self {
probes,
staging_dirs,
max_staged_at_resolve: Mutex::new(0),
consulted: AtomicUsize::new(0),
staging_seen: Mutex::new(false),
}
}
fn max_staged_at_resolve(&self) -> usize {
*self.max_staged_at_resolve.lock().expect("max mutex")
}
fn consulted(&self) -> usize {
self.consulted.load(AtomicOrdering::SeqCst)
}
fn staging_seen(&self) -> bool {
*self.staging_seen.lock().expect("staging mutex")
}
}
impl ConflictResolver for StageWatchResolver {
fn resolve(&self, _conflict: &Conflict) -> Resolution {
self.consulted.fetch_add(1, AtomicOrdering::SeqCst);
let staged = self
.probes
.iter()
.filter(|(path, upstream)| {
std::fs::read(path).ok().as_deref() == Some(upstream.as_slice())
})
.count();
let mut max = self.max_staged_at_resolve.lock().expect("max mutex");
*max = (*max).max(staged);
if phora_staging_present(&self.staging_dirs) {
*self.staging_seen.lock().expect("staging mutex") = true;
}
Resolution::Overwrite
}
}
fn deploy_two_modified(
backend: &GitBackend,
registry: &FileStateStore,
td: &TargetDir,
cfg: &Config,
) -> (Lock, PathBuf, PathBuf) {
let first = sync(&input(cfg, None, None, None, false), backend, registry)
.expect("first sync deploys both artifacts");
assert!(!first.had_failures, "premise: the first deploy is clean");
let editor_dir = td.target_path().join("multi").join("editor");
let widget_dir = td.target_path().join("multi").join("widget");
std::fs::write(editor_dir.join("init.lua"), b"-- locally edited\n").expect("edit editor");
std::fs::write(widget_dir.join("conf.toml"), b"-- locally edited\n").expect("edit widget");
let commit = first
.base_lock
.find_source("multi")
.expect("multi present in base lock")
.commit
.clone();
for (dir, artifact) in [(&editor_dir, "editor"), (&widget_dir, "widget")] {
let st = check_state_at(dir, registry, "dest", "multi", artifact, &commit);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: edited {artifact} must read Modified, got {st:?}"
);
}
(first.base_lock, editor_dir, widget_dir)
}
#[test]
fn eject_then_abort_persists_no_ejection_and_leaves_disk_untouched() {
let (src, url) = build_two_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &url, "dest", &td.target_path(), "by-source");
let (base_lock, editor_dir, widget_dir) = deploy_two_modified(&backend, ®istry, &td, &cfg);
let before = registry
.all_artifacts()
.expect("snapshot records before abort");
let resolver = OrderedResolver::new(
vec![Resolution::Eject, Resolution::Abort],
vec![td.parent_path.clone()],
);
let result = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&backend,
®istry,
);
let Err(err) = result else {
panic!("an Eject-then-Abort ChangeSet must abort the whole run, got Ok");
};
assert!(
matches!(err, Error::Aborted),
"the run must surface Error::Aborted, got {err:?}"
);
assert_eq!(
resolver.consulted(),
2,
"preflight must resolve BOTH conflicts into the decision set before the global Abort \
check, got {}",
resolver.consulted()
);
assert!(
!resolver.staging_seen(),
"no .phora-* staging path may exist at ANY resolve consultation — preflight resolution \
must precede staging, so a stage-then-clean-on-abort pipeline is forbidden"
);
assert_aborted_zero_mutation(®istry, &before, &[("dest", &td)]);
assert_eq!(
std::fs::read(editor_dir.join("init.lua")).expect("read editor init.lua"),
b"-- locally edited\n",
"no Eject/deploy side effect may reach disk once the run aborts"
);
assert_eq!(
std::fs::read(widget_dir.join("conf.toml")).expect("read widget conf.toml"),
b"-- locally edited\n",
"the not-yet-applied artifact's edit must survive the abort too"
);
drop(src);
}
#[test]
fn overwrite_then_abort_stages_no_deploy() {
let (src, url) = build_two_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &url, "dest", &td.target_path(), "by-source");
let (base_lock, editor_dir, widget_dir) = deploy_two_modified(&backend, ®istry, &td, &cfg);
let before = registry
.all_artifacts()
.expect("snapshot records before abort");
let resolver = OrderedResolver::new(
vec![Resolution::Overwrite, Resolution::Abort],
vec![td.parent_path.clone()],
);
let result = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&backend,
®istry,
);
let Err(err) = result else {
panic!("an Overwrite-then-Abort ChangeSet must abort the whole run, got Ok");
};
assert!(
matches!(err, Error::Aborted),
"the run must surface Error::Aborted, got {err:?}"
);
assert!(
!resolver.staging_seen(),
"no .phora-* staging path may exist at ANY resolve consultation — the Overwrite must not \
be staged before preflight discovers the sibling Abort"
);
assert_eq!(
std::fs::read(editor_dir.join("init.lua")).expect("read editor init.lua"),
b"-- locally edited\n",
"resolve-before-staging: the Overwrite-resolved artifact must NOT be redeployed — \
preflight discovers the sibling Abort before ANY staging or deploy runs"
);
assert_eq!(
std::fs::read(widget_dir.join("conf.toml")).expect("read widget conf.toml"),
b"-- locally edited\n",
"the abort artifact's own content is untouched as well"
);
assert_aborted_zero_mutation(®istry, &before, &[("dest", &td)]);
drop(src);
}
#[test]
fn every_conflict_is_resolved_before_any_artifact_is_deployed() {
let (src, url) = build_two_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &url, "dest", &td.target_path(), "by-source");
let (base_lock, editor_dir, widget_dir) = deploy_two_modified(&backend, ®istry, &td, &cfg);
let resolver = StageWatchResolver::new(
vec![
(editor_dir.join("init.lua"), b"-- init\n".to_vec()),
(widget_dir.join("conf.toml"), b"[w]\n".to_vec()),
],
vec![td.parent_path.clone()],
);
let out = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&backend,
®istry,
)
.expect("an all-Overwrite run must succeed");
assert!(!out.had_failures, "an all-overwrite run is clean");
assert_eq!(
resolver.consulted(),
2,
"both Modified conflicts must be resolved, got {}",
resolver.consulted()
);
assert_eq!(
resolver.max_staged_at_resolve(),
0,
"resolve-before-staging: while ANY conflict was being resolved, no earlier artifact may \
have been deployed yet — preflight resolves the whole ChangeSet before staging any of it"
);
assert!(
!resolver.staging_seen(),
"no .phora-* staging path may exist at ANY resolve consultation — staging must not begin \
until the whole ChangeSet is resolved"
);
assert_eq!(
std::fs::read(editor_dir.join("init.lua")).expect("read editor init.lua"),
b"-- init\n",
"the apply pass must eventually overwrite editor with upstream"
);
assert_eq!(
std::fs::read(widget_dir.join("conf.toml")).expect("read widget conf.toml"),
b"[w]\n",
"the apply pass must eventually overwrite widget with upstream"
);
drop(src);
}
fn config_one_source_two_targets(
source: &str,
url: &str,
target_a: &str,
path_a: &Path,
target_b: &str,
path_b: &Path,
layout: &str,
) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.{target_a}]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n\n\
[targets.{target_b}]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n",
path_a.display(),
path_b.display(),
);
Config::parse(&toml).expect("one-source two-target config parses")
}
fn sort_records(mut records: Vec<ArtifactRecord>) -> Vec<ArtifactRecord> {
records.sort_by(|a, b| {
(&a.key.target, &a.key.source, &a.key.artifact).cmp(&(
&b.key.target,
&b.key.source,
&b.key.artifact,
))
});
records
}
fn assert_aborted_zero_mutation(
registry: &FileStateStore,
before_records: &[ArtifactRecord],
targets: &[(&str, &TargetDir)],
) {
let journal = Journal::open(®istry.journal_root()).expect("open journal");
assert!(
journal.entries().expect("read journal entries").is_empty(),
"abort fail-fast: the deploy journal must hold ZERO entries — no staging intent may be \
journaled before the global Abort check"
);
assert_eq!(
sort_records(registry.all_artifacts().expect("list all records")),
sort_records(before_records.to_vec()),
"abort must leave every registry record byte-identical — no put/remove may run before the \
global Abort check"
);
for (name, td) in targets {
assert!(
registry.ejections(name).expect("load ejected").is_empty(),
"abort must persist ZERO ejections for target {name}"
);
assert!(
!td.has_phora_leftover(),
"abort must leave no .phora-* staging path under target {name}'s parent {}",
td.parent_path.display()
);
}
}
fn deploy_two_targets_modified(
fx: &SyncFixture,
registry: &FileStateStore,
td_a: &TargetDir,
td_b: &TargetDir,
cfg: &Config,
) -> (Lock, PathBuf, PathBuf) {
let first = sync(&input(cfg, None, None, None, false), &fx.backend, registry)
.expect("first sync deploys both targets");
assert!(!first.had_failures, "premise: the first deploy is clean");
let dir_a = td_a.target_path().join("solo").join("editor");
let dir_b = td_b.target_path().join("solo").join("editor");
std::fs::write(dir_a.join("init.lua"), b"-- edited a\n").expect("edit target a");
std::fs::write(dir_b.join("init.lua"), b"-- edited b\n").expect("edit target b");
let commit = first
.base_lock
.find_source("solo")
.expect("solo present in base lock")
.commit
.clone();
for (dir, target) in [(&dir_a, "alpha"), (&dir_b, "beta")] {
let st = check_state_at(dir, registry, target, "solo", "editor", &commit);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: edited {target} copy must read Modified, got {st:?}"
);
}
(
first.base_lock,
dir_a.join("init.lua"),
dir_b.join("init.lua"),
)
}
#[test]
fn cross_target_eject_then_abort_mutates_neither_target() {
let fx = build_sync_fixture();
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let cfg = config_one_source_two_targets(
"solo",
&fx.url,
"alpha",
&td_a.target_path(),
"beta",
&td_b.target_path(),
"by-source",
);
let (base_lock, file_a, file_b) =
deploy_two_targets_modified(&fx, &fx.registry, &td_a, &td_b, &cfg);
let before = fx
.registry
.all_artifacts()
.expect("snapshot records before abort");
let resolver = OrderedResolver::new(
vec![Resolution::Eject, Resolution::Abort],
vec![td_a.parent_path.clone(), td_b.parent_path.clone()],
);
let result = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&fx.backend,
&fx.registry,
);
let Err(err) = result else {
panic!("an Eject (target A) then Abort (target B) run must abort the WHOLE sync, got Ok");
};
assert!(
matches!(err, Error::Aborted),
"the run must surface Error::Aborted, got {err:?}"
);
assert_eq!(
resolver.consulted(),
2,
"whole-run preflight must resolve BOTH targets' conflicts before the global Abort check — \
a per-target preflight that applies target A before consulting target B is forbidden; \
got {}",
resolver.consulted()
);
assert!(
!resolver.staging_seen(),
"no .phora-* staging path may exist under EITHER target at any resolve consultation — \
whole-run preflight resolves every target's conflict before any target is staged"
);
assert_aborted_zero_mutation(&fx.registry, &before, &[("alpha", &td_a), ("beta", &td_b)]);
assert_eq!(
std::fs::read(&file_a).expect("read target a init.lua"),
b"-- edited a\n",
"target alpha's edit must survive — no Eject may be applied when a SIBLING TARGET aborts"
);
assert_eq!(
std::fs::read(&file_b).expect("read target b init.lua"),
b"-- edited b\n",
"target beta's edit must survive the abort too"
);
}
#[test]
fn cross_target_conflicts_all_resolve_before_any_target_is_deployed() {
let fx = build_sync_fixture();
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let cfg = config_one_source_two_targets(
"solo",
&fx.url,
"alpha",
&td_a.target_path(),
"beta",
&td_b.target_path(),
"by-source",
);
let (base_lock, file_a, file_b) =
deploy_two_targets_modified(&fx, &fx.registry, &td_a, &td_b, &cfg);
let resolver = StageWatchResolver::new(
vec![
(file_a.clone(), b"-- init\n".to_vec()),
(file_b.clone(), b"-- init\n".to_vec()),
],
vec![td_a.parent_path.clone(), td_b.parent_path.clone()],
);
let out = sync(
&interactive_input(&cfg, Some(base_lock), &resolver),
&fx.backend,
&fx.registry,
)
.expect("an all-Overwrite run across two targets must succeed");
assert!(!out.had_failures, "an all-overwrite run is clean");
assert_eq!(
resolver.consulted(),
2,
"both targets' Modified conflicts must be resolved, got {}",
resolver.consulted()
);
assert_eq!(
resolver.max_staged_at_resolve(),
0,
"whole-run resolve-before-staging ACROSS TARGETS: no target may be deployed while another \
target's conflict is still being resolved — preflight spans the entire sync() run, not \
one deploy_target call"
);
assert!(
!resolver.staging_seen(),
"no .phora-* staging path may exist under EITHER target at any resolve consultation — \
staging across the whole run starts only after every target's conflict is resolved"
);
assert_eq!(
std::fs::read(&file_a).expect("read target a init.lua"),
b"-- init\n",
"the apply pass must eventually overwrite target alpha with upstream"
);
assert_eq!(
std::fs::read(&file_b).expect("read target b init.lua"),
b"-- init\n",
"the apply pass must eventually overwrite target beta with upstream"
);
}
#[test]
fn sync_runs_recovery_sweep_finishing_a_swapped_but_unrecorded_artifact() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let crashed_dst = td.target_path().join("orphan-artifact");
std::fs::create_dir_all(&crashed_dst).expect("mkdir crashed dst");
std::fs::write(crashed_dst.join("recovered.txt"), b"recovered\n").expect("write dst file");
let crashed_key = artifact_key("dest", "ghost-src", "orphan-artifact");
let record = ArtifactRecord {
version: 1,
key: crashed_key.clone(),
source: "ghost-src".to_owned(),
commit: fx.head_sha.clone(),
digest: "blake3:recovered".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("recovered.txt"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 10,
mtime: 1_700_000_000,
blake3: "blake3:recovered".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
let staging_base = td.parent_path.join(".phora-stage");
let staging = staging_base.join("orphan-artifact-deadbeef");
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
journal
.append(&JournalEntry {
staging_base,
staging,
dst: crashed_dst,
record,
swap_completed: true,
})
.expect("seed swap-completed crash intent");
assert!(
fx.registry
.artifact(&crashed_key)
.expect("pre-sync get")
.is_none(),
"premise: the crashed artifact has no registry record yet"
);
assert_eq!(
journal.entries().expect("read seeded journal").len(),
1,
"premise: the crash intent is the sole pending journal entry before sync"
);
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync runs (and must sweep recovery first)");
assert!(
fx.registry
.artifact(&crashed_key)
.expect("post-sync get")
.is_some(),
"`orphan-artifact` is not a name Phase 2 discovers (the fixture exposes `editor`), so \
its record can only exist if the start-of-sync recovery_sweep finished the crashed swap"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("post-sync get for editor")
.is_some(),
"premise: Phase 2 deploys the discovered `editor` artifact (distinct from the swept one), \
proving the swept record was not a Phase 2 side effect"
);
assert!(
journal
.entries()
.expect("read journal after sync")
.is_empty(),
"the recovery sweep must CLEAR the journal once it finishes the crashed swap"
);
}
struct FailingResolveBackend<'a> {
inner: &'a GitBackend,
}
impl SourceStore for FailingResolveBackend<'_> {
fn resolve(
&self,
_request: &ResolveRequest,
_policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
Err(SourceError::Source("injected resolve failure".to_owned()))
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
#[test]
fn sync_runs_recovery_before_phase1_even_when_resolve_fails() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let crashed_dst = td.target_path().join("orphan-artifact");
std::fs::create_dir_all(&crashed_dst).expect("mkdir crashed dst");
std::fs::write(crashed_dst.join("recovered.txt"), b"recovered\n").expect("write dst file");
let crashed_key = artifact_key("dest", "editor-src", "orphan-artifact");
let record = ArtifactRecord {
version: 1,
key: crashed_key.clone(),
source: "editor-src".to_owned(),
commit: fx.head_sha.clone(),
digest: "blake3:recovered".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("recovered.txt"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 10,
mtime: 1_700_000_000,
blake3: "blake3:recovered".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
let staging_base = td.parent_path.join(".phora-stage");
let staging = staging_base.join("orphan-artifact-deadbeef");
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
journal
.append(&JournalEntry {
staging_base,
staging,
dst: crashed_dst,
record,
swap_completed: true,
})
.expect("seed swap-completed crash intent");
assert!(
fx.registry
.artifact(&crashed_key)
.expect("pre-sync get")
.is_none(),
"premise: the crashed artifact has no registry record yet"
);
let backend = FailingResolveBackend { inner: &fx.backend };
let result = sync(
&input(&cfg, None, None, None, false),
&backend,
&fx.registry,
);
assert!(
result.is_err(),
"premise: Phase 1 (resolve_sources) must fail when the backend's resolve errors"
);
assert!(
fx.registry
.artifact(&crashed_key)
.expect("post-sync get")
.is_some(),
"recovery must run at the TRUE START (before Phase 1): the crashed record exists only \
if recovery_sweep finished the swap before resolve_sources returned its error"
);
assert!(
journal
.entries()
.expect("read journal after sync")
.is_empty(),
"recovery running before Phase 1 must have CLEARED the journal despite the Phase 1 error"
);
}
fn seed_managed_artifact(
td: &TargetDir,
reg: &FileStateStore,
source: &str,
artifact: &str,
file: &str,
content: &[u8],
) -> PathBuf {
let dst = td.artifact_dst(&flat_layout(), source, artifact);
std::fs::create_dir_all(&dst).expect("mkdir managed dst");
std::fs::write(dst.join(file), content).expect("write managed file");
let record = ArtifactRecord {
version: 1,
key: artifact_key("dest", source, artifact),
source: source.to_owned(),
commit: "feedfacefeedfacefeedfacefeedfacefeedface".to_owned(),
digest: "blake3:seed".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from(file),
kind: crate::sync::state::ManifestEntryKind::File,
size: content.len() as u64,
mtime: 1_700_000_000,
blake3: blake3::hash(content).to_hex().to_string(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
reg.put_artifact(&record).expect("seed managed record");
dst
}
fn eject_target_config(td: &TargetDir, fx: &SyncFixture) -> Config {
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat")
}
#[test]
fn eject_adds_ejected_entry_keeps_record_and_files() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = eject_target_config(&td, &fx);
let dst = seed_managed_artifact(
&td,
&fx.registry,
"editor-src",
"editor",
"init.lua",
b"-- init\n",
);
let key = artifact_key("dest", "editor-src", "editor");
assert!(
fx.registry
.artifact(&key)
.expect("registry get must not error")
.is_some(),
"premise: the artifact must be MANAGED (record present) before eject"
);
eject(
&cfg,
&fx.registry,
"editor",
"editor-src",
"dest",
&fx.backend,
)
.expect("eject a managed artifact must succeed");
let ejected = fx.registry.ejections("dest").expect("load ejected");
assert!(
ejected
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"eject must add an Ejection for (editor-src, editor), got {ejected:?}"
);
assert!(
fx.registry
.artifact(&key)
.expect("registry get must not error")
.is_some(),
"eject must KEEP the registry record so list/where can render it as ejected"
);
let state = crate::sync::inspect::check_artifact_state(
&dst,
"editor-src",
"any-commit",
&ejected,
"editor",
&fx.registry,
&key,
None,
)
.expect("check_artifact_state");
assert!(
matches!(state, crate::sync::inspect::ArtifactState::Ejected),
"a kept record plus its ejected entry must read as Ejected, got {state:?}"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed file still present"),
b"-- init\n",
"eject must LEAVE the on-disk files untouched"
);
}
#[test]
fn eject_turns_history_overlay_into_a_standalone_clone_before_persisting_ejection() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = eject_target_config(&td, &fx);
let project = TempDir::new().expect("project root");
let deploy = td.target_path().join("history");
std::fs::create_dir_all(deploy.join("editor")).expect("create history content directory");
std::fs::create_dir_all(deploy.join("docs")).expect("create history docs directory");
std::fs::write(deploy.join("editor/init.lua"), b"-- init\n").expect("write history init");
std::fs::write(deploy.join("editor/notes.bak"), b"scratch\n").expect("write history notes");
std::fs::write(deploy.join("docs/readme.md"), b"# docs\n").expect("write history docs");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let resolved = resolve_git_source(
&fx.backend,
"editor-src",
&fx.url,
RevisionSpec::Commit(fx.head_sha.parse().expect("fixture commit")),
ResolvePolicy::CachedOnly,
);
let admin_id = worktree_admin_id(project.path(), &deploy, "dest", "editor-src")
.expect("derive persisted worktree id");
SourceStore::lock_worktree_mirror(&fx.backend, &sn("editor-src"), resolved.snapshot.mirror())
.expect("lock seeded mirror")
.publish_worktree(&WorktreeDeployRequest {
admin_id: admin_id.clone(),
deploy_root: deploy.clone(),
commit: fx.head_sha.parse().expect("fixture commit"),
})
.expect("publish overlay fixture");
let mirror = crate::source::mirror_path(fx.git_dir.path(), &fx.url);
let admin = mirror
.join("worktrees")
.join(format!("ph-{}", admin_id.as_str()));
let pin = mirror.join("refs/phora/worktrees").join(admin_id.as_str());
fx.registry
.put_artifact(&ArtifactRecord {
version: 1,
key: artifact_key("dest", "editor-src", "history"),
source: "editor-src".to_owned(),
commit: fx.head_sha.clone(),
digest: "fixture".to_owned(),
projected_at: "2026-08-31T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: false,
history: true,
worktree_admin_id: Some(admin_id.as_str().to_owned()),
mirror_key: Some(resolved.snapshot.mirror().as_str().to_owned()),
cache_git_root: Some(
fx.git_dir
.path()
.canonicalize()
.expect("physical cache root")
.to_string_lossy()
.into_owned(),
),
vars_digest: None,
deploy_root: None,
layout_separator: None,
})
.expect("persist history record");
let clone = eject(
&cfg,
&fx.registry,
"history",
"editor-src",
"dest",
&fx.backend,
)
.expect("eject managed history artifact");
assert_eq!(clone.as_deref(), Some(deploy.as_path()));
assert!(
deploy.join(".git").is_dir() && !admin.exists() && !pin.exists(),
"eject must replace the gitlink with a standalone clone and drop the recorded-mirror \
administration and pin before it persists Ejection"
);
assert!(
deploy.join("editor/init.lua").exists()
&& fx
.registry
.ejections("dest")
.expect("load ejections")
.iter()
.any(|entry| entry.source == "editor-src" && entry.artifact == "history"),
"eject must retain content while recording the ejection"
);
}
fn history_reshape_configs(url: &str, target: &Path) -> (Config, Config) {
let history = Config::parse(&format!(
"version = 1\n\n[sources.editor]\ngit = \"{url}\"\nbranch = \"main\"\n\n[targets.dest]\npath = \"{}\"\nlayout = \"flat\"\nsources = {{ archive = {{ source = \"editor\", history = true }} }}\n",
target.display(),
))
.expect("history config parses");
let ordinary = Config::parse(&format!(
"version = 1\n\n[sources.editor]\ngit = \"{url}\"\nbranch = \"main\"\n\n[targets.dest]\npath = \"{}\"\nlayout = \"flat\"\nsources = {{ archive = {{ source = \"editor\" }} }}\n",
target.display(),
))
.expect("ordinary config parses");
(history, ordinary)
}
#[test]
fn history_deploys_template_suffixed_files_verbatim() {
let fx = build_sync_fixture();
let src = fx.src.path();
let foreign_template = b"{{ range .Items }}{{ \"x\" | printf }}{{ end }}\n";
std::fs::write(src.join("editor/gen.go.tmpl"), foreign_template).unwrap();
run_git(src, &["add", "-A"]);
run_git(src, &["commit", "-m", "vendor a go template"]);
let td = TargetDir::new();
let (history, _) = history_reshape_configs(&fx.url, &td.target_path());
sync(
&input(&history, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("a history checkout deploys a foreign .tmpl file without rendering it");
let deployed = td.target_path().join("archive/editor/gen.go.tmpl");
assert_eq!(
std::fs::read(&deployed).expect("the .tmpl file keeps its name"),
foreign_template,
"history deploys a git checkout verbatim"
);
}
#[test]
fn history_off_reshape_applies_after_skip_and_retires_the_persisted_overlay() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let (history, ordinary) = history_reshape_configs(&fx.url, &td.target_path());
let first = sync(
&input(&history, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("history sync deploys");
let old_root = td.target_path().join("archive");
let old_key = artifact_key("dest", "archive", "archive");
let admin_id = fx
.registry
.artifact(&old_key)
.expect("read history record")
.expect("history sync writes record")
.worktree_admin_id
.expect("history record has admin id");
let mirror = crate::source::mirror_path(fx.git_dir.path(), &fx.url);
let admin = mirror.join("worktrees").join(format!("ph-{admin_id}"));
let pin = mirror.join("refs/phora/worktrees").join(&admin_id);
std::fs::write(old_root.join("editor/init.lua"), b"-- modified\n")
.expect("modify history content");
let resolver = ScriptedResolver::new(Resolution::Skip);
sync(
&interactive_input(&ordinary, Some(first.base_lock.clone()), &resolver),
&fx.backend,
&fx.registry,
)
.expect("ordinary sync may skip the modified history deployment");
assert!(
old_root.join(".git").exists()
&& std::fs::read(old_root.join("editor/init.lua"))
.expect("read skipped modified content")
== b"-- modified\n"
&& admin.exists()
&& pin.exists()
&& fx
.registry
.artifact(&old_key)
.expect("read skipped history record")
.is_some(),
"Skip must preserve the old overlay, content, and record"
);
std::fs::write(old_root.join("editor/init.lua"), b"-- init\n")
.expect("restore skipped history content");
let interrupted_state = TempDir::new().expect("interrupted state directory");
let interrupted = FileStateStore::open(interrupted_state.path().to_path_buf())
.expect("open interrupted registry");
sync(
&input(&ordinary, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&interrupted,
)
.expect("ordinary artifacts persist before simulated interruption");
for record in interrupted.all_artifacts().expect("read artifacts") {
fx.registry.put_artifact(&record).expect("persist artifact");
}
let persisted = fx
.registry
.target_artifacts("dest")
.expect("read ordinary artifacts");
assert!(
["docs", "editor"]
.into_iter()
.all(|artifact| persisted.iter().any(|record| {
record.key == artifact_key("dest", "archive", artifact) && !record.history
})),
"the interrupted state preserves the old overlay beside clean ordinary replacements"
);
assert_frozen_lockless_history_retirement_refusal(
&ordinary,
first.base_lock.clone(),
&fx,
&old_root,
&admin,
&pin,
&old_key,
);
sync(
&input(&ordinary, None, Some(first.base_lock), None, false),
&fx.backend,
&fx.registry,
)
.expect("plain retry retires the persisted overlay after clean replacements");
assert!(
!old_root.join(".git").exists()
&& !admin.exists()
&& !pin.exists()
&& fx
.registry
.artifact(&old_key)
.expect("read retired history record")
.is_none(),
"clean ordinary replacements retire the old overlay, record, administration, and pin"
);
}
fn assert_frozen_lockless_history_retirement_refusal(
ordinary: &Config,
base_lock: crate::lock::Lock,
fx: &SyncFixture,
old_root: &Path,
admin: &Path,
pin: &Path,
old_key: &ArtifactKey,
) {
let record_before_frozen_lockless = fx
.registry
.artifact(old_key)
.expect("read overlay record before the frozen lockless attempt");
let frozen_lockless_result = sync(
&frozen_lockless_input(ordinary, Some(base_lock), false),
&fx.backend,
&fx.registry,
);
assert!(
frozen_lockless_result.is_err(),
"a frozen lockless sync facing an identity-distinct history-off retirement with ready \
ordinary artifacts must refuse before retiring the old overlay, but it succeeded"
);
assert!(
old_root.join(".git").exists()
&& admin.exists()
&& pin.exists()
&& fx
.registry
.artifact(old_key)
.expect("read overlay record after the refused frozen lockless attempt")
== record_before_frozen_lockless,
"a refused frozen lockless sync must leave the old overlay's content, gitlink \
administration, pin, and registry record untouched"
);
}
#[test]
fn eject_persists_entry_across_a_reopened_registry() {
let state_dir = TempDir::new().expect("state dir");
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = eject_target_config(&td, &fx);
let reg = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
seed_managed_artifact(&td, ®, "editor-src", "editor", "init.lua", b"-- init\n");
eject(&cfg, ®, "editor", "editor-src", "dest", &fx.backend).expect("eject must succeed");
let reopened = FileStateStore::open(state_dir.path().to_path_buf()).expect("reopen registry");
let ejected = reopened.ejections("dest").expect("load ejected reopened");
assert!(
ejected
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"eject must PERSIST the ejected entry to disk so a fresh registry sees it, got {ejected:?}"
);
}
#[test]
fn uneject_removes_matching_entry_and_leaves_others() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = eject_target_config(&td, &fx);
let seeded = vec![
Ejection {
source: "editor-src".to_owned(),
artifact: "editor".to_owned(),
ejected_at: "2026-01-31T14:00:00Z".to_owned(),
},
Ejection {
source: "other-src".to_owned(),
artifact: "widget".to_owned(),
ejected_at: "2026-01-30T10:00:00Z".to_owned(),
},
];
fx.registry
.save_ejections("dest", &seeded)
.expect("seed ejected entries");
uneject(&cfg, &fx.registry, "editor", "editor-src", "dest")
.expect("uneject an ejected artifact must succeed");
let ejected = fx.registry.ejections("dest").expect("load ejected");
assert!(
!ejected
.iter()
.any(|e| e.source == "editor-src" && e.artifact == "editor"),
"uneject must REMOVE the matching (editor-src, editor) entry, got {ejected:?}"
);
assert!(
ejected
.iter()
.any(|e| e.source == "other-src" && e.artifact == "widget"),
"uneject must LEAVE unrelated ejected entries intact, got {ejected:?}"
);
}
fn seed_verifiable_artifact(
td: &TargetDir,
reg: &FileStateStore,
source: &str,
artifact: &str,
files: &[(&str, &[u8])],
) -> PathBuf {
let dst = td.artifact_dst(&flat_layout(), source, artifact);
let manifest = files
.iter()
.map(|(rel, content)| {
let path = dst.join(rel);
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).expect("mkdir verify file parent");
}
std::fs::write(&path, content).expect("write verify file");
ManifestFile {
path: PathBuf::from(rel),
kind: crate::sync::state::ManifestEntryKind::File,
size: content.len() as u64,
mtime: 1_700_000_000,
blake3: blake3::hash(content).to_hex().to_string(),
}
})
.collect();
let record = ArtifactRecord {
version: 1,
key: artifact_key("dest", source, artifact),
source: source.to_owned(),
commit: "feedfacefeedfacefeedfacefeedfacefeedface".to_owned(),
digest: "blake3:seed".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: manifest,
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
reg.put_artifact(&record).expect("seed verifiable record");
dst
}
fn verify_config(td: &TargetDir, fx: &SyncFixture) -> Config {
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat")
}
#[test]
fn verify_reports_no_mismatch_when_content_matches_recorded_hash() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
seed_verifiable_artifact(
&td,
&fx.registry,
"editor-src",
"editor",
&[
("init.lua", b"-- init\n"),
("lua/keymaps.lua", b"-- keymaps\n"),
],
);
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!mismatches
.iter()
.any(|m| m.key == artifact_key("dest", "editor-src", "editor")),
"an artifact whose deployed file contents hash to the recorded blake3 must produce \
NO mismatch, got {mismatches:?}"
);
}
#[test]
fn verify_skips_ejected_artifacts() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
let dst = seed_verifiable_artifact(
&td,
&fx.registry,
"editor-src",
"editor",
&[("init.lua", b"-- init\n")],
);
std::fs::write(dst.join("init.lua"), b"locally edited after eject").expect("tamper file");
fx.registry
.save_ejections(
"dest",
&[crate::sync::state::Ejection {
source: "editor-src".to_owned(),
artifact: "editor".to_owned(),
ejected_at: "2026-01-01T00:00:00Z".to_owned(),
}],
)
.expect("mark the artifact ejected");
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
mismatches.is_empty(),
"verify must SKIP an ejected artifact: its files are the user's now, so a divergence \
from the kept record is not a mismatch, got {mismatches:?}"
);
}
#[test]
fn verify_reports_mismatch_for_edited_deployed_file() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
let original: &[u8] = b"hello world!";
let edited: &[u8] = b"hello-world!";
assert_eq!(original.len(), edited.len());
let dst = seed_verifiable_artifact(
&td,
&fx.registry,
"editor-src",
"editor",
&[("init.lua", original), ("notes.txt", b"keep me\n")],
);
let recorded_hash = blake3::hash(original).to_hex().to_string();
std::fs::write(dst.join("init.lua"), edited).expect("edit deployed file");
let edited_hash = blake3::hash(edited).to_hex().to_string();
assert_ne!(recorded_hash, edited_hash);
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
let hit = mismatches
.iter()
.find(|m| {
m.key == artifact_key("dest", "editor-src", "editor")
&& m.path == *Path::new("init.lua")
})
.unwrap_or_else(|| {
panic!("verify must report the edited init.lua as a mismatch, got {mismatches:?}")
});
let VerifyReason::ContentMismatch { expected, actual } = &hit.reason else {
panic!(
"an edited file must be reported as a content mismatch, got {:?}",
hit.reason
)
};
assert_eq!(
*expected, recorded_hash,
"ContentMismatch.expected must be the recorded blake3 of the original content"
);
assert_eq!(
*actual, edited_hash,
"ContentMismatch.actual must be the real blake3 of the edited deployed content, \
proving verify hashes the actual bytes on disk (not size, not a stale/garbage hash)"
);
assert!(
!mismatches.iter().any(|m| m.path == *Path::new("notes.txt")),
"the untouched notes.txt must NOT be reported as a mismatch, got {mismatches:?}"
);
}
#[test]
fn verify_reports_missing_recorded_file() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
let dst = seed_verifiable_artifact(
&td,
&fx.registry,
"editor-src",
"editor",
&[("init.lua", b"-- init\n"), ("gone.lua", b"-- gone\n")],
);
std::fs::remove_file(dst.join("gone.lua")).expect("remove recorded file");
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
let hit = mismatches
.iter()
.find(|m| {
m.key == artifact_key("dest", "editor-src", "editor")
&& m.path == *Path::new("gone.lua")
})
.unwrap_or_else(|| {
panic!("verify must report the missing gone.lua as a mismatch, got {mismatches:?}")
});
assert_eq!(
hit.reason,
VerifyReason::Missing,
"a recorded file absent from disk must be reported as Missing, got {:?}",
hit.reason
);
}
fn rebuild_setup() -> (SyncFixture, TargetDir, Config, Lock) {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and records the artifact");
assert!(!out.had_failures, "premise: the seeding sync must succeed");
(fx, td, cfg, out.base_lock)
}
#[test]
fn rebuild_reconstructs_lost_record_with_same_commit_digest_and_files() {
let (fx, td, cfg, lock) = rebuild_setup();
let key = artifact_key("dest", "editor-src", "editor");
let original = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("premise: sync must have recorded the artifact");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
dst.join("init.lua").exists(),
"premise: the deployed files must remain on disk after the record is dropped"
);
fx.registry
.remove_artifact(&key)
.expect("drop the registry record");
assert!(
fx.registry
.artifact(&key)
.expect("get after remove")
.is_none(),
"premise: the record must be gone before rebuild"
);
let report = rebuild_registry(&cfg, &lock, &fx.backend, &fx.registry)
.expect("rebuild reconstructs from mirror + disk");
let rebuilt = fx
.registry
.artifact(&key)
.expect("registry get must not error")
.expect("rebuild must reconstruct the dropped record");
assert_eq!(
rebuilt.commit, original.commit,
"reconstructed record must carry the same locked commit"
);
assert_eq!(
rebuilt.digest, original.digest,
"reconstructed export digest must equal the originally-synced digest \
(recomputed by re-walking the mirror at the locked commit)"
);
let file_hashes = |rec: &ArtifactRecord| -> BTreeSet<(PathBuf, String)> {
rec.files
.iter()
.map(|f| (f.path.clone(), f.blake3.clone()))
.collect()
};
assert_eq!(
file_hashes(&rebuilt),
file_hashes(&original),
"reconstructed files must match the original path+blake3 set \
(content hashes recomputed from the mirror)"
);
assert!(
report.reconstructed.contains(&key),
"the report must list the reconstructed artifact, got {:?}",
report.reconstructed
);
assert!(
report.modified.is_empty(),
"an unmodified deploy must not be reported [modified], got {:?}",
report.modified
);
}
#[test]
fn rebuild_preserves_ejected_entries() {
let (fx, _td, cfg, lock) = rebuild_setup();
let key = artifact_key("dest", "editor-src", "editor");
fx.registry
.remove_artifact(&key)
.expect("drop the registry record");
let ejected = Ejection {
source: "editor-src".to_owned(),
artifact: "other".to_owned(),
ejected_at: "2026-01-01T00:00:00Z".to_owned(),
};
fx.registry
.save_ejections("dest", std::slice::from_ref(&ejected))
.expect("seed an ejected entry before rebuild");
rebuild_registry(&cfg, &lock, &fx.backend, &fx.registry)
.expect("rebuild succeeds with an ejected entry present");
let after = fx
.registry
.ejections("dest")
.expect("load ejected after rebuild");
assert!(
after.contains(&ejected),
"rebuild must preserve the pre-existing ejected entry, got {after:?}"
);
}
#[test]
fn rebuild_reports_modified_when_disk_content_fails_recomputed_hash() {
let (fx, td, cfg, lock) = rebuild_setup();
let key = artifact_key("dest", "editor-src", "editor");
fx.registry
.remove_artifact(&key)
.expect("drop the registry record");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let file = dst.join("init.lua");
let original = std::fs::read(&file).expect("deployed init.lua present before tamper");
let tampered: Vec<u8> = original
.iter()
.map(|b| if *b == b'i' { b'I' } else { *b })
.collect();
assert_ne!(
tampered, original,
"premise: the tamper must actually change the bytes"
);
assert_eq!(
tampered.len(),
original.len(),
"premise: the tamper must preserve byte length so size alone won't reveal it"
);
std::fs::write(&file, &tampered)
.expect("overwrite with same-length, different content so disk fails the recomputed hash");
let report = rebuild_registry(&cfg, &lock, &fx.backend, &fx.registry)
.expect("rebuild must not error on a content mismatch");
assert!(
report.modified.contains(&key),
"a managed artifact whose disk content fails the recomputed hash must be \
reported [modified], got {:?}",
report.modified
);
}
#[test]
fn rebuild_reports_foreign_artifact_dir_with_no_config_match() {
let (fx, td, cfg, lock) = rebuild_setup();
let foreign_dir = td.target_path().join("hand-made").join("scratch");
std::fs::create_dir_all(&foreign_dir).expect("mkdir foreign artifact dir");
std::fs::write(foreign_dir.join("notes.txt"), b"hand-written\n").expect("write foreign file");
let report = rebuild_registry(&cfg, &lock, &fx.backend, &fx.registry)
.expect("rebuild must not error in the presence of a foreign dir");
assert!(
report.foreign.iter().any(|p| p.ends_with("hand-made")),
"an on-disk top-level entry with no published-key match must be reported [foreign] \
(the scan compares top-level entries against the published-key set), got {:?}",
report.foreign
);
let managed = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert!(
!report
.foreign
.iter()
.any(|p| { p == &managed || p.ends_with("editor") || p.starts_with(&managed) }),
"the legit managed artifact ({}) must NOT be reported [foreign]; \
only unmanaged on-disk dirs may appear, got {:?}",
managed.display(),
report.foreign
);
}
#[test]
fn rebuild_spares_user_owned_top_level_dotfile_from_foreign() {
let (fx, td, cfg, lock) = rebuild_setup();
let user_dot = td.target_path().join(".cache");
std::fs::create_dir_all(&user_dot).expect("mkdir user dotdir");
std::fs::write(user_dot.join("blob"), b"user-owned\n").expect("write user file");
let report = rebuild_registry(&cfg, &lock, &fx.backend, &fx.registry)
.expect("rebuild must not error in the presence of a user dotdir");
assert!(
!report.foreign.iter().any(|p| p.ends_with(".cache")),
"a user-owned top-level dotfile must NOT be reported foreign by rebuild-registry; \
an orphaned managed dotfile is reclaimed by `sync --prune` (SMR-033), not flagged here; \
got {:?}",
report.foreign
);
}
#[expect(clippy::unwrap_used, reason = "fixture setup fails loudly in tests")]
fn build_worktree(root_sub: Option<&str>) -> TempDir {
let td = TempDir::new().unwrap();
let base = match root_sub {
Some(sub) => td.path().join(sub),
None => td.path().to_path_buf(),
};
std::fs::create_dir_all(&base).unwrap();
for art in ["alpha", "zeta", "uncommitted"] {
std::fs::create_dir_all(base.join(art)).unwrap();
std::fs::write(base.join(art).join("file.txt"), b"x\n").unwrap();
}
std::fs::create_dir_all(base.join(".hidden")).unwrap();
std::fs::write(base.join(".hidden").join("secret"), b"s\n").unwrap();
std::fs::write(base.join("loose.txt"), b"loose\n").unwrap();
td
}
#[test]
fn worktree_scan_returns_sorted_leaves_including_dotdirs_and_loose_files() {
let wt = build_worktree(None);
let found = crate::sync::discover::discover_working_tree_leaves(wt.path(), None, false)
.expect("scanning an existing working tree must succeed");
assert_eq!(
found,
vec![
".hidden/secret".to_string(),
"alpha/file.txt".to_string(),
"loose.txt".to_string(),
"uncommitted/file.txt".to_string(),
"zeta/file.txt".to_string(),
],
"the disk scan must return every leaf, sorted and root-relative; the never-added \
`uncommitted` leaf proves this is a disk scan, not an ODB walk"
);
}
#[test]
fn worktree_scan_honors_root_subdir() {
let wt = build_worktree(Some("languages"));
let found = crate::sync::discover::discover_working_tree_leaves(
wt.path(),
Some(Path::new("languages")),
false,
)
.expect("scanning <git>/<root> must succeed");
assert_eq!(
found,
vec![
".hidden/secret".to_string(),
"alpha/file.txt".to_string(),
"loose.txt".to_string(),
"uncommitted/file.txt".to_string(),
"zeta/file.txt".to_string(),
],
"with root set, leaves nested under <git>/languages must be discovered root-relative"
);
let direct = crate::sync::discover::discover_working_tree_leaves(wt.path(), None, false)
.expect("scanning the git root itself must succeed");
assert_eq!(
direct,
vec![
"languages/.hidden/secret".to_string(),
"languages/alpha/file.txt".to_string(),
"languages/loose.txt".to_string(),
"languages/uncommitted/file.txt".to_string(),
"languages/zeta/file.txt".to_string(),
],
"without root, the top-level `languages` dir is part of every leaf path"
);
}
#[test]
fn worktree_scan_missing_path_errors() {
let parent = TempDir::new().expect("hermetic parent for the missing path");
let missing = parent.path().join("phora-link-source-absent");
assert!(
!missing.exists(),
"premise: the child path under the tempdir must not exist"
);
let err = crate::sync::discover::discover_working_tree_leaves(&missing, None, false)
.expect_err("an absent local path must be a clear error, not an empty list");
let msg = err.to_string().to_lowercase();
assert!(
msg.contains("phora-link-source-absent")
|| msg.contains("not found")
|| msg.contains("no such file"),
"the error should point at the missing path, got: {msg}"
);
}
#[test]
fn worktree_scan_missing_root_errors() {
let wt = build_worktree(None);
let err = crate::sync::discover::discover_working_tree_leaves(
wt.path(),
Some(Path::new("absent-root")),
false,
)
.expect_err("a missing root subdir must error, not silently yield nothing");
let msg = err.to_string().to_lowercase();
assert!(
msg.contains("absent-root")
|| msg.contains("not found")
|| msg.contains("no such file")
|| msg.contains("root"),
"the error should name the missing root, got: {msg}"
);
}
fn config_link_source_one_target(source: &str, link_git: &Path, target_path: &Path) -> Config {
config_link_source_one_target_with_layout(source, link_git, target_path, "by-source")
}
fn config_link_source_one_target_with_layout(
source: &str,
link_git: &Path,
target_path: &Path,
layout: &str,
) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n",
link_git.display(),
target_path.display(),
);
Config::parse(&toml).expect("link-source config parses")
}
fn config_link_source_two_targets(
source: &str,
link_git: &Path,
first_target: &Path,
second_target: &Path,
) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.first]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"by-source\"\n\n\
[targets.second]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"by-source\"\n",
link_git.display(),
first_target.display(),
second_target.display(),
);
Config::parse(&toml).expect("shared link-source config parses")
}
fn link_lock(source: &str, link_git: &Path) -> Lock {
Lock {
version: 1,
sources: vec![LockedSource {
name: source.to_owned(),
git: link_git.to_string_lossy().into_owned(),
resolved: "link".to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
config_digest: "blake3:link".to_owned(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
}
}
#[test]
fn rebuild_discovers_link_source_from_disk_never_via_odb() {
let wt = build_worktree(None);
let td = TargetDir::new();
let cfg = config_link_source_one_target("linked-src", wt.path(), &td.target_path());
let lock = link_lock("linked-src", wt.path());
let counting = CountingBackend::new({
let git_dir = TempDir::new().expect("backend mirror dir");
Box::leak(Box::new(GitBackend::new(git_dir.path().to_path_buf())))
});
let report = rebuild_registry(&cfg, &lock, &counting, &fx_registry())
.expect("rebuild over a link source must succeed using the disk scan");
assert_eq!(
counting.discover_count(),
0,
"a Link source must be discovered from disk in rebuild_registry; \
the ODB backend's list_source_leaves must NOT be called (review C2)"
);
let names: BTreeSet<String> = report
.reconstructed
.iter()
.map(|k| k.artifact.clone())
.collect();
assert!(
names.contains("alpha") && names.contains("zeta"),
"the link source's working-tree artifacts must be reconstructed, got {names:?}"
);
}
#[test]
fn rebuild_resolves_shared_link_source_once_for_multiple_targets() {
let wt = build_worktree(None);
let first = TargetDir::new();
let second = TargetDir::new();
let cfg = config_link_source_two_targets(
"linked-src",
wt.path(),
&first.target_path(),
&second.target_path(),
);
let lock = link_lock("linked-src", wt.path());
let backend = fx_backend();
let counting = CountingBackend::new(&backend);
let registry = fx_registry();
let report = rebuild_registry(&cfg, &lock, &counting, ®istry)
.expect("rebuild over one shared link source must succeed");
for target in ["first", "second"] {
let key = artifact_key(target, "linked-src", "alpha");
assert!(
report.reconstructed.contains(&key),
"the shared source must reconstruct alpha for target {target}, got {:?}",
report.reconstructed
);
let record = registry
.artifact(&key)
.expect("registry read")
.unwrap_or_else(|| panic!("rebuild must record alpha for target {target}"));
assert_eq!(
record.commit, "link",
"each target must retain the shared link source's effective-ref map entry"
);
assert!(
record.linked,
"each target must retain link materialization semantics"
);
}
assert_eq!(
counting.resolve_count(),
1,
"registry rebuild must resolve and capture one shared worktree snapshot once, even when \
that source is bound by multiple targets"
);
}
fn fx_registry() -> FileStateStore {
let state = TempDir::new().expect("registry state dir");
let reg = FileStateStore::open(state.path().to_path_buf()).expect("open registry");
std::mem::forget(state);
reg
}
#[test]
fn verify_skips_linked_record_even_with_stray_manifest_file() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
let stray = ArtifactRecord {
version: 1,
key: artifact_key("dest", "editor-src", "editor"),
source: "editor-src".to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
projected_at: "2026-06-08T12:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("ghost.lua"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 7,
mtime: 1_700_000_000,
blake3: blake3::hash(b"phantom").to_hex().to_string(),
}],
directories: None,
linked: true,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
fx.registry
.put_artifact(&stray)
.expect("seed a linked record carrying a stray manifest file");
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!mismatches
.iter()
.any(|m| m.key == artifact_key("dest", "editor-src", "editor")),
"verify must SKIP a linked record entirely (record.linked short-circuit), never \
reading its files — even a stray manifest entry pointing at an absent path must \
produce NO mismatch, got {mismatches:?}"
);
}
#[cfg(unix)]
#[test]
fn verify_skips_linked_record_over_edited_symlink_target() {
use std::os::unix::fs::symlink;
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = verify_config(&td, &fx);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
std::fs::create_dir_all(dst.parent().expect("dst parent")).expect("mkdir dst parent");
let live = fx.src.path().join("editor");
symlink(&live, &dst).expect("deploy the linked artifact as a symlink");
let linked = ArtifactRecord {
version: 1,
key: artifact_key("dest", "editor-src", "editor"),
source: "editor-src".to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
projected_at: "2026-06-08T12:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: true,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
fx.registry
.put_artifact(&linked)
.expect("seed linked record");
std::fs::write(live.join("init.lua"), b"-- EDITED LIVE\n")
.expect("edit the symlink target content");
let mismatches = verify(&cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!mismatches
.iter()
.any(|m| m.key == artifact_key("dest", "editor-src", "editor")),
"a linked artifact is outside the content-integrity model: editing the live symlink \
target must NOT surface as a verify mismatch, got {mismatches:?}"
);
}
#[cfg(unix)]
#[test]
fn rebuild_keeps_linked_and_excludes_symlink_from_foreign() {
use std::os::unix::fs::symlink;
let wt = build_worktree(None);
let td = TargetDir::new();
let cfg = config_link_source_one_target("linked-src", wt.path(), &td.target_path());
let lock = link_lock("linked-src", wt.path());
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let dst = td.artifact_dst(&by_source, "linked-src", "alpha");
std::fs::create_dir_all(dst.parent().expect("dst parent")).expect("mkdir dst parent");
symlink(wt.path().join("alpha"), &dst).expect("deploy the alpha artifact as a symlink");
let registry = fx_registry();
let report = rebuild_registry(&cfg, &lock, &fx_backend(), ®istry)
.expect("rebuild over a link source must succeed");
let record = registry
.artifact(&artifact_key("dest", "linked-src", "alpha"))
.expect("registry read")
.expect("rebuild must reconstruct the alpha record");
assert!(
record.linked,
"rebuild must reconstruct a Link source's record as linked=true (no hashing), \
got linked={}",
record.linked
);
assert!(
!report
.foreign
.iter()
.any(|p| p == &dst || p.ends_with("alpha")),
"the deployed linked SYMLINK must NOT be classified foreign — scan_foreign's \
no-follow is_dir() skips it; got {:?}",
report.foreign
);
}
#[cfg(unix)]
#[test]
fn prune_removes_stale_linked_symlink_without_following_it() {
use std::os::unix::fs::symlink;
let wt = build_worktree(None);
let td = TargetDir::new();
let cfg = config_link_source_one_target("linked-src", wt.path(), &td.target_path());
let target_dir = wt.path().join("alpha");
let inside = target_dir.join("file.txt");
assert!(
inside.exists(),
"premise: the symlink target file must exist pre-prune"
);
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let dst = td.artifact_dst(&by_source, "linked-src", "stale");
std::fs::create_dir_all(dst.parent().expect("dst parent")).expect("mkdir dst parent");
symlink(&target_dir, &dst).expect("plant a stale linked symlink at the destination");
let registry = fx_registry();
registry
.put_artifact(&ArtifactRecord {
version: 1,
key: artifact_key("dest", "linked-src", "stale"),
source: "linked-src".to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
projected_at: "2026-06-08T12:00:00Z".to_owned(),
layout: "by-source".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: true,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
})
.expect("seed the orphaned linked record");
let parsed = cfg.parsed_sources().expect("sources parse");
let commits = one_commit(&parsed, "linked-src", "link");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let protected = test_protected(&std::env::temp_dir());
let backend = fx_backend();
let resolved_sources = resolved_worktree_map(&backend, "linked-src", wt.path());
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&backend,
&commits,
&resolved_sources,
)
.expect("projection builds");
prune_projected(&projection, &cfg, ®istry, &protected)
.expect("prune must remove the orphaned linked artifact");
assert!(
std::fs::symlink_metadata(&dst).is_err(),
"prune must unlink the stale symlink at {}; it must no longer exist",
dst.display()
);
assert!(
target_dir.is_dir() && inside.exists(),
"prune must unlink the symlink ONLY (no-follow) — the working-tree target dir and the \
file inside it must survive, never removed through the link"
);
assert!(
registry
.artifact(&artifact_key("dest", "linked-src", "stale"))
.expect("registry read")
.is_none(),
"the orphaned linked record must be removed from the registry"
);
}
#[cfg(unix)]
#[test]
fn prune_drops_a_stale_dir_record_once_the_plan_flips_leaf_granular() {
use std::os::unix::fs::symlink;
let wt = TempDir::new().expect("worktree tempdir");
std::fs::create_dir_all(wt.path().join("alpha")).expect("mkdir alpha");
std::fs::write(wt.path().join("alpha").join("a.md"), b"keep\n").expect("write alpha/a.md");
std::fs::write(wt.path().join("alpha").join("secret.md"), b"drop\n")
.expect("write alpha/secret.md");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.linked-src]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\
include = [\"alpha/a.md\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"linked-src\"]\nlayout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link within-dir-exclude config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let dir_dst = td.artifact_dst(&by_source, "linked-src", "alpha");
std::fs::create_dir_all(dir_dst.parent().expect("dst parent")).expect("mkdir dst parent");
symlink(wt.path().join("alpha"), &dir_dst).expect("deploy the stale `alpha` dir as a symlink");
let registry = fx_registry();
registry
.put_artifact(&ArtifactRecord {
version: 1,
key: artifact_key("dest", "linked-src", "alpha"),
source: "linked-src".to_owned(),
commit: "link".to_owned(),
digest: "link:".to_owned(),
projected_at: "2026-06-08T12:00:00Z".to_owned(),
layout: "by-source".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: true,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
})
.expect("seed the stale dir-granular record");
let parsed = cfg.parsed_sources().expect("sources parse");
let commits = one_commit(&parsed, "linked-src", "link");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let protected = test_protected(&std::env::temp_dir());
let backend = fx_backend();
let resolved_sources = resolved_worktree_map(&backend, "linked-src", wt.path());
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&backend,
&commits,
&resolved_sources,
)
.expect("projection builds");
prune_projected(&projection, &cfg, ®istry, &protected).expect("prune runs");
assert!(
std::fs::symlink_metadata(&dir_dst).is_ok(),
"the plan expects `alpha/a.md` UNDER the stale `alpha` path, so prune must NOT delete it: \
removing the symlink (or, in the real post-deploy flow, the dir holding the live leaf) \
would destroy a live artifact / corrupt the source it points at — it vanished from {}",
dir_dst.display()
);
assert!(
registry
.artifact(&artifact_key("dest", "linked-src", "alpha"))
.expect("registry read")
.is_none(),
"the stale dir-granular `alpha` RECORD must still be reconciled out once the plan resolves \
leaf-granular, even though its on-disk path is left for the writer to reconcile"
);
}
fn seed_two_leaf_dir_repo() -> (TempDir, TempDir, GitBackend, String, String) {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/a.md"), b"alpha\n").expect("write a.md");
std::fs::write(p.join("editor/b.md"), b"beta\n").expect("write b.md");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let commit = resolve_git_source(
&backend,
"ed",
&url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
(src, git_dir, backend, url, commit)
}
fn leaf_record(target: &str, identity: &str, key: &str) -> ArtifactRecord {
ArtifactRecord {
version: 1,
key: artifact_key(target, identity, key),
source: "ed".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:leaf".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "by-source".to_owned(),
kind: RecordKind::File,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
}
}
fn dir_record(target: &str, identity: &str, key: &str) -> ArtifactRecord {
let mut record = leaf_record(target, identity, key);
record.kind = RecordKind::Dir;
record.digest = "blake3:dir".to_owned();
record
}
fn prune_one(
cfg: &Config,
backend: &GitBackend,
registry: &FileStateStore,
commit: &str,
) -> Result<()> {
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(cfg, &parsed).expect("remotes resolve");
let commits = one_commit(&parsed, "ed", commit);
let resolved_sources = resolved_git_map(backend, "ed", &remotes["ed"], commit);
let protected = test_protected(&std::env::temp_dir());
let projection =
project_workspace(cfg, &parsed, &remotes, backend, &commits, &resolved_sources)?;
prune_projected(&projection, cfg, registry, &protected)
}
#[test]
fn prune_reconciles_a_stale_dir_record_without_destroying_a_live_leaf_under_it() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("narrowing-take config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let leaf_dst = td.artifact_dst(&by_source, "ed", "editor/a.md");
std::fs::create_dir_all(leaf_dst.parent().expect("leaf parent")).expect("mkdir leaf parent");
std::fs::write(&leaf_dst, b"alpha\n").expect("write live leaf");
let registry = fx_registry();
registry
.put_artifact(&dir_record("dest", "ed", "editor"))
.expect("seed stale dir record");
registry
.put_artifact(&leaf_record("dest", "ed", "editor/a.md"))
.expect("seed live leaf record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
leaf_dst.exists(),
"PROBE: the live taken leaf editor/a.md must SURVIVE prune; pruning the stale `editor` \
dir record (remove_dir_all) destroyed it at {}",
leaf_dst.display()
);
drop(src);
}
#[cfg(unix)]
#[test]
fn prune_reconciles_a_stale_leaf_record_without_traversing_a_collapsed_symlink_into_the_source() {
use std::os::unix::fs::symlink;
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("collapse config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let dir_dst = td.artifact_dst(&by_source, "ed", "editor");
std::fs::create_dir_all(dir_dst.parent().expect("dst parent")).expect("mkdir dst parent");
symlink(src.path().join("editor"), &dir_dst).expect("deploy collapsed editor symlink");
let registry = fx_registry();
registry
.put_artifact(&dir_record("dest", "ed", "editor"))
.expect("seed live collapsed dir record");
registry
.put_artifact(&leaf_record("dest", "ed", "editor/a.md"))
.expect("seed stale per-leaf record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
src.path().join("editor/a.md").exists(),
"PROBE: pruning stale `editor/a.md` must NOT traverse the collapsed `editor` symlink and \
delete the SOURCE file; the source working tree was corrupted"
);
drop(src);
}
#[test]
fn prune_flips_collapse_to_per_leaf_pruning_the_stale_dir_record() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("narrowing-take config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let dir_dst = td.artifact_dst(&by_source, "ed", "editor");
std::fs::create_dir_all(&dir_dst).expect("mkdir stale dir dst");
std::fs::write(dir_dst.join("a.md"), b"alpha\n").expect("write stale dir file");
let registry = fx_registry();
registry
.put_artifact(&dir_record("dest", "ed", "editor"))
.expect("seed stale dir record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
registry
.artifact(&artifact_key("dest", "ed", "editor"))
.expect("registry read")
.is_none(),
"the stale collapsed `editor` dir RECORD is an EXACT-match orphan once the plan resolves \
leaf-granular to `editor/a.md`; prune must reconcile it out of the registry"
);
assert!(
dir_dst.join("a.md").exists(),
"the live taken leaf editor/a.md under the stale `editor` dir must SURVIVE: prune drops \
the stale record but must not remove a path holding a live expected artifact"
);
drop(src);
}
#[test]
fn prune_flips_per_leaf_to_collapse_pruning_the_stale_leaf_records() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("collapse config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
for leaf in ["editor/a.md", "editor/b.md"] {
let dst = td.artifact_dst(&by_source, "ed", leaf);
std::fs::create_dir_all(dst.parent().expect("leaf parent")).expect("mkdir leaf parent");
std::fs::write(&dst, b"stale\n").expect("write stale leaf");
}
let registry = fx_registry();
registry
.put_artifact(&leaf_record("dest", "ed", "editor/a.md"))
.expect("seed stale a.md record");
registry
.put_artifact(&leaf_record("dest", "ed", "editor/b.md"))
.expect("seed stale b.md record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
for leaf in ["editor/a.md", "editor/b.md"] {
assert!(
registry
.artifact(&artifact_key("dest", "ed", leaf))
.expect("registry read")
.is_none(),
"the stale per-leaf record `{leaf}` is an EXACT-match orphan once the plan collapses \
to dir `editor`; it must be pruned"
);
}
drop(src);
}
#[test]
fn prune_narrowing_take_prunes_the_untaken_leaf_keeps_the_taken_one() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("narrowing-take config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let untaken_dst = td.artifact_dst(&by_source, "ed", "editor/b.md");
std::fs::create_dir_all(untaken_dst.parent().expect("parent")).expect("mkdir parent");
std::fs::write(&untaken_dst, b"beta\n").expect("write untaken leaf");
let registry = fx_registry();
registry
.put_artifact(&leaf_record("dest", "ed", "editor/a.md"))
.expect("seed taken record");
registry
.put_artifact(&leaf_record("dest", "ed", "editor/b.md"))
.expect("seed untaken record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
registry
.artifact(&artifact_key("dest", "ed", "editor/a.md"))
.expect("registry read")
.is_some(),
"the still-taken leaf `editor/a.md` must survive prune"
);
assert!(
registry
.artifact(&artifact_key("dest", "ed", "editor/b.md"))
.expect("registry read")
.is_none(),
"the now-untaken leaf `editor/b.md` is an orphan and must be pruned"
);
assert!(
!untaken_dst.exists(),
"the untaken leaf's on-disk file must be removed"
);
drop(src);
}
#[test]
fn prune_is_instance_granular_across_two_aliases_of_one_source() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
one = {{ source = \"ed\", take = [\"editor/b.md\"] }},\n\
two = {{ source = \"ed\", take = [\"editor/a.md\"] }},\n\
}}\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-alias divergent-take config parses");
let by_source = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
let one_stale = td.artifact_dst(&by_source, "one", "editor/a.md");
std::fs::create_dir_all(one_stale.parent().expect("parent")).expect("mkdir parent");
std::fs::write(&one_stale, b"alpha\n").expect("write one's stale a.md");
let registry = fx_registry();
registry
.put_artifact(&leaf_record("dest", "one", "editor/a.md"))
.expect("seed one's stale a.md (now untaken under `one`)");
registry
.put_artifact(&leaf_record("dest", "two", "editor/a.md"))
.expect("seed two's a.md (still taken under `two`)");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
registry
.artifact(&artifact_key("dest", "one", "editor/a.md"))
.expect("registry read")
.is_none(),
"alias `one` no longer takes `editor/a.md`; ITS record is an orphan and must be pruned"
);
assert!(
registry
.artifact(&artifact_key("dest", "two", "editor/a.md"))
.expect("registry read")
.is_some(),
"alias `two` still takes its identically-named `editor/a.md`; instance-granular buckets \
must keep it — pruning `one` must NOT touch `two`"
);
drop(src);
}
#[test]
fn prune_keeps_a_foreign_orphan_dir_that_ancestors_a_live_leaf_of_another_binding() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("flat narrowing-take config parses");
let orphan_dir = td.artifact_dst(&flat_layout(), "gone-src", "editor");
std::fs::create_dir_all(&orphan_dir).expect("mkdir orphan dir");
let sibling = orphan_dir.join("legacy.txt");
std::fs::write(&sibling, b"legacy\n").expect("write orphan sibling");
let registry = fx_registry();
registry
.put_artifact(&ArtifactRecord {
version: 1,
key: artifact_key("dest", "gone-src", "editor"),
source: "gone-src".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:orphan".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("legacy.txt"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 7,
mtime: 1_700_000_000,
blake3: "blake3:orphan".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
})
.expect("seed foreign orphan dir record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
sibling.exists(),
"the cross-binding overlap skips the physical delete, so the orphan dir's sibling must \
SURVIVE at {}",
sibling.display()
);
assert!(
registry
.artifact(&artifact_key("dest", "gone-src", "editor"))
.expect("registry read")
.is_some(),
"UNTRACKED-FILE INVARIANT: a different binding's live leaf sits UNDER this orphan dir, but \
that leaf's record does not track the dir's sibling; the file stays on disk, so the \
orphan record MUST be kept or the sibling becomes untracked"
);
drop(src);
}
#[test]
fn prune_keeps_a_foreign_orphan_leaf_nested_under_a_live_collapsed_dir_of_another_binding() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("flat collapse config parses");
let orphan_leaf = td.artifact_dst(&flat_layout(), "gone-src", "editor/legacy.txt");
std::fs::create_dir_all(orphan_leaf.parent().expect("leaf parent")).expect("mkdir leaf parent");
std::fs::write(&orphan_leaf, b"legacy\n").expect("write orphan leaf");
let registry = fx_registry();
registry
.put_artifact(&ArtifactRecord {
version: 1,
key: artifact_key("dest", "gone-src", "editor/legacy.txt"),
source: "gone-src".to_owned(),
commit: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".to_owned(),
digest: "blake3:orphan".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::File,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
})
.expect("seed foreign orphan leaf record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
orphan_leaf.exists(),
"the overlap under the live collapsed dir skips the delete; the foreign orphan leaf must \
SURVIVE at {}",
orphan_leaf.display()
);
assert!(
registry
.artifact(&artifact_key("dest", "gone-src", "editor/legacy.txt"))
.expect("registry read")
.is_some(),
"UNTRACKED-FILE INVARIANT: the live collapsed `editor` dir belongs to ANOTHER binding and \
does not track this foreign leaf; kept on disk, its record MUST be kept so it stays tracked"
);
drop(src);
}
fn fx_backend() -> GitBackend {
let git_dir = TempDir::new().expect("backend mirror dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
std::mem::forget(git_dir);
backend
}
fn base_copy_source(source: &str, git: &Path) -> Config {
let toml = format!(
"version = 1\n\n[sources.{source}]\ngit = \"{}\"\nbranch = \"main\"\n",
git.display(),
);
Config::parse(&toml).expect("base source without deploy parses")
}
fn local_link_overlay(source: &str, git: &Path, target_path: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"by-source\"\n",
git.display(),
target_path.display(),
);
Config::parse(&toml).expect("local link overlay parses")
}
fn effective_of(base: &Config, local: &Config) -> Config {
merge_configs(base.clone(), Some(local.clone()))
}
#[test]
fn base_link_over_local_path_now_passes_the_guard() {
let wt = build_worktree(None);
let td = TargetDir::new();
let base = config_link_source_one_target("base-linked", wt.path(), &td.target_path());
let base_parsed = base.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&base, &base_parsed).expect("remotes resolve");
let warnings = validate_link_mode(&base, &base_parsed, &remotes).expect(
"deploy = \"link\" committed in the base config over a LOCAL path must now be \
accepted, not rejected as a committed-config violation",
);
assert!(
warnings.iter().all(|w| w.contains("base-linked")),
"any portability warning emitted must name the source `base-linked`, got: {warnings:?}"
);
}
#[test]
fn remote_git_with_link_is_rejected_naming_the_source() {
let td = TargetDir::new();
let remote = std::path::Path::new("https://github.com/me/dotfiles.git");
let base = base_copy_source("remote-linked", remote);
let local = local_link_overlay("remote-linked", remote, &td.target_path());
let effective = effective_of(&base, &local);
assert_eq!(
parsed_of(&effective, "remote-linked").deploy_mode(),
DeployMode::Link,
"premise: the overlay must make the effective mode Link"
);
let parsed = effective.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&effective, &parsed).expect("remotes resolve");
let Err(err) = validate_link_mode(&base, &parsed, &remotes) else {
panic!(
"deploy = \"link\" on a remote-URL git must be rejected (a remote has no \
working tree to symlink), even when the link is overlay-only"
);
};
assert!(
err.to_string().contains("remote-linked"),
"the local-path guard error must name the offending source `remote-linked`, got: {err}"
);
}
#[test]
fn remote_link_in_base_config_still_errors_naming_the_source() {
let td = TargetDir::new();
let remote = std::path::Path::new("https://github.com/me/dotfiles.git");
let base = config_link_source_one_target("base-remote-link", remote, &td.target_path());
let parsed = base.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&base, &parsed).expect("remotes resolve");
let Err(err) = validate_link_mode(&base, &parsed, &remotes) else {
panic!(
"deploy = \"link\" on a remote-URL git must be rejected even when committed in \
the base config; a remote has no working tree to symlink"
);
};
assert!(
err.to_string().contains("base-remote-link")
&& err.to_string().contains("local filesystem path"),
"the local-path guard error must name the source and steer to a local path, got: {err}"
);
}
fn local_copy_overlay(source: &str, git: &Path, target_path: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"copy\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"by-source\"\n",
git.display(),
target_path.display(),
);
Config::parse(&toml).expect("local copy overlay parses")
}
#[test]
fn base_link_downgraded_to_copy_locally_passes_with_no_warning() {
let wt = build_worktree(None);
let td = TargetDir::new();
let base = config_link_source_one_target("committed-link", wt.path(), &td.target_path());
let local = local_copy_overlay("committed-link", wt.path(), &td.target_path());
let effective = effective_of(&base, &local);
assert_eq!(
parsed_of(&effective, "committed-link").deploy_mode(),
DeployMode::Copy,
"premise: the overlay must downgrade the effective mode to Copy"
);
let parsed = effective.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&effective, &parsed).expect("remotes resolve");
let warnings = validate_link_mode(&base, &parsed, &remotes)
.expect("a base link locally downgraded to copy must pass validation, not error");
assert!(
warnings.is_empty(),
"no portability warning may fire when the EFFECTIVE mode is Copy, even though \
the source is base-defined over an absolute path, got: {warnings:?}"
);
}
#[test]
fn link_only_in_local_overlay_passes_the_guard() {
let wt = build_worktree(None);
let td = TargetDir::new();
let base = base_copy_source("dev-src", wt.path());
let local = local_link_overlay("dev-src", wt.path(), &td.target_path());
let effective = effective_of(&base, &local);
assert_eq!(
parsed_of(&effective, "dev-src").deploy_mode(),
DeployMode::Link,
"premise: the overlay must make the effective mode Link"
);
let parsed = effective.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&effective, &parsed).expect("remotes resolve");
let _warnings = validate_link_mode(&base, &parsed, &remotes).expect(
"a link confined to phora.local.toml over a local path must pass the local-path guard",
);
}
fn empty_base() -> Config {
Config::parse("version = 1\n").expect("empty base parses")
}
#[test]
fn base_defined_link_over_absolute_path_warns_exactly_once() {
let wt = build_worktree(None);
let td = TargetDir::new();
assert!(
wt.path().is_absolute(),
"premise: the link source path must be absolute to trigger the portability warning"
);
let base = config_link_source_one_target("abs-link", wt.path(), &td.target_path());
let parsed = base.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&base, &parsed).expect("remotes resolve");
let warnings = validate_link_mode(&base, &parsed, &remotes)
.expect("a base link over an absolute local path is valid (non-fatal warning only)");
assert_eq!(
warnings.len(),
1,
"a base-defined link over an absolute path must emit EXACTLY one portability \
warning (no double-emit across the two validation passes), got: {warnings:?}"
);
assert!(
warnings[0].contains("abs-link"),
"the portability warning must name the source `abs-link`, got: {:?}",
warnings[0]
);
let control = validate_link_mode(&empty_base(), &parsed, &remotes)
.expect("the same effective link is valid against an empty base too");
assert!(
control.is_empty(),
"distinguishing trace: with the SAME effective link but no base-defined source, \
the warning must NOT fire — proving the trigger is base provenance, not incidental \
Vec length, got: {control:?}"
);
}
#[test]
fn local_overlay_adds_link_to_base_source_warns_exactly_once() {
let wt = build_worktree(None);
let td = TargetDir::new();
assert!(
wt.path().is_absolute(),
"premise: the source path must be absolute to trigger the portability warning"
);
let base = base_copy_source("overlay-link", wt.path());
let local = local_link_overlay("overlay-link", wt.path(), &td.target_path());
let effective = effective_of(&base, &local);
assert_eq!(
parsed_of(&effective, "overlay-link").deploy_mode(),
DeployMode::Link,
"premise: the overlay must make the effective mode Link"
);
let parsed = effective.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&effective, &parsed).expect("remotes resolve");
let warnings = validate_link_mode(&base, &parsed, &remotes)
.expect("link added by the overlay onto a base-defined local source is valid");
assert_eq!(
warnings.len(),
1,
"a base-DEFINED source (even with deploy == None) whose effective mode is Link \
over an absolute path must warn exactly once, got: {warnings:?}"
);
assert!(
warnings[0].contains("overlay-link"),
"the portability warning must name the source `overlay-link`, got: {:?}",
warnings[0]
);
let control = validate_link_mode(&empty_base(), &parsed, &remotes)
.expect("same effective link is valid against an empty base");
assert!(
control.is_empty(),
"distinguishing trace: drop the source from the base and the warning must vanish, \
pinning base-defined-source-presence as the trigger, got: {control:?}"
);
}
#[test]
fn link_source_only_in_local_overlay_does_not_warn() {
let wt = build_worktree(None);
let td = TargetDir::new();
assert!(
wt.path().is_absolute(),
"premise: an absolute path would warn IF the source were base-defined; it is not"
);
let base = empty_base();
let local = local_link_overlay("local-only-link", wt.path(), &td.target_path());
let effective = effective_of(&base, &local);
assert_eq!(
parsed_of(&effective, "local-only-link").deploy_mode(),
DeployMode::Link,
"premise: the effective mode is Link over an absolute path"
);
assert!(
!base.sources.contains_key("local-only-link"),
"premise: the source must NOT be base-defined"
);
let parsed = effective.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&effective, &parsed).expect("remotes resolve");
let warnings = validate_link_mode(&base, &parsed, &remotes)
.expect("a link source confined to the overlay over a local path is valid");
assert!(
warnings.is_empty(),
"a source defined ONLY in phora.local.toml is intentional and machine-specific; \
it must emit NO portability warning even over an absolute path, got: {warnings:?}"
);
let provenance_flip = validate_link_mode(&local, &parsed, &remotes)
.expect("same effective link is valid against a base that DOES define the source");
assert_eq!(
provenance_flip.len(),
1,
"distinguishing trace: feed a base that DOES define the source and the warning \
appears — confirming the empty-base result is provenance-driven, got: {provenance_flip:?}"
);
}
fn config_link_source_dot_git(source: &str, target_path: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\ngit = \".\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("dot-git link-source config parses")
}
#[test]
fn base_link_over_non_absolute_local_path_emits_no_warning() {
let td = TargetDir::new();
let base = config_link_source_dot_git("dot-link", &td.target_path());
let parsed = base.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&base, &parsed).expect("remotes resolve");
assert!(
!std::path::Path::new(&remotes["dot-link"]).is_absolute(),
"premise: the resolved remote for `git = \".\"` must be NON-absolute so this \
test exercises the is_absolute == false branch, got: {:?}",
remotes["dot-link"]
);
assert_eq!(
parsed_of(&base, "dot-link").deploy_mode(),
DeployMode::Link,
"premise: the effective deploy mode must be Link"
);
let warnings = validate_link_mode(&base, &parsed, &remotes)
.expect("a base-defined link over a LOCAL non-absolute path is valid and non-fatal");
assert!(
warnings.is_empty(),
"the portability warning is gated on an ABSOLUTE path; a base-defined link over a \
NON-absolute local path must emit ZERO warnings, got: {warnings:?}"
);
let wt = build_worktree(None);
assert!(
wt.path().is_absolute(),
"premise: control path must be absolute"
);
let abs_base = config_link_source_one_target("dot-link", wt.path(), &td.target_path());
let abs_parsed = abs_base.parsed_sources().expect("sources parse");
let abs_remotes = resolved_remotes(&abs_base, &abs_parsed).expect("remotes resolve");
let abs_warnings = validate_link_mode(&abs_base, &abs_parsed, &abs_remotes)
.expect("a base link over an absolute local path is valid (warning only)");
assert_eq!(
abs_warnings.len(),
1,
"distinguishing trace: flip the SAME base-defined link source to an ABSOLUTE path \
and the warning fires exactly once, pinning is_absolute as the gate, got: {abs_warnings:?}"
);
}
fn base_link_overlay_pair(source: &str, git: &Path, target_path: &Path) -> (Config, Config) {
let base = base_copy_source(source, git);
let local = local_link_overlay(source, git, target_path);
(base, local)
}
fn link_dst(target_path: &Path, source: &str, artifact: &str) -> PathBuf {
let layout = crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
};
target_path.join(layout.artifact_path(source, artifact))
}
#[test]
fn linked_artifact_deploys_as_symlink_to_working_tree() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("link-source sync runs to deploy");
assert!(
!out.had_failures,
"deploying a link source over a real local working tree must not fail"
);
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let meta = std::fs::symlink_metadata(&dst)
.expect("the linked artifact must materialize at the destination");
assert!(
meta.file_type().is_symlink(),
"a link-mode artifact must be deployed as a SYMLINK, not a copied directory"
);
let want = canonical_fixture_target(&fx.src.path().join("editor"));
let got = std::fs::read_link(&dst).expect("the deployed symlink must be readable");
assert_eq!(
got, want,
"the symlink must point to the ABSOLUTE working-tree path <source>/<artifact>"
);
std::fs::write(fx.src.path().join("editor/live.lua"), b"-- live\n")
.expect("write a new file into the source working tree");
assert_eq!(
std::fs::read(dst.join("live.lua")).expect("new file visible through the symlink"),
b"-- live\n",
"editing the source working tree must be visible through the destination symlink \
without re-syncing"
);
let key = artifact_key("dest", "dev-src", "editor");
let record = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("a record must be written for the linked artifact");
assert!(
record.linked,
"the deployed registry record for a link artifact must be a LINKED record (linked=true)"
);
}
#[test]
fn linked_record_is_linked_not_copy() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let in_ = input(&base, Some(&local), None, None, false);
sync(&in_, &fx.backend, &fx.registry).expect("link-source sync runs to deploy");
let key = artifact_key("dest", "dev-src", "editor");
let record = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("a record must be written for the linked artifact");
assert!(record.linked, "linked record must carry linked=true");
assert!(
record.files.is_empty(),
"a linked record carries no per-file manifest (it is outside the integrity model)"
);
assert_eq!(
record.commit, "link",
"a linked record uses the sentinel commit, not a copied source commit"
);
assert_eq!(
record.digest, "link:",
"a linked record uses the sentinel digest, not a copied content digest"
);
}
#[cfg(unix)]
#[test]
fn symlink_failure_warns_skips_and_continues() {
use std::os::unix::fs::PermissionsExt;
let td = TargetDir::new();
let (blocked_src, blocked_git) = build_named_artifact_repo("alpha", "a.txt", b"alpha\n");
let (ok_src, ok_git) = build_named_artifact_repo("beta", "b.txt", b"beta\n");
let (copy_src, copy_git) = build_named_artifact_repo("widget", "w.txt", b"widget\n");
let mirror_dir = TempDir::new().expect("backend mirror dir");
let backend = GitBackend::new(mirror_dir.path().to_path_buf());
let registry = fx_registry();
let base = {
let toml = format!(
"version = 1\n\n\
[sources.dev-blocked]\ngit = \"{blocked_git}\"\nbranch = \"main\"\n\n\
[sources.dev-ok]\ngit = \"{ok_git}\"\nbranch = \"main\"\n\n\
[sources.copy-src]\ngit = \"{copy_git}\"\nbranch = \"main\"\n",
);
Config::parse(&toml).expect("base with link + copy sources parses")
};
let local = {
let toml = format!(
"version = 1\n\n\
[sources.dev-blocked]\ngit = \"{blocked_git}\"\nbranch = \"main\"\n\
deploy = \"link\"\n\n\
[sources.dev-ok]\ngit = \"{ok_git}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = [\"dev-blocked\", \"dev-ok\", \"copy-src\"]\nlayout = \"by-source\"\n",
td.target_path().display(),
);
Config::parse(&toml).expect("overlay setting links + target parses")
};
let blocked_parent = td.target_path().join("dev-blocked");
std::fs::create_dir_all(&blocked_parent).expect("create blocked link parent dir");
std::fs::set_permissions(&blocked_parent, std::fs::Permissions::from_mode(0o555))
.expect("make the blocked link parent read-only");
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &backend, ®istry).expect("sync must not abort on a link failure");
std::fs::set_permissions(&blocked_parent, std::fs::Permissions::from_mode(0o755))
.expect("restore perms so the tempdir can be cleaned up");
assert!(
out.had_failures,
"a failed link deploy must set had_failures (warn-and-continue, not abort)"
);
let copy_dst = link_dst(&td.target_path(), "copy-src", "widget");
assert_eq!(
std::fs::read(copy_dst.join("w.txt")).expect("copy artifact deployed"),
b"widget\n",
"a sibling COPY artifact in the same target must deploy fine despite the link failure"
);
let ok_dst = link_dst(&td.target_path(), "dev-ok", "beta");
let ok_meta = std::fs::symlink_metadata(&ok_dst)
.expect("the healthy link source must still deploy despite the sibling failure");
assert!(
ok_meta.file_type().is_symlink(),
"a healthy link artifact must deploy as a symlink even when a sibling link fails"
);
assert_eq!(
std::fs::read_link(&ok_dst).expect("healthy symlink readable"),
canonical_fixture_target(&ok_src.path().join("beta")),
"the healthy link must point at its canonical absolute working-tree target"
);
drop((blocked_src, ok_src, copy_src));
}
#[cfg(unix)]
#[test]
fn orphaned_link_staging_does_not_wedge_next_deploy() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let parent = dst.parent().expect("dst has a parent");
std::fs::create_dir_all(parent).expect("create dst parent");
for n in 0..4096 {
let orphan = parent.join(format!(".phora-link-{n}"));
std::os::unix::fs::symlink(fx.src.path(), &orphan)
.expect("plant a crash-orphan staging symlink");
}
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("sync runs despite link orphans");
assert!(
!out.had_failures,
"a `.phora-link-*` crash orphan must not wedge a fresh link deploy"
);
let meta = std::fs::symlink_metadata(&dst)
.expect("the linked artifact must still materialize despite the orphans");
assert!(
meta.file_type().is_symlink(),
"the deploy must produce a SYMLINK, not fail with EEXIST against an orphan"
);
assert_eq!(
std::fs::read_link(&dst).expect("the deployed symlink must be readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"the deploy must point at the correct canonical absolute <source>/<artifact> target"
);
}
#[test]
fn stale_link_with_wrong_target_is_repointed() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let dst = link_dst(&td.target_path(), "dev-src", "editor");
std::fs::create_dir_all(dst.parent().expect("dst has a parent")).expect("create dst parent");
let wrong = fx.src.path().join("docs");
#[cfg(unix)]
std::os::unix::fs::symlink(&wrong, &dst).expect("plant a wrong-target symlink");
#[cfg(windows)]
std::os::windows::fs::symlink_dir(&wrong, &dst).expect("plant a wrong-target symlink");
assert_eq!(
std::fs::read_link(&dst).expect("stale symlink readable"),
wrong,
"premise: the destination starts as a symlink to the WRONG target"
);
let in_ = input(&base, Some(&local), None, None, true);
sync(&in_, &fx.backend, &fx.registry).expect("forced sync re-points the stale link");
let meta = std::fs::symlink_metadata(&dst).expect("dst still present after re-point");
assert!(
meta.file_type().is_symlink(),
"after re-point the destination must remain a symlink, never a half state"
);
assert_eq!(
std::fs::read_link(&dst).expect("re-pointed symlink readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"a stale link with the wrong target must be re-pointed to the CORRECT canonical absolute \
target"
);
}
fn by_source_copy_config(url: &str, target_path: &Path) -> Config {
config_one_source_one_target("dev-src", url, "dest", target_path, "by-source")
}
#[cfg(unix)]
#[test]
fn transition_copy_to_link_materializes_symlink() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let copy_cfg = by_source_copy_config(&fx.url, &td.target_path());
let copy_in = input(©_cfg, None, None, None, false);
let out = sync(©_in, &fx.backend, &fx.registry).expect("copy leg syncs");
assert!(!out.had_failures, "the copy leg must deploy cleanly");
let copy_meta = std::fs::symlink_metadata(&dst).expect("copy dst present");
assert!(
copy_meta.file_type().is_dir() && !copy_meta.file_type().is_symlink(),
"premise: after a copy sync the dst is a REAL directory, not a symlink"
);
let key = artifact_key("dest", "dev-src", "editor");
let copy_rec = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("copy leg writes a record");
assert!(!copy_rec.linked, "premise: a copy record is linked=false");
let copy_mismatches = verify(©_cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!copy_mismatches.iter().any(|m| m.key == key),
"premise: the materialized copy must verify clean, got {copy_mismatches:?}"
);
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let link_in = input(&base, Some(&local), None, None, false);
let out = sync(&link_in, &fx.backend, &fx.registry).expect("link leg syncs");
assert!(!out.had_failures, "the link transition must not fail");
let link_meta = std::fs::symlink_metadata(&dst).expect("link dst present");
assert!(
link_meta.file_type().is_symlink(),
"copy->link transition must REDEPLOY the dst as a SYMLINK, not leave the real copy in \
place (an intact copy reads Clean and the no-deploy guard would no-op)"
);
assert_eq!(
std::fs::read_link(&dst).expect("transitioned symlink readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"the materialized symlink must point at the canonical absolute working-tree \
<source>/<artifact>"
);
let link_rec = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("link leg rewrites the record");
assert!(
link_rec.linked,
"after copy->link the record must flip to a LINKED record (linked=true)"
);
let effective = effective_of(&base, &local);
let link_mismatches = verify(&effective, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!link_mismatches.iter().any(|m| m.key == key),
"a linked artifact is quarantined from verify; the transition must surface no \
mismatch, got {link_mismatches:?}"
);
}
#[cfg(unix)]
#[test]
fn transition_link_to_copy_materializes_real_copy() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let key = artifact_key("dest", "dev-src", "editor");
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let link_in = input(&base, Some(&local), None, None, false);
let out = sync(&link_in, &fx.backend, &fx.registry).expect("link leg syncs");
assert!(!out.had_failures, "the link leg must deploy cleanly");
let link_meta = std::fs::symlink_metadata(&dst).expect("link dst present");
assert!(
link_meta.file_type().is_symlink(),
"premise: after a link sync the dst is a symlink"
);
let link_rec = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("link leg writes a record");
assert!(link_rec.linked, "premise: a link record is linked=true");
let copy_cfg = by_source_copy_config(&fx.url, &td.target_path());
let copy_in = input(©_cfg, None, None, None, false);
let out = sync(©_in, &fx.backend, &fx.registry).expect("copy leg syncs");
assert!(!out.had_failures, "the link->copy transition must not fail");
let copy_meta = std::fs::symlink_metadata(&dst).expect("copy dst present");
assert!(
copy_meta.file_type().is_dir() && !copy_meta.file_type().is_symlink(),
"link->copy transition must REDEPLOY the dst as a REAL directory (NOT a symlink); a \
Linked record short-circuits to a no-op without this"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("materialized init.lua present"),
b"-- init\n",
"the materialized copy must contain the artifact's exported files on disk"
);
let copy_rec = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("copy leg rewrites the record");
assert!(
!copy_rec.linked,
"after link->copy the record must flip to a copy record (linked=false)"
);
assert!(
copy_rec
.files
.iter()
.any(|f| f.path == *Path::new("init.lua")),
"the materialized copy record must carry a per-file manifest (integrity restored), \
got {:?}",
copy_rec.files
);
let copy_mismatches = verify(©_cfg, &fx.registry, None, &fx.backend)
.expect("verify must not error")
.mismatches;
assert!(
!copy_mismatches.iter().any(|m| m.key == key),
"full per-file integrity must be restored: verify over the materialized copy must \
report no mismatch, got {copy_mismatches:?}"
);
}
#[cfg(unix)]
#[test]
fn linked_record_over_real_dir_redeploys_symlink() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let key = artifact_key("dest", "dev-src", "editor");
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("link leg syncs");
assert!(!out.had_failures, "the initial link deploy must not fail");
assert!(
std::fs::symlink_metadata(&dst)
.expect("link dst present")
.file_type()
.is_symlink(),
"premise: the artifact is first deployed as a symlink"
);
std::fs::remove_file(&dst).expect("remove the deployed symlink");
std::fs::create_dir_all(&dst).expect("plant a real directory in its place");
std::fs::write(dst.join("squatter.txt"), b"external\n").expect("write into the real dir");
assert!(
std::fs::symlink_metadata(&dst)
.expect("replaced dst present")
.file_type()
.is_dir(),
"premise: the dst is now a REAL directory (record still says linked=true)"
);
let out = sync(&in_, &fx.backend, &fx.registry).expect("resync runs");
assert!(!out.had_failures, "the re-link must not fail");
let meta = std::fs::symlink_metadata(&dst).expect("dst present after resync");
assert!(
meta.file_type().is_symlink(),
"a linked record whose dst is NOT a symlink must REDEPLOY the symlink, not no-op and \
quarantine the externally-planted directory"
);
assert_eq!(
std::fs::read_link(&dst).expect("re-linked symlink readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"the re-linked dst must point at the canonical absolute working-tree target"
);
let rec = fx
.registry
.artifact(&key)
.expect("registry read")
.expect("record present after re-link");
assert!(rec.linked, "the re-linked record must remain linked=true");
}
#[cfg(unix)]
#[test]
fn copy_to_link_transition_skips_foreign_dst_without_force() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
std::fs::create_dir_all(&dst).expect("plant a foreign real dir at the link dst");
let marker = b"hand-written, not phora-managed\n";
std::fs::write(dst.join("local-only.txt"), marker).expect("write foreign marker");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"dev-src",
"editor",
&fx.head_sha,
);
assert!(
matches!(st, ArtifactState::Foreign),
"premise: an unmanaged real dir at the link dst must read Foreign, got {st:?}"
);
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let out = sync(
&input(&base, Some(&local), None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Foreign dst during a copy→link transition");
assert!(!out.had_failures, "skipping a Foreign dst is not a failure");
let meta = std::fs::symlink_metadata(&dst).expect("dst present after sync");
assert!(
!meta.file_type().is_symlink(),
"without --force a copy→link transition onto Foreign content must be SKIPPED, not \
replace the real dir with a symlink"
);
assert_eq!(
std::fs::read(dst.join("local-only.txt")).expect("foreign marker still present"),
marker,
"the unmanaged content must be left intact on disk"
);
}
#[cfg(unix)]
#[test]
fn copy_to_link_transition_skips_modified_dst_without_force() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let key = artifact_key("dest", "dev-src", "editor");
let copy_cfg = by_source_copy_config(&fx.url, &td.target_path());
let out = sync(
&input(©_cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("copy leg deploys and records the artifact");
assert!(!out.had_failures, "the copy leg must deploy cleanly");
assert!(
fx.registry.artifact(&key).expect("registry read").is_some(),
"premise: the copy leg must record a managed artifact"
);
let edited = b"-- locally edited, do not clobber\n";
std::fs::write(dst.join("init.lua"), edited).expect("edit the deployed file");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"dev-src",
"editor",
&fx.head_sha,
);
assert!(
matches!(st, ArtifactState::Modified { .. }),
"premise: an edited managed copy at the link dst must read Modified, got {st:?}"
);
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let out = sync(
&input(&base, Some(&local), None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Modified dst during a copy→link transition");
assert!(
!out.had_failures,
"skipping a Modified dst is not a failure"
);
let meta = std::fs::symlink_metadata(&dst).expect("dst present after sync");
assert!(
!meta.file_type().is_symlink(),
"without --force a copy→link transition onto a Modified artifact must be SKIPPED, not \
replace the edited copy with a symlink"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("edited file still present"),
edited,
"the local edit must be preserved on disk"
);
}
#[cfg(unix)]
#[test]
fn link_to_copy_transition_skips_foreign_symlink_without_force() {
use std::os::unix::fs::symlink;
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
std::fs::create_dir_all(dst.parent().expect("dst parent")).expect("mkdir dst parent");
let foreign_target = td.target_path().join("foreign-elsewhere");
std::fs::create_dir_all(&foreign_target).expect("mkdir foreign symlink target");
std::fs::write(foreign_target.join("keep.txt"), b"external\n").expect("write foreign target");
symlink(&foreign_target, &dst).expect("plant a foreign symlink at the copy dst");
let st = check_state_at(
&dst,
&fx.registry,
"dest",
"dev-src",
"editor",
&fx.head_sha,
);
assert!(
matches!(st, ArtifactState::Foreign),
"premise: an unmanaged symlink at the copy dst must read Foreign, got {st:?}"
);
let copy_cfg = by_source_copy_config(&fx.url, &td.target_path());
let out = sync(
&input(©_cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync must not error on a Foreign symlink during a link→copy transition");
assert!(
!out.had_failures,
"skipping a Foreign symlink is not a failure"
);
let meta = std::fs::symlink_metadata(&dst).expect("dst present after sync");
assert!(
meta.file_type().is_symlink(),
"without --force a link→copy transition onto a Foreign symlink must be SKIPPED, not \
materialize a real copy over it"
);
assert_eq!(
std::fs::read_link(&dst).expect("foreign symlink still readable"),
foreign_target,
"the unmanaged symlink must be left intact on disk"
);
}
#[cfg(unix)]
#[test]
fn force_still_applies_copy_to_link_transition_over_foreign() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
std::fs::create_dir_all(&dst).expect("plant a foreign real dir at the link dst");
std::fs::write(dst.join("local-only.txt"), b"squatter\n").expect("write foreign marker");
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let out = sync(
&input(&base, Some(&local), None, None, true),
&fx.backend,
&fx.registry,
)
.expect("forced copy→link transition deploys over Foreign content");
assert!(!out.had_failures, "forced transition must succeed");
let meta = std::fs::symlink_metadata(&dst).expect("dst present after forced sync");
assert!(
meta.file_type().is_symlink(),
"--force must still apply the copy→link transition, replacing Foreign content with a \
symlink"
);
assert_eq!(
std::fs::read_link(&dst).expect("forced symlink readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"the materialized symlink must point at the canonical absolute working-tree \
<source>/<artifact>"
);
}
#[cfg(unix)]
#[test]
fn correct_link_resync_is_still_a_noop() {
use std::os::unix::fs::MetadataExt;
let fx = build_sync_fixture();
let td = TargetDir::new();
let dst = link_dst(&td.target_path(), "dev-src", "editor");
let (base, local) = base_link_overlay_pair("dev-src", fx.src.path(), &td.target_path());
let in_ = input(&base, Some(&local), None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("link leg syncs");
assert!(!out.had_failures, "the initial link deploy must not fail");
assert!(
std::fs::symlink_metadata(&dst)
.expect("link dst present")
.file_type()
.is_symlink(),
"premise: the artifact is first deployed as a symlink"
);
let ino_before = std::fs::symlink_metadata(&dst)
.expect("link dst present")
.ino();
let out = sync(&in_, &fx.backend, &fx.registry).expect("resync runs");
assert!(
!out.had_failures,
"a correct linked re-sync is not a failure"
);
let meta = std::fs::symlink_metadata(&dst).expect("dst still present after resync");
assert!(
meta.file_type().is_symlink(),
"the correct symlink must be left intact (not replaced by a redeploy)"
);
assert_eq!(
meta.ino(),
ino_before,
"a correct link re-sync must NOT recreate the symlink (idempotent no-op)"
);
assert_eq!(
std::fs::read_link(&dst).expect("symlink readable"),
canonical_fixture_target(&fx.src.path().join("editor")),
"the correct symlink must still point at the same canonical working-tree target"
);
}
#[expect(
clippy::unwrap_used,
reason = "fixture paths always have a parent + final component"
)]
fn split_remote_path(url: &str) -> (String, String) {
let p = Path::new(url);
let parent = p.parent().unwrap().to_string_lossy().into_owned();
let base = p.file_name().unwrap().to_string_lossy().into_owned();
(parent, base)
}
fn config_host_source_one_target(
source: &str,
url: &str,
target: &str,
target_path: &Path,
) -> Config {
let (parent, base) = split_remote_path(url);
let toml = format!(
"version = 1\n\n\
[hosts.fixturehost]\nremote = \"{parent}/{{path}}\"\n\n\
[sources.{source}]\nhost = \"fixturehost\"\nrepo = \"{base}\"\nbranch = \"main\"\n\n\
[targets.{target}]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"flat\"\n",
target_path.display(),
);
Config::parse(&toml).expect("host+path one-target config parses")
}
#[test]
fn host_path_source_syncs_identically_to_its_literal_twin() {
let fx = build_sync_fixture();
let td_lit = TargetDir::new();
let cfg_lit =
config_one_source_one_target("editor-src", &fx.url, "dest", &td_lit.target_path(), "flat");
let in_lit = input(&cfg_lit, None, None, None, false);
let git_dir_lit = TempDir::new().expect("literal git dir");
let state_dir_lit = TempDir::new().expect("literal state dir");
let backend_lit = GitBackend::new(git_dir_lit.path().to_path_buf());
let registry_lit =
FileStateStore::open(state_dir_lit.path().to_path_buf()).expect("literal registry");
let out_lit = sync(&in_lit, &backend_lit, ®istry_lit).expect("literal-twin sync deploys");
let td_host = TargetDir::new();
let cfg_host =
config_host_source_one_target("editor-src", &fx.url, "dest", &td_host.target_path());
let in_host = input(&cfg_host, None, None, None, false);
let git_dir_host = TempDir::new().expect("host git dir");
let state_dir_host = TempDir::new().expect("host state dir");
let backend_host = GitBackend::new(git_dir_host.path().to_path_buf());
let registry_host =
FileStateStore::open(state_dir_host.path().to_path_buf()).expect("host registry");
let out_host = sync(&in_host, &backend_host, ®istry_host).expect("host+path sync deploys");
let commit_lit = out_lit
.base_lock
.find_source("editor-src")
.expect("literal twin locked")
.commit
.clone();
let commit_host = out_host
.base_lock
.find_source("editor-src")
.expect("host+path locked")
.commit
.clone();
assert_eq!(
commit_host, commit_lit,
"a host+path source must resolve to the SAME commit as its literal twin"
);
assert_eq!(
commit_host, fx.head_sha,
"the host+path source must resolve branch main to the fixture HEAD"
);
let dst_lit = td_lit.artifact_dst(&flat_layout(), "editor-src", "editor");
let dst_host = td_host.artifact_dst(&flat_layout(), "editor-src", "editor");
let bytes_lit =
std::fs::read(dst_lit.join("init.lua")).expect("literal twin deployed init.lua");
let bytes_host = std::fs::read(dst_host.join("init.lua")).expect("host+path deployed init.lua");
assert_eq!(
bytes_host, bytes_lit,
"a host+path source must deploy the SAME artifact bytes as its literal twin"
);
assert_eq!(
bytes_host, b"-- init\n",
"the host+path deploy must materialize the fixture's init.lua content"
);
}
#[test]
fn literal_git_source_still_syncs_unchanged() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &fx.backend, &fx.registry).expect("literal source still syncs");
assert_eq!(
out.base_lock
.find_source("editor-src")
.expect("literal source locked")
.commit,
fx.head_sha,
"a literal-git source must keep resolving to the fixture HEAD"
);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("literal deployed init.lua"),
b"-- init\n",
"a literal-git source must keep deploying its artifact bytes"
);
}
struct RecordingBackend<'a> {
inner: &'a GitBackend,
urls: Mutex<Vec<String>>,
}
impl<'a> RecordingBackend<'a> {
fn new(inner: &'a GitBackend) -> Self {
Self {
inner,
urls: Mutex::new(Vec::new()),
}
}
fn fetched_urls(&self) -> Vec<String> {
self.urls.lock().expect("urls mutex").clone()
}
}
impl SourceStore for RecordingBackend<'_> {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
if policy == ResolvePolicy::Refresh
&& let SourceLocation::Git { url } | SourceLocation::Url { url } = &request.location
{
self.urls.lock().expect("urls mutex").push(url.clone());
}
SourceStore::resolve(self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_repo_named(name: &str, content: &[u8]) -> (TempDir, String) {
let parent = TempDir::new().unwrap();
let repo = parent.path().join(name);
std::fs::create_dir_all(repo.join("editor")).unwrap();
run_git(&repo, &["init", "-b", "main", "."]);
run_git(&repo, &["config", "user.email", "test@example.com"]);
run_git(&repo, &["config", "user.name", "Test"]);
std::fs::write(repo.join("editor/init.lua"), content).unwrap();
run_git(&repo, &["add", "-A"]);
run_git(&repo, &["commit", "-m", "init"]);
let url = repo.to_string_lossy().into_owned();
(parent, url)
}
#[test]
fn per_source_protocol_beats_global_default() {
let (https_src, https_url) = build_repo_named("repo", b"-- https\n");
let (ssh_src, ssh_url) = build_repo_named("repo", b"-- ssh\n");
let https_head = rev_parse(Path::new(&https_url), "HEAD");
let ssh_head = rev_parse(Path::new(&ssh_url), "HEAD");
assert_ne!(
https_head, ssh_head,
"premise: the two protocol repos must have distinct HEADs"
);
let (https_parent, https_base) = split_remote_path(&https_url);
let (ssh_parent, ssh_base) = split_remote_path(&ssh_url);
assert_eq!(
https_base, ssh_base,
"premise: both repos must share a basename so one {{path}} value selects either by protocol"
);
let td = TargetDir::new();
let toml = format!(
"version = 1\nprotocol = \"https\"\n\n\
[hosts.dual]\nremote = {{ https = \"{https_parent}/{{path}}\", ssh = \"{ssh_parent}/{{path}}\" }}\n\n\
[sources.editor-src]\nhost = \"dual\"\npath = \"{ssh_base}\"\nprotocol = \"ssh\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("dual-protocol config parses");
let in_ = input(&cfg, None, None, None, false);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let inner = GitBackend::new(git_dir.path().to_path_buf());
let recording = RecordingBackend::new(&inner);
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("registry");
let out = sync(&in_, &recording, ®istry).expect("dual-protocol sync deploys");
let commit = out
.base_lock
.find_source("editor-src")
.expect("editor-src locked")
.commit
.clone();
assert_eq!(
commit, ssh_head,
"per-source protocol=ssh must win over global https: resolve via the SSH repo's HEAD"
);
assert!(
recording.fetched_urls().iter().any(|u| u == &ssh_url),
"the wiring must fetch the SSH-resolved remote `{ssh_url}`, got {:?}",
recording.fetched_urls()
);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua"),
b"-- ssh\n",
"the deployed bytes must come from the SSH repo (per-source protocol wins)"
);
drop(https_src);
drop(ssh_src);
}
#[test]
fn global_protocol_applies_when_source_omits_protocol() {
let (https_src, https_url) = build_repo_named("repo", b"-- https\n");
let (ssh_src, ssh_url) = build_repo_named("repo", b"-- ssh\n");
let https_head = rev_parse(Path::new(&https_url), "HEAD");
let ssh_head = rev_parse(Path::new(&ssh_url), "HEAD");
assert_ne!(
https_head, ssh_head,
"premise: the two protocol repos must have distinct HEADs"
);
let (https_parent, https_base) = split_remote_path(&https_url);
let (ssh_parent, ssh_base) = split_remote_path(&ssh_url);
assert_eq!(
https_base, ssh_base,
"premise: both repos must share a basename so one {{path}} value selects either by protocol"
);
let td = TargetDir::new();
let toml = format!(
"version = 1\nprotocol = \"ssh\"\n\n\
[hosts.dual]\nremote = {{ https = \"{https_parent}/{{path}}\", ssh = \"{ssh_parent}/{{path}}\" }}\n\n\
[sources.editor-src]\nhost = \"dual\"\npath = \"{ssh_base}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("config-default-protocol config parses");
let in_ = input(&cfg, None, None, None, false);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let inner = GitBackend::new(git_dir.path().to_path_buf());
let recording = RecordingBackend::new(&inner);
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("registry");
let out = sync(&in_, &recording, ®istry).expect("config-default-protocol sync deploys");
let commit = out
.base_lock
.find_source("editor-src")
.expect("editor-src locked")
.commit
.clone();
assert_eq!(
commit, ssh_head,
"a silent source must inherit config.protocol=ssh: resolve via the SSH repo's HEAD, not the Https default"
);
assert!(
recording.fetched_urls().iter().any(|u| u == &ssh_url),
"the wiring must fetch the config-resolved SSH remote `{ssh_url}`, got {:?}",
recording.fetched_urls()
);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua"),
b"-- ssh\n",
"the deployed bytes must come from the SSH repo (config.protocol applies to a silent source)"
);
drop(https_src);
drop(ssh_src);
}
struct UrlTarServer {
url: String,
_handle: std::thread::JoinHandle<()>,
}
impl UrlTarServer {
fn spawn(bodies: Vec<Vec<u8>>) -> Self {
use std::io::{Read, Write};
use std::net::TcpListener;
use std::time::Duration;
let listener =
TcpListener::bind("127.0.0.1:0").expect("bind ephemeral port for url server");
let port = listener.local_addr().expect("local addr").port();
let url = format!("http://127.0.0.1:{port}/pkg-1.0.tar.gz");
let handle = std::thread::spawn(move || {
let mut idx = 0usize;
while let Ok((mut stream, _)) = listener.accept() {
let _ = stream.set_read_timeout(Some(Duration::from_secs(5)));
let _ = stream.set_write_timeout(Some(Duration::from_secs(5)));
let mut buf = [0u8; 1024];
let _ = stream.read(&mut buf);
let body = &bodies[idx.min(bodies.len() - 1)];
idx += 1;
let header = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
let _ = stream.write_all(header.as_bytes());
let _ = stream.write_all(body);
let _ = stream.flush();
}
});
Self {
url,
_handle: handle,
}
}
}
fn editor_tar_gz(init_lua: &[u8]) -> Vec<u8> {
use std::io::Write;
let mut header = tar::Header::new_gnu();
header.set_size(init_lua.len() as u64);
header.set_mode(0o644);
header.set_entry_type(tar::EntryType::Regular);
header.set_cksum();
let mut builder = tar::Builder::new(Vec::new());
builder
.append_data(&mut header, "pkg-1.0/editor/init.lua", init_lua)
.expect("append editor/init.lua tar entry");
let tar_bytes = builder.into_inner().expect("finish tar");
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
encoder.write_all(&tar_bytes).expect("gzip tar bytes");
encoder.finish().expect("finish gzip")
}
fn url_config_one_target(source: &str, url: &str, target_path: &Path, layout: &str) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.{source}]\nurl = \"{url}\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"{layout}\"\n",
target_path.display(),
);
Config::parse(&toml).expect("url source + target config parses")
}
struct CountingRouter {
inner: RouterBackend<GitBackend, HttpBackend>,
fetches: AtomicUsize,
}
impl CountingRouter {
fn new(git_dir: PathBuf) -> Self {
let git = GitBackend::new(git_dir.clone());
let http = HttpBackend::new(git_dir, BTreeMap::new());
Self {
inner: RouterBackend::new(git, http),
fetches: AtomicUsize::new(0),
}
}
fn fetch_count(&self) -> usize {
self.fetches.load(AtomicOrdering::SeqCst)
}
}
impl SourceStore for CountingRouter {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
if policy == ResolvePolicy::Refresh {
self.fetches.fetch_add(1, AtomicOrdering::SeqCst);
}
SourceStore::resolve(&self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(&self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
SourceStore::read(&self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(&self.inner, snapshot, path)
}
}
#[test]
fn second_sync_of_unchanged_url_is_a_noop() {
let server = UrlTarServer::spawn(vec![editor_tar_gz(b"-- v1\n")]);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = CountingRouter::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let cfg = url_config_one_target("pkg", &server.url, &td.target_path(), "flat");
let first = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync of url source deploys");
assert!(!first.had_failures, "first url sync must succeed");
assert_eq!(
backend.fetch_count(),
1,
"premise: the first sync of a fresh url source must fetch exactly once"
);
assert_eq!(
first
.base_lock
.find_source("pkg")
.expect("url source in lock")
.resolved,
"url",
"a url source's lock must record the 'url' sentinel in resolved, not the empty Refspec::None string"
);
let dst = td.artifact_dst(&flat_layout(), "pkg", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua"),
b"-- v1\n",
"premise: the first sync must deploy the archived editor/init.lua bytes"
);
let fetches_after_first = backend.fetch_count();
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&backend,
®istry,
)
.expect("second sync of unchanged url runs cleanly");
assert!(!second.had_failures, "second clean url sync must not fail");
assert_eq!(
backend.fetch_count(),
fetches_after_first,
"the second sync of an unchanged url MUST be a no-op: the matching lock must \
suppress the re-download, so fetch_count must not increase (the bug is that a \
url lock never matches and re-fetches every time)"
);
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("init.lua still deployed"),
b"-- v1\n",
"files must remain correctly deployed after the no-op second sync"
);
}
#[test]
fn update_with_changed_url_content_advances_lock() {
let server = UrlTarServer::spawn(vec![editor_tar_gz(b"-- v1\n"), editor_tar_gz(b"-- v2\n")]);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = CountingRouter::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let cfg = url_config_one_target("pkg", &server.url, &td.target_path(), "flat");
let first = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync deploys v1");
let first_commit = first
.base_lock
.find_source("pkg")
.expect("pkg locked after first sync")
.commit
.clone();
let fetches_after_first = backend.fetch_count();
let second = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("updated second sync re-fetches changed content");
assert!(!second.had_failures, "second sync must succeed");
assert!(
backend.fetch_count() > fetches_after_first,
"an update of changed url content MUST re-fetch: fetch_count increases"
);
let second_commit = second
.base_lock
.find_source("pkg")
.expect("pkg locked after second sync")
.commit
.clone();
assert_ne!(
second_commit, first_commit,
"changed archive bytes must yield a different synthetic commit id: the lock advances"
);
let dst = td.artifact_dst(&flat_layout(), "pkg", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua after advance"),
b"-- v2\n",
"advancing the lock must re-deploy the new archive bytes, not merely bump the commit id"
);
}
#[test]
fn reimport_identical_bytes_does_not_churn() {
let server = UrlTarServer::spawn(vec![
editor_tar_gz(b"-- same\n"),
editor_tar_gz(b"-- same\n"),
]);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let backend = CountingRouter::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let cfg = url_config_one_target("pkg", &server.url, &td.target_path(), "flat");
let first = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync imports the archive");
let first_commit = first
.base_lock
.find_source("pkg")
.expect("pkg locked after first sync")
.commit
.clone();
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, true),
&backend,
®istry,
)
.expect("forced re-import of identical bytes");
let second_commit = second
.base_lock
.find_source("pkg")
.expect("pkg locked after second sync")
.commit
.clone();
assert_eq!(
second_commit, first_commit,
"re-importing identical archive bytes must yield the SAME content-addressed synthetic \
commit id — no lock churn even when forced to re-fetch"
);
}
fn lock_bytes(lock: &Lock) -> String {
toml::to_string(lock).expect("lock serializes to toml")
}
#[test]
fn two_bindings_of_one_source_share_a_single_lock_entry() {
let (src, url) = build_multi_root_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let cfg = Config::parse(&format!(
"version = 1\n\n[sources.dots]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
nvim = {{ source = \"dots\" }},\n\
tmux = {{ source = \"dots\" }},\n\
}}\nlayout = \"by-source\"\n",
td.target_path().display(),
))
.expect("two-binding config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("two bindings of one source must sync");
assert_eq!(
out.base_lock.sources.len(),
1,
"two bindings of one source must collapse to exactly ONE lock entry: the lock keys per \
source, not per binding"
);
assert_eq!(
out.base_lock
.find_source("dots")
.expect("the single lock entry is keyed by the source name")
.name,
"dots",
"the shared lock entry is keyed by the underlying source `dots`, never a binding identity"
);
drop(src);
}
fn two_slice_tar_gz() -> Vec<u8> {
use std::io::Write;
let mut builder = tar::Builder::new(Vec::new());
for (path, body) in [
("pkg-1.0/editor/init.lua", b"-- editor\n".as_slice()),
("pkg-1.0/shell/profile.sh", b"# shell\n".as_slice()),
] {
let mut header = tar::Header::new_gnu();
header.set_size(body.len() as u64);
header.set_mode(0o644);
header.set_entry_type(tar::EntryType::Regular);
header.set_cksum();
builder
.append_data(&mut header, path, body)
.expect("append tar entry");
}
let tar_bytes = builder.into_inner().expect("finish tar");
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
encoder.write_all(&tar_bytes).expect("gzip tar bytes");
encoder.finish().expect("finish gzip")
}
#[test]
fn url_source_lock_digest_is_full_archive_regardless_of_selection() {
let server_a = UrlTarServer::spawn(vec![two_slice_tar_gz()]);
let server_b = UrlTarServer::spawn(vec![two_slice_tar_gz()]);
let (_g1, _s1, _b1, registry_a) = fresh_backend_registry();
let (_g2, _s2, _b2, registry_b) = fresh_backend_registry();
let git_a = TempDir::new().expect("git dir a");
let git_b = TempDir::new().expect("git dir b");
let backend_a = CountingRouter::new(git_a.path().to_path_buf());
let backend_b = CountingRouter::new(git_b.path().to_path_buf());
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let cfg_editor = Config::parse(&format!(
"version = 1\n\n[sources.pkg]\nurl = \"{}\"\ninclude = [\"editor/**\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"pkg\"]\nlayout = \"by-source\"\n",
server_a.url,
td_a.target_path().display(),
))
.expect("editor-scoped url config parses");
let cfg_shell = Config::parse(&format!(
"version = 1\n\n[sources.pkg]\nurl = \"{}\"\ninclude = [\"shell/**\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"pkg\"]\nlayout = \"by-source\"\n",
server_b.url,
td_b.target_path().display(),
))
.expect("shell-scoped url config parses");
let out_editor = sync(
&input(&cfg_editor, None, None, None, false),
&backend_a,
®istry_a,
)
.expect("editor-scoped url sync");
let out_shell = sync(
&input(&cfg_shell, None, None, None, false),
&backend_b,
®istry_b,
)
.expect("shell-scoped url sync");
let editor_lock = out_editor
.base_lock
.find_source("pkg")
.expect("editor-scoped url locked");
let shell_lock = out_shell
.base_lock
.find_source("pkg")
.expect("shell-scoped url locked");
assert_eq!(
editor_lock.commit, shell_lock.commit,
"premise: identical archive bytes give the same content-addressed synthetic commit, so \
the url commit is already selection-neutral"
);
assert_eq!(
editor_lock.digest, shell_lock.digest,
"a url source's lock digest must be the FULL extracted archive (selection-neutral): two \
scopes over identical bytes must lock the same digest. The filtered subtree digest leaks \
the selection into the lock and must not be used for url sources"
);
}
#[test]
fn url_source_lock_digest_equals_full_archive_oracle() {
let server = UrlTarServer::spawn(vec![two_slice_tar_gz()]);
let git_dir = TempDir::new().expect("git dir");
let (_g, _s, _b, registry) = fresh_backend_registry();
let backend = CountingRouter::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let cfg = Config::parse(&format!(
"version = 1\n\n[sources.pkg]\nurl = \"{}\"\ninclude = [\"editor/**\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"pkg\"]\nlayout = \"by-source\"\n",
server.url,
td.target_path().display(),
))
.expect("scoped url config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("scoped url source must sync");
assert_eq!(
out.base_lock.sources.len(),
1,
"one url source must produce exactly ONE lock entry"
);
let pkg = out
.base_lock
.find_source("pkg")
.expect("the single url lock entry is keyed by source `pkg`");
let resolved = backend
.resolve(
&ResolveRequest {
name: sn("pkg"),
location: SourceLocation::Url {
url: server.url.clone(),
},
revision: RevisionSpec::None,
},
ResolvePolicy::CachedOnly,
)
.expect("resolve the cached synthetic snapshot");
assert_eq!(
resolved.snapshot.commit().as_str(),
pkg.commit,
"the cached snapshot used by the digest oracle must be the lock-pinned commit"
);
let inventory = backend
.inventory(&resolved.snapshot, None)
.expect("inventory the full extracted archive");
let leaves: Vec<SourcePath> = inventory
.entries
.into_iter()
.map(|entry| entry.path)
.collect();
let full_archive = digest_snapshot(&backend, &resolved.snapshot, &leaves)
.expect("full-archive digest computes");
assert_eq!(
pkg.digest, full_archive,
"the url lock digest must be the FULL-archive digest (no root/include/exclude), not the \
include-filtered subtree digest: selection scopes projection, never the lock"
);
}
#[test]
fn bare_binding_lock_is_byte_identical_to_source_only_config() {
let (src, url) = build_multi_root_repo();
let (_g1, _s1, backend_a, registry_a) = fresh_backend_registry();
let (_g2, _s2, backend_b, registry_b) = fresh_backend_registry();
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let cfg_bare = Config::parse(&format!(
"version = 1\n\n[sources.dots]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dots\"]\nlayout = \"by-source\"\n",
td_a.target_path().display(),
))
.expect("bare-binding config parses");
let cfg_plain = Config::parse(&format!(
"version = 1\n\n[sources.dots]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nlayout = \"by-source\"\n",
td_b.target_path().display(),
))
.expect("source-only (no explicit bindings) config parses");
let out_bare = sync(
&input(&cfg_bare, None, None, None, false),
&backend_a,
®istry_a,
)
.expect("bare-binding sync");
let out_plain = sync(
&input(&cfg_plain, None, None, None, false),
&backend_b,
®istry_b,
)
.expect("source-only sync");
assert_eq!(
lock_bytes(&out_bare.base_lock),
lock_bytes(&out_plain.base_lock),
"a bare binding must lock byte-identically to a source-only config: the per-binding \
feature must not perturb the lock when no refinement is present"
);
drop(src);
}
struct VersionedFixture {
_src: TempDir,
_git_dir: TempDir,
_state_dir: TempDir,
backend: GitBackend,
registry: FileStateStore,
url: String,
sha_a: String,
sha_b: String,
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_versioned_sync_fixture() -> VersionedFixture {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/init.lua"), b"v55\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "v55"]);
run_git(p, &["tag", "v0.55.0"]);
let sha_a = rev_parse(p, "HEAD");
std::fs::write(p.join("editor/init.lua"), b"v56\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "v56"]);
run_git(p, &["tag", "v0.56.0"]);
let sha_b = rev_parse(p, "HEAD");
assert_ne!(
sha_a, sha_b,
"fixture premise: the two tags pin distinct commits"
);
let git_dir = TempDir::new().unwrap();
let state_dir = TempDir::new().unwrap();
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry =
FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry over tempdir");
let url = p.to_string_lossy().into_owned();
VersionedFixture {
_src: src,
_git_dir: git_dir,
_state_dir: state_dir,
backend,
registry,
url,
sha_a,
sha_b,
}
}
fn config_two_versions(url: &str, target_path: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.fzf]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{\n\
stable = {{ source = \"fzf\", tag = \"v0.55.0\" }},\n\
canary = {{ source = \"fzf\", tag = \"v0.56.0\" }},\n\
}}\nlayout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("two-version config parses")
}
fn fzf_entries(lock: &Lock) -> Vec<&crate::lock::LockedSource> {
lock.sources.iter().filter(|s| s.name == "fzf").collect()
}
#[test]
fn two_version_bindings_produce_two_lock_entries_with_distinct_commits() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_two_versions(&fx.url, &td.target_path());
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("two-version sync resolves both refs");
let entries = fzf_entries(&out.base_lock);
assert_eq!(
entries.len(),
2,
"one source bound at two distinct refs must produce TWO lock entries \
(one per resolved commit), not one collapsed by source name; got {entries:?}"
);
let commits: std::collections::BTreeSet<&str> =
entries.iter().map(|e| e.commit.as_str()).collect();
let expected: std::collections::BTreeSet<&str> =
[fx.sha_a.as_str(), fx.sha_b.as_str()].into_iter().collect();
assert_eq!(
commits, expected,
"the two `fzf` lock entries must carry the two tag SHAs \
(v0.55.0 -> {}, v0.56.0 -> {}), one commit each",
fx.sha_a, fx.sha_b
);
drop(fx);
}
#[test]
fn two_version_bindings_project_each_their_own_commit_tree() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_two_versions(&fx.url, &td.target_path());
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("two-version sync deploys both slices");
let stable = fx
.registry
.artifact(&artifact_key("dest", "stable", "editor"))
.expect("registry get")
.expect("the slice keyed by identity `stable` must record under identity `stable`");
let canary = fx
.registry
.artifact(&artifact_key("dest", "canary", "editor"))
.expect("registry get")
.expect("the slice keyed by identity `canary` must record under identity `canary`");
assert_eq!(
stable.commit, fx.sha_a,
"the stable (tag v0.55.0) record must pin commit A, not the shared/last commit"
);
assert_eq!(
canary.commit, fx.sha_b,
"the canary (tag v0.56.0) record must pin commit B, not the shared/last commit"
);
assert_ne!(
stable.commit, canary.commit,
"the two identities must record DISTINCT commits; equality means both bindings \
read the same (wrong) per-source-name commit"
);
let stable_lua = std::fs::read(
td.target_path()
.join("stable")
.join("editor")
.join("init.lua"),
)
.expect("stable init.lua deployed");
let canary_lua = std::fs::read(
td.target_path()
.join("canary")
.join("editor")
.join("init.lua"),
)
.expect("canary init.lua deployed");
assert_eq!(
stable_lua, b"v55\n",
"stable must materialize v0.55.0's tree (init.lua == v55)"
);
assert_eq!(
canary_lua, b"v56\n",
"canary must materialize v0.56.0's tree (init.lua == v56)"
);
drop(fx);
}
#[test]
fn two_version_bindings_fetch_source_once_but_resolve_two_commits() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_two_versions(&fx.url, &td.target_path());
let counting = CountingBackend::new(&fx.backend);
let out = sync(
&input(&cfg, None, None, None, false),
&counting,
&fx.registry,
)
.expect("two-version sync over a counting backend");
assert_eq!(
counting.fetch_count(),
1,
"one source fetched once must cover both refs: fetch_count must be exactly 1, got {}",
counting.fetch_count()
);
let commits: std::collections::BTreeSet<&str> = fzf_entries(&out.base_lock)
.iter()
.map(|e| e.commit.as_str())
.collect();
assert_eq!(
commits.len(),
2,
"a single fetch must still yield two DISTINCT resolved commits, one per ref"
);
drop(fx);
}
#[test]
fn ref_split_entries_share_config_digest_but_differ_in_commit_and_digest() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_two_versions(&fx.url, &td.target_path());
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("two-version sync resolves both refs");
let entries = fzf_entries(&out.base_lock);
assert_eq!(
entries.len(),
2,
"premise: two ref-split entries must exist"
);
let (a, b) = (entries[0], entries[1]);
assert_eq!(
a.config_digest, b.config_digest,
"config_digest is source-derived and SHARED across ref splits"
);
assert_ne!(a.commit, b.commit, "ref splits must pin distinct commits");
assert_ne!(
a.digest, b.digest,
"each entry recomputes its export digest at its own commit; v55 and v56 trees \
differ, so the export digests must differ"
);
drop(fx);
}
#[test]
fn bare_config_lock_has_no_ref_discriminator_field() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target("fzf", &fx.url, "dest", &td.target_path(), "flat");
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("bare-config sync succeeds");
let text = toml::to_string(&out.base_lock).expect("lock serializes");
for forbidden in ["ref =", "tag =", "branch =", "rev ="] {
assert!(
!text.contains(forbidden),
"a bare lock must carry NO per-binding ref discriminator: found `{forbidden}` in:\n{text}"
);
}
drop(fx);
}
#[test]
fn rebuild_round_trips_both_ref_splits_at_their_own_commits() {
let fx = build_versioned_sync_fixture();
let td = TargetDir::new();
let cfg = config_two_versions(&fx.url, &td.target_path());
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("seeding two-version sync");
let stable_key = artifact_key("dest", "stable", "editor");
let canary_key = artifact_key("dest", "canary", "editor");
fx.registry
.remove_artifact(&stable_key)
.expect("drop stable record");
fx.registry
.remove_artifact(&canary_key)
.expect("drop canary record");
rebuild_registry(&cfg, &out.base_lock, &fx.backend, &fx.registry)
.expect("rebuild reconstructs both ref splits");
let stable = fx
.registry
.artifact(&stable_key)
.expect("registry get")
.expect("rebuild must reconstruct the stable record");
let canary = fx
.registry
.artifact(&canary_key)
.expect("registry get")
.expect("rebuild must reconstruct the canary record");
assert_eq!(
stable.commit, fx.sha_a,
"rebuild must select the locked entry by the binding's effective ref: \
stable -> tag v0.55.0 -> commit A"
);
assert_eq!(
canary.commit, fx.sha_b,
"rebuild must select the locked entry by the binding's effective ref: \
canary -> tag v0.56.0 -> commit B"
);
drop(fx);
}
fn lock_with(cfg: &Config, name: &str, git: &str, commit: &str) -> Lock {
let source = parsed_of(cfg, name);
Lock {
version: 1,
sources: vec![LockedSource {
name: name.to_owned(),
git: git.to_owned(),
resolved: source.refspec().to_string(),
commit: commit.to_owned(),
digest: "blake3:locked".to_owned(),
config_digest: source.config_digest(),
r#ref: None,
instance: None,
build: None,
}],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
}
}
fn preview_entry<'a>(plan: &'a PreviewTargetPlan, artifact: &str) -> &'a PreviewEntry {
plan.entries
.iter()
.find(|e| e.artifact == artifact)
.unwrap_or_else(|| panic!("preview plan must contain an entry for artifact `{artifact}`"))
}
fn only_plan<'a>(plans: &'a [PreviewTargetPlan], target: &str) -> &'a PreviewTargetPlan {
plans
.iter()
.find(|p| p.target == target)
.unwrap_or_else(|| panic!("preview must produce a plan for target `{target}`"))
}
fn build_loose_file_repo() -> (TempDir, String, String) {
let src = TempDir::new().expect("temp src repo");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/init.lua"), b"-- init\n").expect("write init.lua");
std::fs::write(p.join("notes.txt"), b"loose top-level note\n").expect("write notes.txt");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let head = rev_parse(p, "HEAD");
let url = p.to_string_lossy().into_owned();
(src, url, head)
}
#[test]
fn preview_emits_top_level_loose_file_leaf_matching_deploy() {
let (src, url, head) = build_loose_file_repo();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let cfg = config_one_source_one_target("loose-src", &url, "dest", &td.target_path(), "flat");
seed_git_mirror(&backend, "loose-src", &url);
let lock = lock_with(&cfg, "loose-src", &url, &head);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), false)
.expect("preview builds a plan");
let plan = only_plan(&plans, "dest");
let synced: BTreeSet<String> = plan
.entries
.iter()
.filter(|e| e.state == SyncState::Synced)
.map(|e| e.artifact.clone())
.collect();
assert!(
synced.contains("notes.txt"),
"preview must emit the top-level loose file `notes.txt` as its own materialization \
(leaf-granular parity with deploy/where), got {synced:?}"
);
assert!(
synced.contains("editor"),
"the sibling artifact dir must still be previewed alongside the loose file, got {synced:?}"
);
let notes = preview_entry(plan, "notes.txt");
assert_eq!(
notes.destination,
td.target_path().join("notes.txt"),
"the loose-file entry's destination must be the flat target join of its published key"
);
drop(src);
}
#[test]
fn preview_of_a_rooted_source_emits_root_relative_leaves_matching_deploy() {
let (src, url, head) = build_loose_file_repo();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n[sources.rooted]\ngit = \"{url}\"\nbranch = \"main\"\nroot = \"editor\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"rooted\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("rooted-source config parses");
seed_git_mirror(&backend, "rooted", &url);
let lock = lock_with(&cfg, "rooted", &url, &head);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), false)
.expect("preview builds a plan");
let plan = only_plan(&plans, "dest");
let synced: BTreeSet<String> = plan
.entries
.iter()
.filter(|e| e.state == SyncState::Synced)
.map(|e| e.artifact.clone())
.collect();
assert!(
synced.contains("init.lua"),
"a rooted source's preview must emit its root-relative leaf `init.lua` (the offer root \
`editor` re-anchors the unrooted candidates); discovering WITH the root double-applied it \
and emptied the preview, got {synced:?}"
);
assert!(
!synced.contains("notes.txt"),
"the loose file OUTSIDE the offer root must not appear — the root scopes the offer, \
got {synced:?}"
);
drop(src);
}
#[test]
fn preview_with_empty_mirror_and_no_lock_performs_no_fetch_and_annotates_not_locked() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let counting = CountingBackend::new(&fx.backend);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &counting, None, false)
.expect("an empty mirror + absent lock must NOT abort preview");
assert_eq!(
counting.fetch_count(),
0,
"preview must perform NO fetch: commits come from the lock only"
);
let plan = only_plan(&plans, "dest");
assert_eq!(
plan.entries.len(),
1,
"an un-locked source still produces one per-binding annotation entry, got {:?}",
plan.entries
);
assert_eq!(
plan.entries[0].source, "editor-src",
"the annotation entry names the un-locked source"
);
assert_eq!(
plan.entries[0].state,
SyncState::NotLocked,
"a source with no lock entry must be annotated NotLocked, not fetched"
);
}
#[test]
fn preview_reads_the_commit_from_the_lock_not_a_fresh_resolution() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let locked_commit = fx.head_sha.clone();
let lock = lock_with(&cfg, "editor-src", &fx.url, &locked_commit);
let new_head = fx.advance_head();
assert_ne!(new_head, locked_commit, "fixture HEAD must have moved");
let counting = CountingBackend::new(&fx.backend);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &counting, Some(&lock), false)
.expect("preview reads the locked commit");
assert_eq!(
counting.fetch_count(),
0,
"preview must not fetch when the commit is in the lock"
);
assert_eq!(
counting.resolve_count(),
0,
"preview must reuse the locked commit, never re-resolve a refspec"
);
let entry = preview_entry(only_plan(&plans, "dest"), "editor");
assert_eq!(
entry.commit, locked_commit,
"the entry's commit must equal the LOCKED commit, not the advanced HEAD"
);
assert_ne!(
entry.commit, new_head,
"the advanced HEAD must not leak into the preview entry"
);
}
#[test]
fn preview_annotates_locked_but_unfetched_source_as_needs_sync_without_fetching() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
let lock = lock_with(&cfg, "editor-src", &fx.url, &fx.head_sha);
let counting = CountingBackend::new(&fx.backend);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &counting, Some(&lock), false)
.expect("a locked-but-absent commit must annotate, not abort");
assert_eq!(
counting.fetch_count(),
0,
"preview must NOT fetch a locked-but-absent commit — it annotates NeedsSync"
);
let plan = only_plan(&plans, "dest");
assert_eq!(
plan.entries.len(),
1,
"a locked-but-unfetched source yields one annotation entry, got {:?}",
plan.entries
);
assert_eq!(
plan.entries[0].state,
SyncState::NeedsSync,
"locked but commit/mirror absent must be NeedsSync, distinct from NotLocked"
);
}
#[test]
fn preview_still_plans_other_bindings_when_one_source_needs_sync() {
let synced = build_named_artifact_repo("alpha", "a.txt", b"from-alpha\n");
let unsynced = build_named_artifact_repo("beta", "b.txt", b"from-beta\n");
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.src-a]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[sources.src-b]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"src-a\", \"src-b\"]\nlayout = \"by-source\"\n",
synced.1,
unsynced.1,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-source config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&backend, "src-a", &synced.1);
let a_head = rev_parse(synced.0.path(), "HEAD");
let b_head = rev_parse(unsynced.0.path(), "HEAD");
let lock = Lock {
version: 1,
sources: vec![
lock_with(&cfg, "src-a", &synced.1, &a_head)
.sources
.remove(0),
lock_with(&cfg, "src-b", &unsynced.1, &b_head)
.sources
.remove(0),
],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), false)
.expect("one unsynced source must not blank the whole plan");
let plan = only_plan(&plans, "dest");
let alpha = preview_entry(plan, "alpha");
assert_eq!(
alpha.state,
SyncState::Synced,
"the synced source's artifact must still be planned (state Synced)"
);
assert_eq!(alpha.source, "src-a", "the synced entry belongs to src-a");
assert!(
plan.entries
.iter()
.any(|e| e.source == "src-b" && e.state == SyncState::NeedsSync),
"the unsynced source must still appear, annotated NeedsSync, got {:?}",
plan.entries
);
drop(synced);
drop(unsynced);
}
#[test]
fn preview_link_binding_reads_the_working_tree_ignoring_the_lock() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dev-src]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dev-src\"]\nlayout = \"flat\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link-source config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &fx.backend, None, false)
.expect("a link binding reads the working tree without lock or mirror");
let entry = preview_entry(only_plan(&plans, "dest"), "editor");
assert_eq!(
entry.commit, "link",
"a link binding has no resolved commit; its entry carries the \"link\" sentinel"
);
assert_eq!(
entry.state,
SyncState::Synced,
"a link binding with a present working tree is renderable (Synced), not unsynced"
);
}
#[test]
fn preview_link_binding_with_missing_working_tree_is_annotated() {
let missing = TempDir::new().expect("scratch tempdir");
let gone_path = missing.path().join("not-there");
let gone = gone_path.to_string_lossy().into_owned();
drop(missing);
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dev-src]\ngit = \"{gone}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dev-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link-source config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes: BTreeMap<String, String> =
std::iter::once(("dev-src".to_owned(), gone.clone())).collect();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, None, false)
.expect("a link binding whose working tree is gone must annotate, not abort");
let plan = only_plan(&plans, "dest");
assert_eq!(
plan.entries.len(),
1,
"a gone working tree yields one annotation entry, got {:?}",
plan.entries
);
assert_eq!(
plan.entries[0].state,
SyncState::LinkWorkingTreeGone,
"a link binding whose working tree directory is gone must be LinkWorkingTreeGone"
);
}
#[test]
fn preview_writes_nothing_to_the_registry_or_the_target() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg =
config_one_source_one_target("editor-src", &fx.url, "dest", &td.target_path(), "flat");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let seeded = ArtifactRecord {
version: 1,
key: artifact_key("dest", "editor-src", "editor"),
source: "editor-src".to_owned(),
commit: fx.head_sha.clone(),
digest: "blake3:seeded".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("init.lua"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 8,
mtime: 1_700_000_000,
blake3: "blake3:seeded".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
fx.registry
.put_artifact(&seeded)
.expect("seed registry record");
let before = fx.registry.all_artifacts().expect("snapshot registry");
std::fs::create_dir_all(td.target_path()).expect("mkdir target");
std::fs::write(td.target_path().join("pre-existing.txt"), b"keep\n")
.expect("seed a pre-existing target file");
let target_before = read_target_dir(&td.target_path());
let counting = CountingBackend::new(&fx.backend);
let lock = lock_with(&cfg, "editor-src", &fx.url, &fx.head_sha);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &counting, Some(&lock), false)
.expect("preview builds a plan");
assert!(
!preview_entry(only_plan(&plans, "dest"), "editor")
.destination
.as_os_str()
.is_empty(),
"premise: preview must actually produce the editor entry so the no-write scan is meaningful"
);
assert_eq!(counting.read_count(), 0, "preview must export nothing");
let after = fx.registry.all_artifacts().expect("re-read registry");
assert_eq!(
before.len(),
after.len(),
"preview must not add or remove registry records"
);
assert_eq!(
before[0].key, after[0].key,
"the seeded registry record must be byte-for-byte unchanged after preview"
);
assert_eq!(
before[0].digest, after[0].digest,
"preview must not rewrite the seeded record's digest"
);
assert_eq!(
read_target_dir(&td.target_path()),
target_before,
"preview must not create, remove, or modify any file under the target dir"
);
}
fn read_target_dir(dir: &Path) -> BTreeMap<PathBuf, Vec<u8>> {
let mut out = BTreeMap::new();
for entry in walkdir::WalkDir::new(dir)
.into_iter()
.filter_map(std::result::Result::ok)
{
if entry.file_type().is_file() {
let rel = entry
.path()
.strip_prefix(dir)
.expect("entry under dir")
.to_path_buf();
out.insert(rel, std::fs::read(entry.path()).expect("read target file"));
}
}
out
}
#[test]
fn preview_annotates_predicted_flat_collision_as_warning_not_error() {
let fx_a = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let fx_b = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.src-a]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[sources.src-b]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"src-a\", \"src-b\"]\nlayout = \"flat\"\n",
fx_a.1,
fx_b.1,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-source flat config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&backend, "src-a", &fx_a.1);
seed_git_mirror(&backend, "src-b", &fx_b.1);
let a_head = rev_parse(fx_a.0.path(), "HEAD");
let b_head = rev_parse(fx_b.0.path(), "HEAD");
let lock = Lock {
version: 1,
sources: vec![
lock_with(&cfg, "src-a", &fx_a.1, &a_head).sources.remove(0),
lock_with(&cfg, "src-b", &fx_b.1, &b_head).sources.remove(0),
],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let result = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), false);
let plans = match result {
Ok(plans) => plans,
Err(Error::Collision { .. }) => {
panic!("a predicted flat collision must be a warning in preview, NOT Error::Collision")
}
Err(e) => panic!("preview must not error on a predicted collision, got {e:?}"),
};
let plan = only_plan(&plans, "dest");
assert_eq!(
plan.entries
.iter()
.filter(|e| e.artifact == "shared")
.count(),
2,
"preview must render BOTH colliding entries, got {:?}",
plan.entries
);
let collision = plan
.collisions
.iter()
.find(|c| c.artifact == "shared")
.expect("the flat collision on `shared` must be annotated on the target");
assert!(
collision.sources.contains(&"src-a".to_owned())
&& collision.sources.contains(&"src-b".to_owned()),
"the collision warning must name BOTH contributing sources, got {:?}",
collision.sources
);
drop(fx_a);
drop(fx_b);
}
#[test]
fn preview_happy_path_renders_synced_artifacts_at_literal_layout_destinations() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target(
"editor-src",
&fx.url,
"dest",
&td.target_path(),
"by-source",
);
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let lock = lock_with(&cfg, "editor-src", &fx.url, &fx.head_sha);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let plans = preview_targets(&cfg, &parsed, &remotes, &fx.backend, Some(&lock), false)
.expect("a synced source previews its artifacts");
let plan = only_plan(&plans, "dest");
let editor = preview_entry(plan, "editor");
assert_eq!(
editor.state,
SyncState::Synced,
"a synced source's artifact must be Synced"
);
assert_eq!(
editor.source, "editor-src",
"the entry names its source binding"
);
assert_eq!(
editor.commit, fx.head_sha,
"the entry carries the locked commit"
);
assert_eq!(
editor.destination,
td.target_path().join("editor-src").join("editor"),
"by-source layout must place `editor` at <target>/editor-src/editor"
);
}
use crate::cli::{
PreviewPlan, PreviewSelectors, preview_plan, render_preview_json, render_preview_tree,
};
struct PreviewFixture {
_fx_a: SyncFixture,
_fx_b: TempDir,
home: TargetDir,
work: TargetDir,
_git_dir: TempDir,
cfg: Config,
lock: Lock,
counting_inner: GitBackend,
head_a: String,
}
fn build_preview_fixture() -> PreviewFixture {
let fx_a = build_sync_fixture();
let (fx_b, url_b) = build_named_artifact_repo("lint", "rules.toml", b"[rules]\n");
let git_dir = TempDir::new().expect("shared git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
seed_git_mirror(&backend, "editor-src", &fx_a.url);
let head_a = fx_a.head_sha.clone();
let head_b = resolve_git_source(
&backend,
"lint-src",
&url_b,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let home = TargetDir::new();
let work = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.lint-src]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[sources.ghost-src]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[targets.home]\npath = \"{home_path}\"\nsources = [\"editor-src\", \"lint-src\", \"ghost-src\"]\nlayout = \"by-source\"\n\n\
[targets.work]\npath = \"{work_path}\"\nsources = [\"lint-src\"]\nlayout = \"by-source\"\n",
url_a = fx_a.url,
url_b = url_b,
home_path = home.target_path().display(),
work_path = work.target_path().display(),
);
let cfg = Config::parse(&toml).expect("multi-target multi-source config parses");
let lock = Lock {
version: 1,
sources: vec![
LockedSource {
name: "editor-src".to_owned(),
git: fx_a.url.clone(),
resolved: "main".to_owned(),
commit: head_a.clone(),
digest: "blake3:a".to_owned(),
config_digest: parsed_of(&cfg, "editor-src").config_digest(),
r#ref: None,
instance: None,
build: None,
},
LockedSource {
name: "lint-src".to_owned(),
git: url_b.clone(),
resolved: "main".to_owned(),
commit: head_b.clone(),
digest: "blake3:b".to_owned(),
config_digest: parsed_of(&cfg, "lint-src").config_digest(),
r#ref: None,
instance: None,
build: None,
},
],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
PreviewFixture {
_fx_a: fx_a,
_fx_b: fx_b,
home,
work,
_git_dir: git_dir,
cfg,
lock,
counting_inner: backend,
head_a,
}
}
impl PreviewFixture {
fn parsed(&self) -> BTreeMap<String, ParsedSource> {
self.cfg.parsed_sources().expect("sources parse")
}
fn remotes(&self) -> BTreeMap<String, String> {
let parsed = self.parsed();
resolved_remotes(&self.cfg, &parsed).expect("remotes resolve")
}
}
fn plan_target_of<'a>(plan: &'a PreviewPlan, target: &str) -> &'a PreviewTargetPlan {
plan.targets
.iter()
.find(|t| t.target == target)
.unwrap_or_else(|| panic!("preview plan must include target `{target}`"))
}
fn entry_of<'a>(tp: &'a PreviewTargetPlan, source: &str, artifact: &str) -> &'a PreviewEntry {
tp.entries
.iter()
.find(|e| e.source == source && e.artifact == artifact)
.unwrap_or_else(|| {
panic!(
"target `{}` must carry an entry for {source}/{artifact}, got {:?}",
tp.target, tp.entries
)
})
}
#[test]
fn preview_plan_includes_all_targets_with_synced_entries_at_literal_destinations() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: None,
files: false,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("an unfiltered plan builds over the seeded mirrors");
let mut targets: Vec<&str> = plan.targets.iter().map(|t| t.target.as_str()).collect();
targets.sort_unstable();
assert_eq!(
targets,
vec!["home", "work"],
"an unfiltered plan must include every configured target, got {targets:?}"
);
let home = plan_target_of(&plan, "home");
let editor = entry_of(home, "editor-src", "editor");
assert_eq!(
editor.state,
SyncState::Synced,
"editor-src/editor must be Synced"
);
assert_eq!(
editor.commit, pf.head_a,
"the synced entry carries the locked commit of editor-src"
);
assert_eq!(
editor.destination,
pf.home.target_path().join("editor-src").join("editor"),
"by-source layout must place editor at <home>/editor-src/editor (literal path, not via layout helper)"
);
let lint = entry_of(home, "lint-src", "lint");
assert_eq!(
lint.state,
SyncState::Synced,
"lint-src/lint must be Synced"
);
assert_eq!(
lint.destination,
pf.home.target_path().join("lint-src").join("lint"),
"lint must land at <home>/lint-src/lint"
);
let work = plan_target_of(&plan, "work");
assert_eq!(
entry_of(work, "lint-src", "lint").destination,
pf.work.target_path().join("lint-src").join("lint"),
"the work target's lint entry must land at <work>/lint-src/lint"
);
}
#[test]
fn preview_plan_keeps_unsynced_binding_in_the_unfiltered_plan() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: None,
files: false,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("plan builds");
let home = plan_target_of(&plan, "home");
let ghost = home
.entries
.iter()
.find(|e| e.source == "ghost-src")
.expect("an unlocked source must still appear as a per-binding annotation entry");
assert_eq!(
ghost.state,
SyncState::NotLocked,
"ghost-src has no lock entry, so it must be annotated NotLocked (not dropped, not fetched)"
);
}
#[test]
fn preview_plan_target_selector_keeps_only_that_target() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: Some("work".to_owned()),
files: false,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("plan builds filtered to work");
let targets: Vec<&str> = plan.targets.iter().map(|t| t.target.as_str()).collect();
assert_eq!(
targets,
vec!["work"],
"--target=work must filter the plan to exactly that target, got {targets:?}"
);
let work = plan_target_of(&plan, "work");
assert!(
entry_of(work, "lint-src", "lint").state == SyncState::Synced,
"the surviving work target must still carry its lint-src/lint entry"
);
}
#[test]
fn preview_plan_source_selector_keeps_only_that_underlying_source_across_targets() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: Some("lint-src".to_owned()),
target: None,
files: false,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("plan builds filtered to lint-src");
for tp in &plan.targets {
assert!(
tp.entries.iter().all(|e| e.source == "lint-src"),
"--source=lint-src must drop every entry whose underlying source != lint-src, \
target `{}` still has {:?}",
tp.target,
tp.entries
);
}
let home = plan_target_of(&plan, "home");
assert!(
entry_of(home, "lint-src", "lint").state == SyncState::Synced,
"the lint-src binding under home must survive the source filter"
);
assert!(
home.entries
.iter()
.all(|e| e.source != "editor-src" && e.source != "ghost-src"),
"editor-src and ghost-src entries must be dropped under --source=lint-src, got {:?}",
home.entries
);
}
#[test]
fn preview_plan_unknown_target_selector_errors() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: Some("nope".to_owned()),
files: false,
};
let err = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect_err("an unknown --target must be rejected, not silently produce an empty plan");
assert!(
err.to_string().contains("nope"),
"the error must name the offending target `nope`, got `{err}`"
);
}
#[test]
fn preview_plan_unknown_source_selector_errors() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: Some("nope-src".to_owned()),
target: None,
files: false,
};
let err = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect_err("an unknown --source must be rejected against the merged config");
assert!(
err.to_string().contains("nope-src"),
"the error must name the offending source `nope-src`, got `{err}`"
);
}
#[test]
fn preview_plan_is_offline_and_writes_nothing() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let counting = CountingBackend::new(&pf.counting_inner);
let sel = PreviewSelectors {
source: None,
target: None,
files: true,
};
let home_before = read_target_dir(&pf.home.target_path());
let work_before = read_target_dir(&pf.work.target_path());
let plan = preview_plan(&pf.cfg, &parsed, &remotes, &counting, Some(&pf.lock), &sel)
.expect("plan builds offline");
assert!(
!plan.targets.is_empty(),
"premise: the plan must be non-empty so the offline assertions are meaningful"
);
assert_eq!(
counting.fetch_count(),
0,
"preview_plan must perform NO fetch; commits come from the lock"
);
assert_eq!(
counting.resolve_count(),
0,
"preview_plan must reuse the locked commit, never re-resolve a refspec"
);
assert_eq!(
counting.read_count(),
0,
"even with --files, preview_plan must not export/write artifacts"
);
assert_eq!(
read_target_dir(&pf.home.target_path()),
home_before,
"preview_plan must not create, remove, or modify any file under the home target"
);
assert_eq!(
read_target_dir(&pf.work.target_path()),
work_before,
"preview_plan must not write under the work target"
);
}
#[test]
fn preview_plan_with_files_enriches_synced_entries_with_their_file_lists() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: None,
files: true,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("a --files plan builds");
let editor = entry_of(plan_target_of(&plan, "home"), "editor-src", "editor");
let mut editor_files: Vec<PathBuf> = editor.files.iter().map(|f| f.path.clone()).collect();
editor_files.sort();
assert_eq!(
editor_files,
vec![PathBuf::from("init.lua"), PathBuf::from("notes.bak")],
"with --files the editor entry must list EXACTLY the seeded editor tree \
(init.lua + the sibling notes.bak), with no over-listing or duplication, got {:?}",
editor.files
);
let lint = entry_of(plan_target_of(&plan, "home"), "lint-src", "lint");
let mut lint_files: Vec<PathBuf> = lint.files.iter().map(|f| f.path.clone()).collect();
lint_files.sort();
assert_eq!(
lint_files,
vec![PathBuf::from("rules.toml")],
"with --files the lint entry must list EXACTLY rules.toml, got {:?}",
lint.files
);
}
#[test]
fn preview_plan_without_files_leaves_entries_unenriched() {
let pf = build_preview_fixture();
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: None,
files: false,
};
let plan = preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("a no-files plan builds");
let editor = entry_of(plan_target_of(&plan, "home"), "editor-src", "editor");
assert!(
editor.files.is_empty(),
"without --files a synced entry must carry no file list, got {:?}",
editor.files
);
}
#[test]
fn source_inventory_under_artifact_root_lists_offline_without_refreshing() {
let fx = build_sync_fixture();
let resolved = resolve_git_source(
&fx.backend,
"editor-src",
&fx.url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
);
let counting = CountingBackend::new(&fx.backend);
let inventory = counting
.inventory(
&resolved.snapshot,
Some(&SourcePath::new("editor").expect("safe fixture root")),
)
.expect("inventorying a synced artifact's leaves must succeed");
let leaves: Vec<&str> = inventory
.entries
.iter()
.map(|entry| entry.path.as_str())
.collect();
assert_eq!(
leaves,
vec!["init.lua", "notes.bak"],
"a rooted final inventory must be sorted and relative to the requested `editor` root; it \
must include both the ordinary leaf and the unfiltered .bak control"
);
assert_eq!(
counting.fetch_count(),
0,
"snapshot inventory must read the seeded mirror without refreshing"
);
assert_eq!(
counting.read_count(),
0,
"inventory must not export/write anything"
);
}
#[test]
fn offer_selection_exclude_drops_the_leaf_it_matches() {
let fx = build_sync_fixture();
let resolved = resolve_git_source(
&fx.backend,
"editor-src",
&fx.url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
);
let inventory = fx
.backend
.inventory(
&resolved.snapshot,
Some(&SourcePath::new("editor").expect("safe fixture root")),
)
.expect("snapshot inventory succeeds");
let candidates: Vec<&str> = inventory
.entries
.iter()
.map(|entry| entry.path.as_str())
.collect();
assert_eq!(
candidates,
vec!["init.lua", "notes.bak"],
"premise: inventory rooted at `editor` returns root-relative candidates, so selection \
must not apply the root a second time"
);
let selection =
crate::projection::offer::OfferSelection::compile(&[], &["**/*.bak".to_owned()], None)
.expect("exclude offer compiles");
let selected = selection.select(&candidates);
assert!(
selected.contains(&"init.lua".to_string()),
"init.lua is not excluded and must be selected, got {selected:?}"
);
assert!(
!selected.contains(&"notes.bak".to_string()),
"a **/*.bak exclude must drop notes.bak from the selection, got {selected:?}"
);
}
fn rendered_plan(pf: &PreviewFixture) -> PreviewPlan {
let parsed = pf.parsed();
let remotes = pf.remotes();
let sel = PreviewSelectors {
source: None,
target: None,
files: true,
};
preview_plan(
&pf.cfg,
&parsed,
&remotes,
&pf.counting_inner,
Some(&pf.lock),
&sel,
)
.expect("the rendering fixture plan builds")
}
#[test]
fn render_preview_tree_shows_targets_bindings_destinations_and_files() {
let pf = build_preview_fixture();
let plan = rendered_plan(&pf);
let out = render_preview_tree(&plan);
assert!(
out.contains("home"),
"the tree must name the home target, got:\n{out}"
);
assert!(
out.contains("work"),
"the tree must name the work target, got:\n{out}"
);
assert!(
out.contains("editor-src"),
"the tree must name the editor-src binding, got:\n{out}"
);
assert!(
out.contains("editor"),
"the tree must name the editor artifact, got:\n{out}"
);
assert!(
out.contains("editor-src/editor")
|| out.contains(
pf.home
.target_path()
.join("editor-src")
.join("editor")
.to_string_lossy()
.as_ref()
),
"the tree must show the artifact's destination path, got:\n{out}"
);
assert!(
out.contains("init.lua"),
"with files enriched the tree must list init.lua under its artifact, got:\n{out}"
);
assert!(
out.contains("ghost-src"),
"the tree must surface the unsynced ghost-src binding, got:\n{out}"
);
let lower = out.to_lowercase();
assert!(
lower.contains("not locked") || lower.contains("needs sync") || lower.contains("notlocked"),
"an unsynced binding must render a visible annotation, got:\n{out}"
);
}
#[test]
fn render_preview_tree_warns_about_a_predicted_collision_naming_both_sources() {
let fx_a = build_named_artifact_repo("shared", "a.txt", b"from-a\n");
let fx_b = build_named_artifact_repo("shared", "b.txt", b"from-b\n");
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.src-a]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[sources.src-b]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"src-a\", \"src-b\"]\nlayout = \"flat\"\n",
fx_a.1,
fx_b.1,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two-source flat config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let commit_a = resolve_git_source(
&backend,
"src-a",
&fx_a.1,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let commit_b = resolve_git_source(
&backend,
"src-b",
&fx_b.1,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let lock = Lock {
version: 1,
sources: vec![
LockedSource {
name: "src-a".to_owned(),
git: fx_a.1.clone(),
resolved: "main".to_owned(),
commit: commit_a,
digest: "blake3:a".to_owned(),
config_digest: parsed_of(&cfg, "src-a").config_digest(),
r#ref: None,
instance: None,
build: None,
},
LockedSource {
name: "src-b".to_owned(),
git: fx_b.1.clone(),
resolved: "main".to_owned(),
commit: commit_b,
digest: "blake3:b".to_owned(),
config_digest: parsed_of(&cfg, "src-b").config_digest(),
r#ref: None,
instance: None,
build: None,
},
],
trusted_hooks: Vec::new(),
candidate_hooks: Vec::new(),
};
let sel = PreviewSelectors {
source: None,
target: None,
files: false,
};
let plan = preview_plan(&cfg, &parsed, &remotes, &backend, Some(&lock), &sel)
.expect("a colliding plan builds without error");
let out = render_preview_tree(&plan);
let lower = out.to_lowercase();
assert!(
lower.contains("collision") || lower.contains("warn") || lower.contains("conflict"),
"a predicted flat collision must render a visible warning, got:\n{out}"
);
assert!(
out.contains("src-a") && out.contains("src-b"),
"the collision warning must name BOTH contributing sources, got:\n{out}"
);
drop(fx_a);
drop(fx_b);
}
#[test]
fn render_preview_json_is_valid_json_with_targets_entries_and_collisions() {
let pf = build_preview_fixture();
let plan = rendered_plan(&pf);
let json = render_preview_json(&plan).expect("preview JSON must serialize");
let value: serde_json::Value =
serde_json::from_str(&json).expect("preview JSON must parse back into a Value");
let targets = value
.get("targets")
.and_then(serde_json::Value::as_array)
.expect("JSON must carry a `targets` array");
let home = targets
.iter()
.find(|t| t.get("target").and_then(serde_json::Value::as_str) == Some("home"))
.expect("the targets array must include the home target");
let entries = home
.get("entries")
.and_then(serde_json::Value::as_array)
.expect("each target must carry an `entries` array");
let editor = entries
.iter()
.find(|e| {
e.get("source").and_then(serde_json::Value::as_str) == Some("editor-src")
&& e.get("artifact").and_then(serde_json::Value::as_str) == Some("editor")
})
.expect("home entries must include editor-src/editor");
let dest_str = editor
.get("destination")
.and_then(serde_json::Value::as_str)
.expect("each entry must serialize its destination as a string");
assert!(
Path::new(dest_str).ends_with("editor-src/editor"),
"the editor entry's destination must resolve under editor-src/editor, got {dest_str:?}"
);
let state_str = editor
.get("state")
.and_then(serde_json::Value::as_str)
.expect("each entry must serialize its sync state as a string");
assert_eq!(
state_str.to_lowercase(),
"synced",
"the editor entry's state must mean Synced, got {state_str:?}"
);
let collisions = home
.get("collisions")
.and_then(serde_json::Value::as_array)
.expect("each target must serialize collisions as an array");
assert!(
collisions.is_empty(),
"the unfiltered by-source home plan has no flat collision, got {collisions:?}"
);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_templated_artifact_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/motd.tmpl"), b"hello {{ greeting }}!\n").unwrap();
std::fs::write(p.join("editor/static.txt"), b"plain content\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn file_named<'a>(entry: &'a PreviewEntry, name: &str) -> &'a crate::sync::PreviewFile {
entry
.files
.iter()
.find(|f| f.path == Path::new(name))
.unwrap_or_else(|| {
panic!(
"entry for `{}` must carry a file with deployed path `{name}`, got {:?}",
entry.artifact, entry.files
)
})
}
#[test]
fn preview_files_strips_tmpl_suffix_and_marks_templated_in_copy_mode() {
let (src, url) = build_templated_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let commit = resolve_git_source(
&backend,
"dotfiles",
&url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\ninclude = [\"editor\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dotfiles\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("templated copy config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let lock = lock_with(&cfg, "dotfiles", &url, &commit);
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), true)
.expect("a --files preview over a templated source builds");
let entry = preview_entry(only_plan(&plans, "dest"), "editor");
let motd = file_named(entry, "motd");
assert!(
motd.templated,
"a default-opt-in `.tmpl` file must be marked templated=true, got {:?}",
entry.files
);
assert!(
!entry.files.iter().any(|f| f.path == Path::new("motd.tmpl")),
"preview must show the DEPLOYED name `motd`, never the source `motd.tmpl`, got {:?}",
entry.files
);
let static_txt = file_named(entry, "static.txt");
assert!(
!static_txt.templated,
"a plain sibling must be templated=false and keep its name, got {:?}",
entry.files
);
drop(src);
}
#[test]
fn preview_reflects_a_narrowing_take_omitting_the_untaken_sibling() {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/a.md"), b"alpha\n").unwrap();
std::fs::write(p.join("editor/b.md"), b"beta\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let commit = resolve_git_source(
&backend,
"ed",
&url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("narrowing-take preview config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let lock = lock_with(&cfg, "ed", &url, &commit);
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, Some(&lock), true)
.expect("a --files preview over a narrowing take builds");
let plan = only_plan(&plans, "dest");
let synced = plan
.entries
.iter()
.filter(|e| e.state == SyncState::Synced)
.count();
assert_eq!(
synced, 1,
"a take of one leaf previews exactly one synced artifact; got {:?}",
plan.entries
);
let entry = preview_entry(plan, "editor/a.md");
assert_eq!(
entry.files.len(),
1,
"a single-leaf take previews as its own Leaf, not a collapsed `editor` dir of many \
children; got {:?}",
entry.files
);
file_named(entry, "a.md");
assert!(
!plan.entries.iter().any(|e| e.artifact.contains("b.md")),
"the untaken sibling editor/b.md must be absent from preview just as it is from deploy; \
a preview that read_dir'd the source tree would leak it; got {:?}",
plan.entries
);
drop(src);
}
#[test]
fn preview_files_in_link_mode_never_marks_templated() {
let (src, url) = build_templated_artifact_repo();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\ndeploy = \"link\"\ninclude = [\"editor\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dotfiles\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link-mode templated config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let plans = preview_targets(&cfg, &parsed, &remotes, &backend, None, true)
.expect("a link binding reads the working tree without lock or mirror");
let entry = preview_entry(only_plan(&plans, "dest"), "editor");
let motd = file_named(entry, "motd.tmpl");
assert!(
!motd.templated,
"link mode never renders, so a `.tmpl`-named file must stay templated=false, got {:?}",
entry.files
);
assert!(
!entry.files.iter().any(|f| f.path == Path::new("motd")),
"link mode must NOT strip the `.tmpl` suffix; the source name `motd.tmpl` deploys as-is, got {:?}",
entry.files
);
drop(src);
}
#[test]
fn render_preview_tree_annotates_templated_files_only() {
let (src, url) = build_templated_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let commit = resolve_git_source(
&backend,
"dotfiles",
&url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\ninclude = [\"editor\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dotfiles\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("templated config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let lock = lock_with(&cfg, "dotfiles", &url, &commit);
let sel = PreviewSelectors {
source: None,
target: None,
files: true,
};
let plan = preview_plan(&cfg, &parsed, &remotes, &backend, Some(&lock), &sel)
.expect("a --files plan builds");
let out = render_preview_tree(&plan);
assert!(
out.contains("motd (templated)"),
"the tree must annotate the templated file as `motd (templated)`, got:\n{out}"
);
assert!(
!out.contains("motd.tmpl"),
"the tree must not leak the source name `motd.tmpl`, got:\n{out}"
);
let static_line = out
.lines()
.find(|l| l.contains("static.txt"))
.unwrap_or_else(|| panic!("the tree must list static.txt, got:\n{out}"));
assert!(
!static_line.contains("(templated)"),
"a plain file must render with NO `(templated)` annotation, got line `{static_line}`"
);
drop(src);
}
#[test]
fn render_preview_json_carries_deployed_name_and_templated_flag() {
let (src, url) = build_templated_artifact_repo();
let git_dir = TempDir::new().expect("git dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let commit = resolve_git_source(
&backend,
"dotfiles",
&url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
)
.snapshot
.commit()
.to_string();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.dotfiles]\ngit = \"{url}\"\nbranch = \"main\"\ninclude = [\"editor\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"dotfiles\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("templated config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let lock = lock_with(&cfg, "dotfiles", &url, &commit);
let sel = PreviewSelectors {
source: None,
target: None,
files: true,
};
let plan = preview_plan(&cfg, &parsed, &remotes, &backend, Some(&lock), &sel)
.expect("a --files plan builds");
let json = render_preview_json(&plan).expect("preview JSON must serialize");
let value: serde_json::Value =
serde_json::from_str(&json).expect("preview JSON must parse back into a Value");
let files = value
.pointer("/targets/0/entries/0/files")
.and_then(serde_json::Value::as_array)
.unwrap_or_else(|| panic!("JSON must carry a per-entry `files` array, got:\n{json}"));
let find = |name: &str| {
files
.iter()
.find(|f| f.get("path").and_then(serde_json::Value::as_str) == Some(name))
.unwrap_or_else(|| panic!("files must include `{name}` by deployed path, got:\n{json}"))
};
let motd = find("motd");
assert_eq!(
motd.get("templated").and_then(serde_json::Value::as_bool),
Some(true),
"the templated file must serialize `\"templated\": true`, got {motd:?}"
);
let static_txt = find("static.txt");
assert_eq!(
static_txt
.get("templated")
.and_then(serde_json::Value::as_bool),
Some(false),
"the plain file must serialize `\"templated\": false`, got {static_txt:?}"
);
drop(src);
}
#[test]
fn plan_target_without_override_discovers_full_source_level_set() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"by-source\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("plain-binding config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let commits = one_commit(&parsed, "editor-src", &fx.head_sha);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx.backend,
&commits,
&resolved_sources,
)
.expect("projection builds over the seeded mirror");
let dest = projection
.targets
.iter()
.find(|p| p.target == "dest")
.expect("projection must include target `dest`");
let mut artifacts: Vec<String> = dest
.bindings
.iter()
.flat_map(projected_artifact_keys)
.collect();
artifacts.sort_unstable();
assert_eq!(
artifacts,
vec!["docs", "editor"],
"a plain binding (no override) inherits the source's full set, got {artifacts:?}"
);
}
#[test]
fn project_workspace_keeps_history_materialization_on_its_binding() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nlayout = \"by-source\"\n\
sources = {{ ordinary = {{ source = \"editor-src\" }}, archive = {{ source = \"editor-src\", history = true }} }}\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("two differently owned bindings parse");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let commits = one_commit(&parsed, "editor-src", &fx.head_sha);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx.backend,
&commits,
&resolved_sources,
)
.expect("projection builds over the seeded mirror");
let dest = projection
.targets
.iter()
.find(|p| p.target == "dest")
.expect("projection must include target `dest`");
let ordinary = dest
.bindings
.iter()
.find(|binding| binding.identity == "ordinary")
.expect("ordinary binding projects");
assert!(
ordinary.artifacts.iter().all(|artifact| !matches!(
&artifact.materialization,
crate::projection::model::Materialization::WholeRoot { .. }
)),
"the ordinary binding must retain normal materialization"
);
let mut ordinary_artifacts = projected_artifact_keys(ordinary);
ordinary_artifacts.sort_unstable();
assert_eq!(
ordinary_artifacts,
vec!["docs", "editor"],
"the ordinary binding must retain the source's normal artifact set"
);
let archive = dest
.bindings
.iter()
.find(|binding| binding.identity == "archive")
.expect("history binding projects");
assert!(
matches!(
archive.artifacts.as_slice(),
[artifact]
if matches!(
&artifact.materialization,
crate::projection::model::Materialization::WholeRoot { identity }
if identity == "archive"
)
),
"only the history binding must project one WholeRoot at its identity; got: {:?}",
archive.artifacts
);
}
#[test]
fn project_workspace_aggregates_per_target_warnings() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nlayout = \"by-source\"\n\
sources = {{ editor-src = {{ take = [\"*.nomatch\"] }} }}\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("warning-producing config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let commits = one_commit(&parsed, "editor-src", &fx.head_sha);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx.backend,
&commits,
&resolved_sources,
)
.expect("projection builds over the seeded mirror");
let aggregated: Vec<ProjectionWarning> = projection
.targets
.iter()
.flat_map(|t| t.warnings.iter().cloned())
.collect();
assert!(
!aggregated.is_empty(),
"premise: a `take` glob matching no offered leaf must produce a per-target \
TakeNoMatchGlob warning; got none"
);
assert_eq!(
projection.warnings, aggregated,
"the workspace-level warnings vector must aggregate every target's warnings, not drop them \
as an empty vec"
);
}
fn append_cmd(log: &Path, marker: &str) -> String {
format!("printf '%s\\n' '{marker}' >> '{}'", log.display())
}
fn append_then_fail_cmd(log: &Path, marker: &str) -> String {
format!("printf '%s\\n' '{marker}' >> '{}'; exit 7", log.display())
}
fn log_lines(log: &Path) -> Vec<String> {
match std::fs::read_to_string(log) {
Ok(text) => text
.lines()
.map(str::trim)
.filter(|l| !l.is_empty())
.map(ToOwned::to_owned)
.collect(),
Err(_) => Vec::new(),
}
}
fn config_with_target_hooks(url: &str, target_path: &Path, on_change_toml: &str) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\non_change = {on_change_toml}\n",
target_path.display(),
);
Config::parse(&toml).expect("target-hooks config parses")
}
#[cfg(unix)]
#[test]
fn pre_sync_generates_link_source_before_capture_and_discovery() {
for source_exists in [false, true] {
let fx = build_sync_fixture();
let td = TargetDir::new();
let generated = td.parent_path.join("generated");
if source_exists {
std::fs::create_dir(&generated).expect("create empty source");
}
let cfg = Config::parse(&format!(
"version = 1\n\n\
[sources.generated]\npath = '{}'\ndeploy = 'link'\n\n\
[targets.dest]\npath = '{}'\nsources = ['generated']\nlayout = 'flat'\n\n\
[hooks]\npre_sync = \"mkdir -p '{}' && printf generated > '{}/skill.md'\"\n",
generated.display(),
td.target_path().display(),
generated.display(),
generated.display(),
))
.expect("generated-source config parses");
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("pre_sync generates source before resolution");
assert!(!out.had_failures);
assert_eq!(
std::fs::read(td.target_path().join("skill.md")).expect("read deployed artifact"),
b"generated"
);
assert!(td.target_path().join("skill.md").is_symlink());
assert_eq!(out.hook_results.len(), 1);
assert_eq!(out.hook_results[0].scope, HookScope::PreSync);
}
}
#[test]
fn failing_pre_sync_aborts_before_missing_source_resolution() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let generated = td.parent_path.join("missing");
let cfg = Config::parse(&format!(
"version = 1\n\n\
[sources.generated]\npath = '{}'\ndeploy = 'link'\n\n\
[targets.dest]\npath = '{}'\nsources = ['generated']\n\n\
[hooks]\npre_sync = 'exit 7'\n",
generated.display(),
td.target_path().display(),
))
.expect("missing-source config parses");
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("failed hook is reported without resolving the missing source");
assert!(out.had_failures);
assert!(!out.deploy_failures);
assert_eq!(out.hook_results.len(), 1);
assert_eq!(out.hook_results[0].scope, HookScope::PreSync);
assert_eq!(out.hook_results[0].status, HookStatus::Failure);
assert!(out.base_lock.sources.is_empty());
assert!(
fx.registry
.all_artifacts()
.expect("read registry")
.is_empty()
);
assert!(!generated.exists());
assert!(!td.target_path().exists());
}
fn sole_hook_id(reg: &FileStateStore, target: &str) -> String {
let mut states = reg.hook_state(target).expect("load hook state");
assert_eq!(states.len(), 1, "expected exactly one recorded hook id");
states.remove(0).hook_id
}
fn recorded_hook(
reg: &FileStateStore,
target: &str,
id: &str,
) -> Option<crate::sync::state::HookState> {
reg.hook_state(target)
.expect("load hook state")
.into_iter()
.find(|h| h.hook_id == id)
}
#[test]
fn changing_sync_fires_on_change_hook_once_and_records_success() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let cfg = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!("\"{}\"", append_cmd(&log, "fired").replace('"', "\\\"")),
);
let out = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and fires the on_change hook");
assert!(
!out.had_failures,
"a clean deploy + successful hook is no failure"
);
assert_eq!(
log_lines(&log),
vec!["fired".to_owned()],
"a sync that changed the target's digest-set must run on_change EXACTLY once"
);
let id = sole_hook_id(&fx.registry, "dest");
assert!(
id.starts_with("dest#") && recorded_hook(&fx.registry, "dest", &id).is_some(),
"after the hook exits 0 its last-success digest-set must be recorded under a \
command-keyed `dest#<run>` id (INV-4); got {id:?}"
);
}
#[test]
fn noop_sync_fires_no_hook() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let cfg = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!("\"{}\"", append_cmd(&log, "fired").replace('"', "\\\"")),
);
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys and fires once");
assert_eq!(
log_lines(&log).len(),
1,
"premise: the first changing sync fires the hook once"
);
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("second sync is a clean no-op");
assert!(!second.had_failures, "a clean no-op sync must not fail");
assert_eq!(
log_lines(&log).len(),
1,
"INV-3: a no-op sync (digest-set unchanged since last hook success) must fire NOTHING — \
the log must still hold exactly the one line from the first run"
);
}
#[test]
fn failed_hook_fails_sync_keeps_files_and_refires_next_sync() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let cfg = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!(
"\"{}\"",
append_then_fail_cmd(&log, "fired").replace('"', "\\\"")
),
);
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("a hook failure surfaces via had_failures, not a hard Err");
assert!(
first.had_failures,
"a hook exiting non-zero must make the sync report failure (CLI exit non-zero)"
);
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
assert_eq!(
std::fs::read(dst.join("init.lua")).expect("deployed init.lua present"),
b"-- init\n",
"INV-2: a hook failure NEVER rolls back files — the artifact stays deployed"
);
assert_eq!(
fx.registry.hook_state("dest").expect("load hook state"),
vec![],
"INV-4: a failed hook must NOT record last-success — with this target's single \
hook failing, the registry holds NO recorded success under ANY id"
);
assert_eq!(
log_lines(&log).len(),
1,
"premise: the failing hook ran exactly once on the first sync"
);
let second = sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("second sync re-runs the never-succeeded hook");
assert!(
second.had_failures,
"the still-failing hook keeps the sync in a failed state"
);
assert_eq!(
log_lines(&log).len(),
2,
"INV-4 retry-on-next-sync: a hook with no recorded success must re-fire next sync, \
appending a second line"
);
}
#[test]
fn on_change_hooks_run_in_declaration_order_and_dedupe() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let dup = append_cmd(&log, "alpha").replace('"', "\\\"");
let beta = append_cmd(&log, "beta").replace('"', "\\\"");
let on_change = format!("[\"{dup}\", \"{beta}\", \"{dup}\"]");
let cfg = config_with_target_hooks(&fx.url, &td.target_path(), &on_change);
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync runs the deduped, ordered hook list");
assert_eq!(
log_lines(&log),
vec!["alpha".to_owned(), "beta".to_owned()],
"duplicate commands collapse to one run and survivors keep declaration order: \
alpha (once) then beta — got {:?}",
log_lines(&log)
);
}
#[test]
fn same_run_different_shell_are_distinct_hooks() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let run = append_cmd(&log, "fired").replace('"', "\\\"");
let on_change = format!(
"[{{ run = \"{run}\", shell = \"sh -c\" }}, {{ run = \"{run}\", shell = \"bash -c\" }}]"
);
let cfg = config_with_target_hooks(&fx.url, &td.target_path(), &on_change);
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync runs both same-run/different-shell hooks");
assert_eq!(
log_lines(&log).len(),
2,
"two hooks with the same run but different shell must BOTH run — they are not \
duplicates; got {:?}",
log_lines(&log)
);
let mut ids: Vec<String> = fx
.registry
.hook_state("dest")
.expect("load hook state")
.into_iter()
.map(|h| h.hook_id)
.collect();
ids.sort();
assert_eq!(
ids.len(),
2,
"each shell variant records under a DISTINCT hook id (shell is part of the id, \
matching the dedup key) — no id collision; got {ids:?}"
);
assert_ne!(ids[0], ids[1], "the two recorded hook ids must differ");
}
#[test]
fn hook_environment_exposes_phora_target_and_changed() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let target_log = td.parent_path.join("target.log");
let changed_log = td.parent_path.join("changed.log");
let names_log = td.parent_path.join("names.log");
let cmd = format!(
"printf '%s' \"$PHORA_TARGET\" > '{}'; \
printf '%s' \"$PHORA_CHANGED\" > '{}'; \
printf '%s' \"$PHORA_CHANGED_NAMES\" > '{}'",
target_log.display(),
changed_log.display(),
names_log.display(),
);
let cfg = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!("\"{}\"", cmd.replace('"', "\\\"")),
);
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync runs the env-reporting hook");
let read = |p: &Path| std::fs::read_to_string(p).expect("hook wrote the env var");
assert_eq!(
read(&target_log),
"dest",
"the hook environment must set PHORA_TARGET to the target name `dest`"
);
let deployed = td
.artifact_dst(&flat_layout(), "editor-src", "editor")
.to_string_lossy()
.into_owned();
let changed = read(&changed_log);
assert!(
changed.contains(&deployed),
"PHORA_CHANGED must hold the DEPLOYED PATH of the changed `editor` artifact \
({deployed}), got {changed:?}"
);
let names = read(&names_log);
assert!(
names.lines().any(|n| n == "editor"),
"PHORA_CHANGED_NAMES must name the changed artifact member(s) — the `editor` \
artifact whose digest moved must appear, got {names:?}"
);
}
#[test]
fn hook_runs_strictly_after_files_are_deployed() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("hook.log");
let dst = td.artifact_dst(&flat_layout(), "editor-src", "editor");
let cmd = format!(
"if [ -f '{}' ]; then printf 'deployed\\n' >> '{}'; \
else printf 'missing\\n' >> '{}'; fi",
dst.join("init.lua").display(),
log.display(),
log.display(),
);
let cfg = config_with_target_hooks(
&fx.url,
&td.target_path(),
&format!("\"{}\"", cmd.replace('"', "\\\"")),
);
sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("sync deploys then fires the hook");
assert_eq!(
log_lines(&log),
vec!["deployed".to_owned()],
"INV-2: the hook must see the artifact already on disk — files are durable \
BEFORE any hook is dispatched (strictly post-commit)"
);
}
#[test]
fn global_post_sync_runs_even_on_noop_sync() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let log = td.parent_path.join("post.log");
let post = append_cmd(&log, "post").replace('"', "\\\"");
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[hooks]\npost_sync = \"{post}\"\nwhen = \"always\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("global post_sync config parses");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync runs post_sync");
assert_eq!(
log_lines(&log).len(),
1,
"post_sync must run after the first sync"
);
sync(
&input(&cfg, None, Some(first.base_lock.clone()), None, false),
&fx.backend,
&fx.registry,
)
.expect("second no-op sync still runs post_sync");
assert_eq!(
log_lines(&log).len(),
2,
"global post_sync with when=always must run after EVERY sync, including a no-op — \
the log must hold a second line"
);
}
#[test]
fn prune_only_sync_skips_on_change_but_runs_post_sync() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let on_change_log = td.parent_path.join("on_change.log");
let post_log = td.parent_path.join("post.log");
let on_change_run = append_cmd(&on_change_log, "changed");
let post_run = append_cmd(&post_log, "post");
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.dest.hooks]\non_change = \"{}\"\n\n\
[hooks]\npost_sync = \"{}\"\nwhen = \"always\"\n",
fx.url,
td.target_path().display(),
on_change_run.replace('"', "\\\""),
post_run.replace('"', "\\\""),
);
let cfg = Config::parse(&toml).expect("removal-scenario config parses");
let first = sync(
&input(&cfg, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("first sync deploys, fires on_change, runs post_sync");
assert_eq!(
log_lines(&on_change_log).len(),
1,
"premise: the first changing sync fires on_change once"
);
assert_eq!(
log_lines(&post_log).len(),
1,
"premise: post_sync runs after the first sync"
);
let id = sole_hook_id(&fx.registry, "dest");
let mut recorded: std::collections::BTreeSet<String> = recorded_hook(&fx.registry, "dest", &id)
.expect("on_change recorded last-success on first sync")
.last_success;
recorded.insert("blake3:orphan".to_owned());
fx.registry
.record_hook_success("dest", &id, &recorded)
.expect("seed last-success with the soon-to-be-removed digest");
let orphan_dst = seed_orphan(&td, &fx.registry, &flat_layout());
let in_ = SyncInput {
base_config: &cfg,
local_config: None,
base_lock: Some(first.base_lock.clone()),
local_lock: None,
force: false,
interactive: false,
prune: true,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: None,
};
sync(&in_, &fx.backend, &fx.registry).expect("prune-only sync runs");
assert!(!orphan_dst.exists(), "premise: --prune removed the orphan");
assert_eq!(
log_lines(&on_change_log).len(),
1,
"D1: a removal-only sync must NOT fire on_change — the directional changed \
set is empty, so the log keeps exactly the one line from the first run"
);
assert_eq!(
log_lines(&post_log).len(),
2,
"D1: the global post_sync escape hatch must still run on a removal-only sync"
);
}
struct RenderHarness {
src: TempDir,
_git_dir: TempDir,
_state_dir: TempDir,
backend: GitBackend,
registry: FileStateStore,
url: String,
#[expect(
dead_code,
reason = "constructor records the resolved head for harness symmetry"
)]
head: String,
}
impl RenderHarness {
fn over(src: TempDir, url: String, head: String) -> Self {
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
Self {
src,
_git_dir: git_dir,
_state_dir: state_dir,
backend,
registry,
url,
head,
}
}
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_template_repo() -> (TempDir, String, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/motd.tmpl"), b"hello {{ greeting }}!\n").unwrap();
std::fs::write(p.join("editor/keep.txt"), b"verbatim\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let head = rev_parse(p, "HEAD");
let url = p.to_string_lossy().into_owned();
(src, url, head)
}
fn config_with_vars(source: &str, url: &str, target_path: &Path, vars_toml: &str) -> Config {
let vars_section = if vars_toml.is_empty() {
String::new()
} else {
format!("[vars]\n{vars_toml}\n")
};
let toml = format!(
"version = 1\n\n{vars_section}\
[sources.{source}]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"{source}\"]\nlayout = \"flat\"\n",
target_path.display(),
);
Config::parse(&toml).expect("vars + target config parses")
}
#[test]
fn sync_renders_tmpl_file_with_vars_and_strips_suffix() {
let (src, url, head) = build_template_repo();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "greeting = \"world\"\n");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &h.backend, &h.registry).expect("render sync deploys");
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
assert_eq!(
std::fs::read(dst.join("motd")).expect("rendered file deployed under stripped name"),
b"hello world!\n",
"a .tmpl file must render through minijinja with Config.vars and deploy under its \
.tmpl-stripped name (deployed_name), substituting {{{{ greeting }}}} -> world"
);
assert!(
!dst.join("motd.tmpl").exists(),
"the .tmpl suffix must be stripped: no `motd.tmpl` may land at the target"
);
assert!(
!out.had_failures,
"a clean render deploy must report no failures"
);
}
#[test]
fn sync_byte_copies_non_template_file_alongside_a_rendered_sibling() {
let (src, url, head) = build_template_repo();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "greeting = \"world\"\n");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &h.backend, &h.registry).expect("render sync deploys");
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
assert_eq!(
std::fs::read(dst.join("keep.txt")).expect("plain file deployed verbatim"),
b"verbatim\n",
"a non-templated file must be byte-copied unchanged, with no name rewrite, even when a \
templated sibling in the same artifact renders"
);
assert_eq!(
std::fs::read(dst.join("motd")).expect("rendered sibling deployed"),
b"hello world!\n",
"the templated sibling must render and deploy under its stripped name in the same pass \
that byte-copies the plain file"
);
}
#[test]
fn manifest_hashes_rendered_bytes_so_verify_passes_on_rendered_output() {
let (src, url, head) = build_template_repo();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "greeting = \"world\"\n");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &h.backend, &h.registry).expect("render sync deploys");
let rec = h
.registry
.artifact(&artifact_key("dest", "ed", "editor"))
.expect("registry get")
.expect("deployed record present");
let motd = rec
.files
.iter()
.find(|f| f.path == *Path::new("motd"))
.expect("manifest lists the rendered file under its stripped name `motd`");
let rendered_hash = blake3::hash(b"hello world!\n").to_hex().to_string();
assert_eq!(
motd.blake3, rendered_hash,
"INV-5: the manifest blake3 for `motd` must hash the RENDERED bytes (hello world!\\n), \
not the source template bytes; got {}",
motd.blake3
);
let report = crate::sync::verify(&cfg, &h.registry, None, &h.backend).expect("verify runs");
assert!(
report.mismatches.is_empty(),
"INV-5: verify re-hashes the deployed rendered file and must match the manifest; \
mismatches: {:?}",
report.mismatches
);
}
#[test]
fn lock_hashes_source_bytes_independent_of_vars() {
let (src_a, url_a, head_a) = build_template_repo();
let ha = RenderHarness::over(src_a, url_a, head_a);
let tda = TargetDir::new();
let cfg_a = config_with_vars("ed", &ha.url, &tda.target_path(), "greeting = \"world\"\n");
let out_a = sync(
&input(&cfg_a, None, None, None, false),
&ha.backend,
&ha.registry,
)
.expect("sync with vars A");
let locked_a = out_a
.base_lock
.find_source("ed")
.expect("source A locked")
.clone();
let (src_b, url_b, head_b) = build_template_repo();
let hb = RenderHarness::over(src_b, url_b, head_b);
let tdb = TargetDir::new();
let cfg_b = config_with_vars("ed", &hb.url, &tdb.target_path(), "greeting = \"galaxy\"\n");
let out_b = sync(
&input(&cfg_b, None, None, None, false),
&hb.backend,
&hb.registry,
)
.expect("sync with vars B");
let locked_b = out_b
.base_lock
.find_source("ed")
.expect("source B locked")
.clone();
assert_eq!(
locked_a.commit, locked_b.commit,
"premise: both syncs are over identical source content at the same commit"
);
assert_eq!(
locked_a.digest, locked_b.digest,
"INV-6: the lock digest hashes SOURCE bytes and must be IDENTICAL across two syncs whose \
only difference is [vars] (world vs galaxy); rendering must not leak into the lock"
);
}
#[test]
fn render_error_on_undefined_var_aborts_that_artifact_and_sibling_still_deploys() {
let (src, url, head) = {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("bad")).expect("mkdir bad");
std::fs::write(p.join("bad/conf.tmpl"), b"value = {{ missing }}\n").expect("write tmpl");
std::fs::create_dir_all(p.join("good")).expect("mkdir good");
std::fs::write(p.join("good/plain.txt"), b"ok\n").expect("write plain");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let head = rev_parse(p, "HEAD");
let url = p.to_string_lossy().into_owned();
(src, url, head)
};
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_one_source_one_target("multi", &h.url, "dest", &td.target_path(), "by-source");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &h.backend, &h.registry)
.expect("a render failure must warn-and-continue, not abort the whole run");
assert!(
out.had_failures,
"a strict-undefined render error must set had_failures=true (sync exits non-zero)"
);
let bad_dst = td.target_path().join("multi").join("bad");
assert!(
!bad_dst.join("conf").exists() && !bad_dst.join("conf.tmpl").exists(),
"the failing artifact must NOT be deployed (no partial/garbage file lands pre-swap), \
found something at {}",
bad_dst.display()
);
assert!(
h.registry
.artifact(&artifact_key("dest", "multi", "bad"))
.expect("get bad record")
.is_none(),
"a render-aborted artifact must leave no registry record"
);
let good_dst = td.target_path().join("multi").join("good");
assert_eq!(
std::fs::read(good_dst.join("plain.txt")).expect("good artifact deployed"),
b"ok\n",
"the sibling artifact must still deploy despite the render failure (warn-and-continue)"
);
}
#[test]
fn render_error_preserves_prior_deployed_content_pre_swap() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/conf.txt"), b"first\n").expect("write v1");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "v1"]);
let url = p.to_string_lossy().into_owned();
let h = RenderHarness::over(src, url, String::new());
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "");
let first = sync(
&input(&cfg, None, None, None, true),
&h.backend,
&h.registry,
)
.expect("first clean deploy");
assert!(!first.had_failures, "premise: first deploy is clean");
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
assert_eq!(
std::fs::read(dst.join("conf.txt")).expect("v1 deployed"),
b"first\n",
"premise: the clean v1 content must be deployed"
);
std::fs::remove_file(h.src.path().join("editor/conf.txt")).expect("rm v1");
std::fs::write(h.src.path().join("editor/conf.tmpl"), b"x = {{ nope }}\n")
.expect("write bad tmpl");
run_git(h.src.path(), &["add", "-A"]);
run_git(h.src.path(), &["commit", "-m", "v2-bad-template"]);
let out = sync(
&input(&cfg, None, None, None, true),
&h.backend,
&h.registry,
)
.expect("a render failure must not abort the run");
assert!(
out.had_failures,
"the undefined-var render must fail the run (had_failures=true)"
);
assert_eq!(
std::fs::read(dst.join("conf.txt")).expect("prior content intact"),
b"first\n",
"a render error must abort PRE-swap: the previously deployed conf.txt must remain intact, \
never clobbered by partial/garbage rendered output"
);
assert!(
!dst.join("conf").exists(),
"no partial rendered `conf` file may land when the render fails pre-swap"
);
}
#[test]
fn feature_free_config_deploys_byte_identically_with_unchanged_lock_and_manifest() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/raw.conf"), b"literal {{ greeting }} stays\n")
.expect("write raw");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let head = rev_parse(p, "HEAD");
let url = p.to_string_lossy().into_owned();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &h.backend, &h.registry).expect("feature-free sync deploys");
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
assert_eq!(
std::fs::read(dst.join("raw.conf")).expect("raw.conf deployed"),
b"literal {{ greeting }} stays\n",
"INV-8: with no vars and no template opt-in, a file containing template-looking syntax \
must be byte-copied verbatim, NOT rendered"
);
assert!(!out.had_failures, "the feature-free deploy must succeed");
let locked = out.base_lock.find_source("ed").expect("ed locked");
assert_eq!(
locked.digest, "blake3:15bd5ad64b9159e3dc1f4352478767ceea090eff38ca6d61d0354c0f0c7fcd18",
"INV-8: feature-free lock digest is a fixed source-derived value, independent of compute_digest"
);
}
#[test]
fn deployed_name_collision_within_an_artifact_is_a_clear_failure_not_last_writer_wins() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/foo"), b"plain\n").expect("write foo");
std::fs::write(p.join("editor/foo.tmpl"), b"templated {{ x }}\n").expect("write foo.tmpl");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let head = rev_parse(p, "HEAD");
let url = p.to_string_lossy().into_owned();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let cfg = config_with_vars("ed", &h.url, &td.target_path(), "x = \"v\"\n");
let in_ = input(&cfg, None, None, None, false);
let out = sync(&in_, &h.backend, &h.registry)
.expect("a deployed-name collision must be a per-artifact failure, not a whole-run abort");
assert!(
out.had_failures,
"a deployed-name collision (foo and foo.tmpl both -> foo) must report failure"
);
assert!(
h.registry
.artifact(&artifact_key("dest", "ed", "editor"))
.expect("get record")
.is_none(),
"a collided artifact must NOT be deployed (no record), never last-writer-wins"
);
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
assert!(
!dst.join("foo").exists(),
"no `foo` may land when `foo` and `foo.tmpl` collide on the deployed name"
);
}
#[test]
fn sync_redeploys_when_vars_change_without_new_commit() {
let (src, url, head) = build_template_repo();
let h = RenderHarness::over(src, url, head);
let td = TargetDir::new();
let dst = td.artifact_dst(&flat_layout(), "ed", "editor");
let cfg_a = config_with_vars("ed", &h.url, &td.target_path(), "greeting = \"world\"\n");
let out_a = sync(
&input(&cfg_a, None, None, None, false),
&h.backend,
&h.registry,
)
.expect("first vars deploy succeeds");
assert!(!out_a.had_failures, "premise: the first deploy is clean");
assert_eq!(
std::fs::read(dst.join("motd")).expect("rendered motd deployed"),
b"hello world!\n",
"premise: greeting=world renders `hello world!`"
);
let cfg_b = config_with_vars("ed", &h.url, &td.target_path(), "greeting = \"galaxy\"\n");
let out_b = sync(
&input(&cfg_b, None, Some(out_a.base_lock.clone()), None, false),
&h.backend,
&h.registry,
)
.expect("second deploy with changed vars succeeds");
assert!(
!out_b.had_failures,
"a vars-only redeploy (no new commit) must succeed"
);
assert_eq!(
std::fs::read(dst.join("motd")).expect("re-rendered motd deployed"),
b"hello galaxy!\n",
"a [vars] change at the SAME commit must trigger a redeploy: motd must re-render to \
`hello galaxy!`, not stay pinned at the prior `hello world!` because the commit/source \
digest is unchanged"
);
}
struct SyncRecordingBackend<'a> {
inner: &'a GitBackend,
fetched_urls: Mutex<Vec<String>>,
total_fetches: AtomicUsize,
}
impl<'a> SyncRecordingBackend<'a> {
fn new(inner: &'a GitBackend) -> Self {
Self {
inner,
fetched_urls: Mutex::new(Vec::new()),
total_fetches: AtomicUsize::new(0),
}
}
fn fetch_count_for(&self, url: &str) -> usize {
self.fetched_urls
.lock()
.expect("fetched_urls mutex")
.iter()
.filter(|u| u.as_str() == url)
.count()
}
fn total_fetches(&self) -> usize {
self.total_fetches.load(AtomicOrdering::SeqCst)
}
}
impl SourceStore for SyncRecordingBackend<'_> {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
if policy == ResolvePolicy::Refresh
&& let SourceLocation::Git { url } | SourceLocation::Url { url } = &request.location
{
self.total_fetches.fetch_add(1, AtomicOrdering::SeqCst);
self.fetched_urls
.lock()
.expect("fetched_urls mutex")
.push(url.clone());
}
SourceStore::resolve(self.inner, request, policy)
}
fn inventory(
&self,
snapshot: &SnapshotId,
root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
SourceStore::inventory(self.inner, snapshot, root)
}
fn read(&self, snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
SourceStore::read(self.inner, snapshot, path)
}
fn list_directory(
&self,
snapshot: &SnapshotId,
path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
SourceStore::list_directory(self.inner, snapshot, path)
}
}
fn input_with_jobs(base: &Config, jobs: usize) -> SyncInput<'_> {
SyncInput {
base_config: base,
local_config: None,
base_lock: None,
local_lock: None,
force: false,
interactive: false,
prune: false,
no_hooks: false,
no_transitive_hooks: false,
frozen: false,
lockless: false,
fast_forward: false,
resolver: None,
jobs: Some(jobs),
}
}
fn config_two_sources_one_url(url: &str, td_a: &Path, td_b: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.alpha]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[sources.beta]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.ta]\npath = \"{}\"\nsources = [\"alpha\"]\nlayout = \"flat\"\n\n\
[targets.tb]\npath = \"{}\"\nsources = [\"beta\"]\nlayout = \"flat\"\n",
td_a.display(),
td_b.display(),
);
Config::parse(&toml).expect("two-source shared-url config parses")
}
#[test]
fn two_sources_sharing_one_url_fetch_the_shared_mirror_once() {
let fx = build_sync_fixture();
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let cfg = config_two_sources_one_url(&fx.url, &td_a.target_path(), &td_b.target_path());
let recording = SyncRecordingBackend::new(&fx.backend);
let in_ = input_with_jobs(&cfg, 4);
sync(&in_, &recording, &fx.registry).expect("two sources sharing one url sync");
assert_eq!(
recording.fetch_count_for(&fx.url),
1,
"two sources resolving to the SAME upstream url must fetch the shared mirror EXACTLY once \
(dedup keyed by normalized url, not source name); got {} fetches of {:?}",
recording.fetch_count_for(&fx.url),
recording.fetched_urls.lock().expect("urls").clone(),
);
assert_eq!(
recording.total_fetches(),
1,
"the only upstream is shared, so the run must perform exactly one fetch overall"
);
}
struct UrlRefreshRecordingStore {
refreshed_sources: Mutex<Vec<String>>,
}
impl UrlRefreshRecordingStore {
fn new() -> Self {
Self {
refreshed_sources: Mutex::new(Vec::new()),
}
}
fn refreshed_source_names(&self) -> Vec<String> {
self.refreshed_sources
.lock()
.expect("refreshed_sources mutex")
.clone()
}
fn was_refreshed(&self, source: &str) -> bool {
self.refreshed_source_names().iter().any(|s| s == source)
}
}
impl SourceStore for UrlRefreshRecordingStore {
fn resolve(
&self,
request: &ResolveRequest,
policy: ResolvePolicy,
) -> SourceResult<ResolvedSource> {
let SourceLocation::Url { url } = &request.location else {
unreachable!("the integrity fixture contains only URL sources")
};
if policy == ResolvePolicy::Refresh {
self.refreshed_sources
.lock()
.expect("refreshed_sources mutex")
.push(request.name.as_str().to_owned());
}
let normalized = crate::source::NormalizedUrl::parse(url);
let commit: crate::source::Commit = "0".repeat(40).parse().expect("fixture commit");
Ok(ResolvedSource {
name: request.name.clone(),
snapshot: SnapshotId::Git {
mirror: crate::source::MirrorKey::from_url(&normalized),
commit: commit.clone(),
},
revision: crate::source::ResolvedRevision::Commit(commit),
authored_at: crate::source::SourceTimestamp::from_unix_seconds(1),
normalized_location: crate::source::SourceIdentity::Url(normalized),
})
}
fn inventory(
&self,
_snapshot: &SnapshotId,
_root: Option<&SourcePath>,
) -> SourceResult<SourceInventory> {
Ok(SourceInventory::default())
}
fn read(&self, _snapshot: &SnapshotId, path: &SourcePath) -> SourceResult<SourceEntry> {
Err(SourceError::MappedKeyNotFound {
key: PathBuf::from(path.as_str()),
})
}
fn list_directory(
&self,
_snapshot: &SnapshotId,
_path: Option<&SourcePath>,
) -> SourceResult<Vec<SourceDirectoryEntry>> {
Ok(Vec::new())
}
}
fn config_two_url_sources_one_url(url: &str, td_a: &Path, td_b: &Path) -> Config {
let toml = format!(
"version = 1\n\n\
[sources.alpha]\nurl = \"{url}\"\n\n\
[sources.beta]\nurl = \"{url}\"\n\n\
[targets.ta]\npath = \"{}\"\nsources = [\"alpha\"]\nlayout = \"flat\"\n\n\
[targets.tb]\npath = \"{}\"\nsources = [\"beta\"]\nlayout = \"flat\"\n",
td_a.display(),
td_b.display(),
);
Config::parse(&toml).expect("two url-source shared-url config parses")
}
#[test]
fn url_sources_sharing_one_url_each_fetch_so_per_source_digest_is_validated() {
let td_a = TargetDir::new();
let td_b = TargetDir::new();
let url = "https://example.com/pkg.tar.gz";
let cfg = config_two_url_sources_one_url(url, &td_a.target_path(), &td_b.target_path());
let recording = UrlRefreshRecordingStore::new();
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
resolve_sources(
&cfg,
&parsed,
&remotes,
&BTreeMap::new(),
&[],
None,
&recording,
false,
false,
Some(4),
crate::sync::progress::SILENT,
)
.expect("two url sources sharing one url resolve");
assert!(
recording.was_refreshed("alpha"),
"url-source `alpha` must be refreshed so its per-source digest is validated; \
refreshed sources were {:?}",
recording.refreshed_source_names()
);
assert!(
recording.was_refreshed("beta"),
"url-source `beta` shares the upstream url with `alpha`, but its refresh must NOT be \
deduped away: each url-source refresh validates ITS OWN integrity digest, so dropping \
beta's refresh silently skips beta's digest check (integrity-pin bypass); \
refreshed sources were {:?}",
recording.refreshed_source_names()
);
}
#[test]
fn serial_and_parallel_runs_produce_identical_lock_and_registry() {
let (src_a, url_a) = build_repo_named("alpha-repo", b"-- alpha\n");
let (src_b, url_b) = build_repo_named("beta-repo", b"-- beta\n");
let (src_c, url_c) = build_repo_named("gamma-repo", b"-- gamma\n");
let cfg_toml = |ta: &Path, tb: &Path, tc: &Path| {
let toml = format!(
"version = 1\n\n\
[sources.alpha]\ngit = \"{url_a}\"\nbranch = \"main\"\n\n\
[sources.beta]\ngit = \"{url_b}\"\nbranch = \"main\"\n\n\
[sources.gamma]\ngit = \"{url_c}\"\nbranch = \"main\"\n\n\
[targets.ta]\npath = \"{}\"\nsources = [\"alpha\"]\nlayout = \"flat\"\n\n\
[targets.tb]\npath = \"{}\"\nsources = [\"beta\"]\nlayout = \"flat\"\n\n\
[targets.tc]\npath = \"{}\"\nsources = [\"gamma\"]\nlayout = \"flat\"\n",
ta.display(),
tb.display(),
tc.display(),
);
Config::parse(&toml).expect("three-source config parses")
};
let run = |jobs: usize| -> (String, Vec<(ArtifactKey, String, String)>) {
let ta = TargetDir::new();
let tb = TargetDir::new();
let tc = TargetDir::new();
let cfg = cfg_toml(&ta.target_path(), &tb.target_path(), &tc.target_path());
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry =
FileStateStore::open(state_dir.path().to_path_buf()).expect("registry over tempdir");
let in_ = input_with_jobs(&cfg, jobs);
let out = sync(&in_, &backend, ®istry).expect("multi-source sync");
let lock_toml = toml::to_string(&out.base_lock).expect("base lock serializes to toml");
let mut records: Vec<(ArtifactKey, String, String)> = registry
.all_artifacts()
.expect("registry records")
.into_iter()
.map(|r| (r.key, r.commit, r.digest))
.collect();
records.sort_by(|a, b| {
(&a.0.target, &a.0.source, &a.0.artifact).cmp(&(
&b.0.target,
&b.0.source,
&b.0.artifact,
))
});
(lock_toml, records)
};
let (lock_serial, recs_serial) = run(1);
let (lock_parallel, recs_parallel) = run(4);
assert_eq!(
lock_serial, lock_parallel,
"serial (jobs=1) and parallel (jobs=4) runs must serialize to a byte-identical base lock; \
parallel completion order must not reorder locked sources"
);
assert_eq!(
recs_serial, recs_parallel,
"serial and parallel runs must record an identical registry record set \
(same keys, commits, digests)"
);
drop((src_a, src_b, src_c));
}
#[test]
fn source_inventory_returns_full_unfiltered_leaf_set() {
let fx = build_sync_fixture();
let resolved = resolve_git_source(
&fx.backend,
"editor-src",
&fx.url,
RevisionSpec::Branch("main".into()),
ResolvePolicy::Refresh,
);
let inventory = fx
.backend
.inventory(&resolved.snapshot, None)
.expect("inventory reads the immutable snapshot");
let leaves: Vec<String> = inventory
.entries
.iter()
.map(|entry| entry.path.as_str().to_owned())
.collect();
assert_eq!(
leaves,
vec![
"docs/readme.md".to_string(),
"editor/init.lua".to_string(),
"editor/notes.bak".to_string(),
],
"inventory returns the FULL sorted root-relative leaf set with NO selection \
applied — the `.bak` is present and nothing is excluded; got: {leaves:?}"
);
}
fn seed_recorded_artifact(reg: &FileStateStore, source: &str, artifact: &str) {
seed_recorded_artifact_at(
reg,
source,
artifact,
"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
);
}
fn seed_recorded_artifact_at(reg: &FileStateStore, source: &str, artifact: &str, commit: &str) {
let record = ArtifactRecord {
version: 1,
key: artifact_key("dest", source, artifact),
source: source.to_owned(),
commit: commit.to_owned(),
digest: "blake3:recorded".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
};
reg.put_artifact(&record).expect("seed recorded artifact");
}
#[test]
fn sealed_offer_source_dropped_a_still_wanted_artifact_is_a_hard_error() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("docs")).expect("mkdir docs");
std::fs::write(p.join("docs/readme.md"), b"# docs\n").expect("write docs");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init without editor/"]);
let url = p.to_string_lossy().into_owned();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("default-offer config parses");
seed_recorded_artifact(®istry, "editor-src", "editor");
let in_ = input(&cfg, None, None, None, false);
let Err(err) = sync(&in_, &backend, ®istry) else {
panic!(
"the default offer STILL selects `editor`, but the source dropped it: a silent source \
narrowing under an active offer must be a hard error (D9)"
);
};
let msg = err.to_string();
assert_sealed_offer_diagnostic(&msg, "dest", "editor-src", "editor");
assert!(
msg.contains("--fast-forward"),
"the pin moved off the recorded commit, so the remedy must surface `--fast-forward` as \
the way to follow the drop; got:\n{msg}"
);
assert!(
msg.contains("binding: source `editor-src` → target `dest`"),
"the rejection must name the source→target binding in plain terms; got:\n{msg}"
);
assert!(
msg.contains("pin: recorded ") && msg.contains(" → now "),
"the rejection must show the pin transition (recorded commit → resolved ref); got:\n{msg}"
);
assert!(
msg.contains("path: ") && msg.contains("editor"),
"the rejection must name the affected deploy path; got:\n{msg}"
);
drop(src);
}
#[test]
fn sealed_offer_ejecting_a_source_dropped_artifact_unblocks_sync() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("docs")).expect("mkdir docs");
std::fs::write(p.join("docs/readme.md"), b"# docs\n").expect("write docs");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init without editor/"]);
let url = p.to_string_lossy().into_owned();
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("default-offer config parses");
seed_recorded_artifact(®istry, "editor-src", "editor");
crate::sync::eject(&cfg, ®istry, "editor", "editor-src", "dest", &backend)
.expect("ejecting a managed record must succeed");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &backend, ®istry).expect(
"the diagnostic's own remedy is `eject it`; once `editor` is ejected the sealed-offer \
guard must skip it and let sync proceed — otherwise the prescribed remedy is inert",
);
drop(src);
}
fn assert_sealed_offer_diagnostic(rendered: &str, target: &str, source: &str, artifact: &str) {
use crate::diagnostic::{MATCHED_AGAINST, REMEDY, SELECTION, TO_DEBUG};
for phrase in [SELECTION, MATCHED_AGAINST, REMEDY, TO_DEBUG] {
assert!(
rendered.contains(phrase),
"the sealed-offer rejection must render `{phrase}`; got:\n{rendered}"
);
}
for named in [target, source, artifact] {
assert!(
rendered.contains(named),
"the sealed-offer rejection must name `{named}` (target/binding/artifact); got:\n{rendered}"
);
}
assert!(
rendered.contains(&format!(
"to debug: phora explain {target} {source} {artifact}"
)),
"the sealed-offer rejection must point at the attribution command for the dropped \
artifact; got:\n{rendered}"
);
}
#[test]
fn sealed_offer_take_subsetting_a_leaf_is_allowed_not_a_violation() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = {{ editor-src = {{ take = [\"docs/readme.md\"] }} }}\n\
layout = \"flat\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("take-subsetting config parses");
seed_recorded_artifact(&fx.registry, "editor-src", "editor");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &fx.backend, &fx.registry).expect(
"a leaf the source still OFFERS but `take` drops must NOT trip the sealed-offer check; \
offer-vs-take is the crux — only an un-offered recorded artifact is a D9 violation",
);
}
#[test]
fn sealed_offer_recorded_rename_dest_resolves_to_its_offered_source_leaf() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ editor-src = {{ take = [{{ \"docs/readme.md\" = \"renamed.md\" }}] }} }}\n\
layout = \"flat\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("rename-take config parses");
seed_recorded_artifact(&fx.registry, "editor-src", "renamed.md");
let in_ = input(&cfg, None, None, None, false);
sync(&in_, &fx.backend, &fx.registry).expect(
"a recorded artifact keyed by a rename DEST must be checked against its offered SOURCE \
leaf, not the dest; re-syncing an active rename whose src is still offered is not drift",
);
}
#[test]
fn sealed_offer_intentional_narrowing_does_not_block_prune_of_the_dropped_artifact() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{}\"\nbranch = \"main\"\ninclude = [\"docs/**\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
fx.url,
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("intentional-narrowing config parses");
let stale_dst = td.target_path().join("editor");
std::fs::create_dir_all(&stale_dst).expect("mkdir stale editor");
std::fs::write(stale_dst.join("init.lua"), b"-- init\n").expect("write stale file");
seed_recorded_artifact(&fx.registry, "editor-src", "editor");
let in_ = SyncInput {
prune: true,
..input(&cfg, None, None, None, false)
};
let out = sync(&in_, &fx.backend, &fx.registry).expect(
"intentionally narrowing the offer drops `editor` from BOTH the offer and the plan, so it \
is a pure orphan — `--prune` must SUCCEED and clean it, never hard-error on the seal",
);
assert!(!out.had_failures, "the narrowing prune run must succeed");
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry read")
.is_none(),
"the dropped `editor` artifact must be PRUNED, not locked behind a sealed-offer error"
);
assert!(
!stale_dst.exists(),
"the dropped artifact's on-disk files must be removed by prune"
);
}
fn init_editorless_source(p: &Path) -> (String, String) {
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("docs")).expect("mkdir docs");
std::fs::write(p.join("docs/readme.md"), b"# docs\n").expect("write docs");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init without editor/"]);
(p.to_string_lossy().into_owned(), rev_parse(p, "HEAD"))
}
#[test]
fn fast_forward_deletes_an_artifact_the_new_commit_dropped() {
let src = TempDir::new().expect("src tempdir");
let (url, _sha) = init_editorless_source(src.path());
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("default-offer config parses");
let stale_dst = td.target_path().join("editor");
std::fs::create_dir_all(&stale_dst).expect("mkdir stale editor");
std::fs::write(stale_dst.join("init.lua"), b"-- init\n").expect("write stale file");
seed_recorded_artifact(®istry, "editor-src", "editor");
let in_ = SyncInput {
fast_forward: true,
..input(&cfg, None, None, None, false)
};
let out = sync(&in_, &backend, ®istry).expect(
"fast-forward must follow the moved pin: an artifact the new commit dropped is deleted, \
not sealed",
);
assert!(!out.had_failures, "the fast-forward run must succeed");
assert!(
!stale_dst.exists(),
"fast-forward must delete the on-disk copy of the upstream-removed artifact",
);
assert!(
registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("registry read")
.is_none(),
"fast-forward must drop the record for the upstream-removed artifact",
);
drop(src);
}
fn prepare_real_pending_fast_forward_drop(
fx: &SyncFixture,
target: &TargetDir,
) -> (PathBuf, Vec<ArtifactRecord>) {
let initial =
config_one_source_one_target("editor-src", &fx.url, "dest", &target.target_path(), "flat");
let first = sync(
&input(&initial, None, None, None, false),
&fx.backend,
&fx.registry,
)
.expect("initial sync deploys genuine records before the upstream drop");
assert!(!first.had_failures, "premise: initial deploy must succeed");
let stale_dst = target.target_path().join("editor");
assert_eq!(
std::fs::read(stale_dst.join("init.lua")).ok(),
Some(b"-- init\n".to_vec()),
"premise: the soon-to-be-dropped editor artifact is genuinely deployed"
);
assert!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("lookup editor before upstream drop")
.is_some(),
"premise: the initial deploy creates a real editor registry record"
);
std::fs::remove_dir_all(fx.src.path().join("editor"))
.expect("remove editor from the source working tree");
run_git(fx.src.path(), &["add", "-A"]);
run_git(fx.src.path(), &["commit", "-m", "drop editor"]);
let new_head = rev_parse(fx.src.path(), "HEAD");
assert_ne!(
new_head,
first_commit(&first),
"premise: the source pin must advance to the commit that dropped editor"
);
let records = fx
.registry
.all_artifacts()
.expect("snapshot genuine records before fast-forward");
(stale_dst, records)
}
fn config_pending_drop_with_later_target(
dropped_url: &str,
later_url: &str,
dropped_target: &Path,
later_target: &Path,
later_pre_deploy: Option<&str>,
pre_sync: Option<&str>,
) -> Config {
let later_hooks =
pre_deploy_hook_table("later", later_pre_deploy.map(|command| (command, None)));
let global_hooks = pre_sync
.map(|command| {
format!(
"\n[hooks]\npre_sync = \"{}\"\n",
command.replace('"', "\\\"")
)
})
.unwrap_or_default();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{dropped_url}\"\nbranch = \"main\"\n\n\
[sources.later-src]\ngit = \"{later_url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n\n\
[targets.later]\npath = \"{}\"\nsources = [\"later-src\"]\nlayout = \"flat\"\n\
{later_hooks}{global_hooks}",
dropped_target.display(),
later_target.display(),
);
Config::parse(&toml).expect("pending-drop gate config parses")
}
#[test]
fn fast_forward_drop_waits_for_later_post_hook_conflict_abort_before_mutating() {
let fx = build_sync_fixture();
let dropped_target = TargetDir::new();
let (stale_dst, records_before) = prepare_real_pending_fast_forward_drop(&fx, &dropped_target);
let editor_record_before = fx
.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("lookup editor before abort")
.expect("pending drop retains its real editor record");
let (later_src, later_url) =
build_named_artifact_repo("later-art", "later.txt", b"from-later\n");
let later_target = TargetDir::new();
let later_dst = later_target.target_path().join("later-art");
let hook_value = later_dst.join("created-before-abort.txt");
let hook = format!(
"mkdir -p '{}' && printf '%s' 'later hook value' > '{}'",
later_dst.display(),
hook_value.display(),
);
let cfg = config_pending_drop_with_later_target(
&fx.url,
&later_url,
&dropped_target.target_path(),
&later_target.target_path(),
Some(&hook),
None,
);
let resolver = ScriptedResolver::new(Resolution::Abort);
let mut request = interactive_input(&cfg, None, &resolver);
request.fast_forward = true;
let result = sync(&request, &fx.backend, &fx.registry);
let Err(error) = result else {
panic!("the later hook-created Foreign conflict resolved as Abort must abort the run");
};
assert!(
matches!(error, Error::Aborted),
"the later post-hook conflict must surface Error::Aborted, got {error:?}"
);
assert_eq!(
resolver.consulted(),
1,
"only the later target's hook-created Foreign artifact requires resolution"
);
let conflict = resolver.last_conflict();
assert_eq!(
(
conflict.target.as_str(),
conflict.source.as_str(),
conflict.artifact.as_str(),
),
("later", "later-src", "later-art"),
"the sole conflict must retain the later target/source/artifact identity"
);
assert_eq!(
std::fs::read(stale_dst.join("init.lua")).ok(),
Some(b"-- init\n".to_vec()),
"fast-forward may plan the upstream drop, but the stale artifact bytes must survive a \
later Abort byte-identically"
);
assert_eq!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("lookup editor after abort"),
Some(editor_record_before),
"the pending-drop registry record must survive the later Abort byte-identically"
);
assert_eq!(
std::fs::read(&hook_value).ok(),
Some(b"later hook value".to_vec()),
"premise: the later hook ran and exposed the conflict that aborted the run"
);
assert!(
!later_dst.join("later.txt").exists(),
"no later target deployment may occur once its conflict resolves Abort"
);
assert_aborted_zero_mutation(
&fx.registry,
&records_before,
&[("dest", &dropped_target), ("later", &later_target)],
);
drop(later_src);
}
#[test]
fn fast_forward_drop_waits_for_failing_pre_sync_before_mutating() {
let fx = build_sync_fixture();
let dropped_target = TargetDir::new();
let (stale_dst, records_before) = prepare_real_pending_fast_forward_drop(&fx, &dropped_target);
let editor_record_before = fx
.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("lookup editor before pre_sync")
.expect("pending drop retains its real editor record");
let (later_src, later_url) =
build_named_artifact_repo("later-art", "later.txt", b"from-later\n");
let later_target = TargetDir::new();
let pre_sync_log = dropped_target.parent_path.join("pre-sync.log");
let failing_gate = append_then_fail_cmd(&pre_sync_log, "ran");
let cfg = config_pending_drop_with_later_target(
&fx.url,
&later_url,
&dropped_target.target_path(),
&later_target.target_path(),
None,
Some(&failing_gate),
);
let mut request = input(&cfg, None, None, None, false);
request.fast_forward = true;
let out = sync(&request, &fx.backend, &fx.registry)
.expect("a failed pre_sync gate is reported through the sync output");
assert!(
out.had_failures,
"a non-zero pre_sync gate must mark the overall sync output failed"
);
assert_eq!(
out.hook_results.len(),
1,
"the aborting run must report exactly the single configured pre_sync hook outcome"
);
let failed_gate = &out.hook_results[0];
assert_eq!(
(failed_gate.scope, failed_gate.status),
(HookScope::PreSync, HookStatus::Failure),
"the sole hook outcome must report a failed pre_sync gate"
);
assert!(
failed_gate.command.contains("ran")
&& failed_gate
.command
.contains(&pre_sync_log.display().to_string())
&& failed_gate.command.contains("exit 7"),
"the failed pre_sync outcome must identify the configured marker, log path, and exit; \
got {:?}",
failed_gate.command
);
assert_eq!(
log_lines(&pre_sync_log),
vec!["ran".to_owned()],
"premise: the failing pre_sync gate must run exactly once"
);
assert_eq!(
std::fs::read(stale_dst.join("init.lua")).ok(),
Some(b"-- init\n".to_vec()),
"a failing pre_sync gate must leave the planned fast-forward drop's bytes byte-identical"
);
assert_eq!(
fx.registry
.artifact(&artifact_key("dest", "editor-src", "editor"))
.expect("lookup editor after pre_sync failure"),
Some(editor_record_before),
"a failing pre_sync gate must leave the pending-drop registry record byte-identical"
);
assert!(
!later_target
.target_path()
.join("later-art/later.txt")
.exists(),
"no target deployment may occur after pre_sync fails"
);
assert_aborted_zero_mutation(
&fx.registry,
&records_before,
&[("dest", &dropped_target), ("later", &later_target)],
);
drop(later_src);
}
#[test]
fn ref_transition_lines_reports_only_moved_pins() {
let toml = "version = 1\n\n\
[sources.dotfiles]\ngit = \"https://example.test/repo.git\"\nbranch = \"main\"\n\n\
[targets.home]\npath = \"out\"\nsources = [\"dotfiles\"]\n";
let cfg = Config::parse(toml).expect("config parses");
let parsed = cfg.parsed_sources().expect("parsed sources");
let refspec = parsed_of(&cfg, "dotfiles").refspec();
let key = ("dotfiles".to_owned(), crate::lock::encode_ref(&refspec));
let old = "1111111111111111111111111111111111111111";
let lock = lock_with(&cfg, "dotfiles", "https://example.test/repo.git", old);
let mut moved = BTreeMap::new();
moved.insert(
key.clone(),
"2222222222222222222222222222222222222222".to_owned(),
);
let lines = ref_transition_lines(&cfg, &parsed, Some(&lock), &moved);
assert_eq!(
lines.len(),
1,
"a moved pin must emit one line; got {lines:?}"
);
assert!(
lines[0].contains("dotfiles → home") && lines[0].contains("main"),
"the transition line must name the source→target binding and the ref; got {lines:?}"
);
let mut unchanged = BTreeMap::new();
unchanged.insert(key.clone(), old.to_owned());
assert!(
ref_transition_lines(&cfg, &parsed, Some(&lock), &unchanged).is_empty(),
"an unchanged pin must stay silent so steady-state syncs print nothing"
);
assert!(
ref_transition_lines(&cfg, &parsed, None, &moved).is_empty(),
"a first sync with no prior lock must stay silent, not announce a bogus transition"
);
}
fn build_moved_recovery_source(p: &Path) -> (String, String, String) {
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).expect("mkdir editor");
std::fs::write(p.join("editor/init.lua"), b"-- init\n").expect("write editor source");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "initial with editor"]);
let c0 = rev_parse(p, "HEAD");
assert_eq!(
git_show_path(p, &c0, "editor/init.lua"),
Some(b"-- init\n".to_vec()),
"premise: C0 contains the exact source bytes represented by the recovered record"
);
std::fs::remove_dir_all(p.join("editor")).expect("remove editor at C1");
std::fs::create_dir_all(p.join("docs")).expect("mkdir docs");
std::fs::write(p.join("docs/readme.md"), b"# docs\n").expect("write docs");
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "drop editor"]);
let c1 = rev_parse(p, "HEAD");
assert_ne!(c0, c1, "premise: the source pin moves from C0 to C1");
assert!(
git_show_path(p, &c1, "editor/init.lua").is_none(),
"premise: C1 no longer contains editor/init.lua"
);
(p.to_string_lossy().into_owned(), c0, c1)
}
fn crashed_recovery_record(key: ArtifactKey, commit: &str) -> ArtifactRecord {
ArtifactRecord {
version: 1,
key,
source: "editor-src".to_owned(),
commit: commit.to_owned(),
digest: "blake3:recovered".to_owned(),
projected_at: "2026-01-01T00:00:00Z".to_owned(),
layout: "flat".to_owned(),
kind: RecordKind::Dir,
allow_symlinks: false,
preserve_executable: true,
files: vec![ManifestFile {
path: PathBuf::from("init.lua"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 8,
mtime: 1_700_000_000,
blake3: "blake3:recovered".to_owned(),
}],
directories: None,
linked: false,
history: false,
worktree_admin_id: None,
mirror_key: None,
cache_git_root: None,
vars_digest: None,
deploy_root: None,
layout_separator: None,
}
}
#[test]
fn sealed_offer_validates_crash_recovered_record_finalized_by_the_sweep() {
let src = TempDir::new().expect("src tempdir");
let p = src.path();
let (url, c0, c1) = build_moved_recovery_source(p);
let git_dir = TempDir::new().expect("git dir");
let state_dir = TempDir::new().expect("state dir");
let backend = GitBackend::new(git_dir.path().to_path_buf());
let registry = FileStateStore::open(state_dir.path().to_path_buf()).expect("open registry");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.editor-src]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"editor-src\"]\nlayout = \"flat\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("sealed-offer recovery config parses");
let crashed_dst = td.target_path().join("editor");
std::fs::create_dir_all(&crashed_dst).expect("mkdir crashed dst");
std::fs::write(crashed_dst.join("init.lua"), b"-- init\n").expect("write crashed file");
let crashed_key = artifact_key("dest", "editor-src", "editor");
let record = crashed_recovery_record(crashed_key.clone(), &c0);
let staging_base = td.parent_path.join(".phora-stage");
let staging = staging_base.join("editor-deadbeef");
let journal = Journal::open(®istry.journal_root()).expect("open journal");
journal
.append(&JournalEntry {
staging_base,
staging,
dst: crashed_dst.clone(),
record: record.clone(),
swap_completed: true,
})
.expect("seed swap-completed crash intent");
assert!(
registry
.artifact(&crashed_key)
.expect("pre-sync get")
.is_none(),
"premise: the crashed `editor` record exists only once recovery_sweep finalizes it"
);
assert!(
registry
.target_artifacts("dest")
.expect("pre-sync target listing")
.is_empty(),
"premise: the target registry is exactly empty before recovery_sweep"
);
let in_ = input(&cfg, None, None, None, false);
let Err(err) = sync(&in_, &backend, ®istry) else {
panic!(
"a crash-recovered, STILL-WANTED, source-dropped artifact must trip D9 once the \
sealed-offer snapshot is taken AFTER recovery_sweep, not before"
);
};
let rendered = err.to_string();
assert_sealed_offer_diagnostic(&rendered, "dest", "editor-src", "editor");
assert!(
rendered.contains(&c0[..8]) && rendered.contains(&c1[..8]),
"the recovery diagnostic must show the moved C0 -> C1 pin: {rendered}"
);
assert!(
rendered.contains("--fast-forward"),
"the recovered copy record is from an older immutable commit, so fast-forward may follow \
the moved pin: {rendered}"
);
assert_eq!(
registry.artifact(&crashed_key).expect("post-sync get"),
Some(record),
"the sealed sync must preserve the exact record finalized by recovery_sweep"
);
assert_eq!(
std::fs::read(crashed_dst.join("init.lua")).expect("read recovered destination"),
b"-- init\n",
"the sealed sync must preserve the crash-completed destination bytes"
);
drop(src);
}
mod leaf_granular_deploy_tests {
use super::*;
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_two_leaf_dir_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor/plug")).unwrap();
std::fs::write(p.join("editor/a.md"), b"alpha\n").unwrap();
std::fs::write(p.join("editor/b.md"), b"beta\n").unwrap();
std::fs::write(p.join("editor/plug/x.md"), b"ex\n").unwrap();
std::fs::write(p.join("editor/plug/y.md"), b"why\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn build_link_tree_with_nested_plug_dir() -> TempDir {
let td = TempDir::new().expect("link tree tempdir");
let base = td.path();
std::fs::create_dir_all(base.join("editor/plug")).expect("mkdir editor/plug");
std::fs::write(base.join("editor/a.md"), b"alpha\n").expect("write a.md");
std::fs::write(base.join("editor/b.md"), b"beta\n").expect("write b.md");
std::fs::write(base.join("editor/plug/x.md"), b"ex\n").expect("write x.md");
std::fs::write(base.join("editor/plug/y.md"), b"why\n").expect("write y.md");
td
}
fn build_flat_two_leaf_link_tree() -> TempDir {
let td = TempDir::new().expect("link tree tempdir");
let base = td.path();
std::fs::create_dir_all(base.join("editor")).expect("mkdir editor");
std::fs::write(base.join("editor/a.md"), b"alpha\n").expect("write a.md");
std::fs::write(base.join("editor/b.md"), b"beta\n").expect("write b.md");
td
}
fn by_source() -> crate::config::LayoutConfig {
crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
}
}
fn records(reg: &FileStateStore, target: &str) -> Vec<ArtifactRecord> {
reg.target_artifacts(target)
.expect("list_target must not error")
}
fn copy_shape_config(url: &str, target_path: &Path, take: Option<&str>) -> Config {
let sources = take.map_or_else(
|| "sources = [\"ed\"]".to_owned(),
|take| format!("sources = {{ ed = {{ source = \"ed\", take = [{take}] }} }}"),
);
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n{sources}\nlayout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("copy shape-transition config parses")
}
fn pruning_sync(config: &Config) -> SyncInput<'_> {
SyncInput {
prune: true,
..input(config, None, None, None, false)
}
}
fn record_keys(registry: &FileStateStore) -> BTreeSet<String> {
records(registry, "dest")
.into_iter()
.map(|record| record.key.artifact)
.collect()
}
fn build_single_leaf_repo(relative: &str, contents: &[u8]) -> (TempDir, String, String) {
let src = TempDir::new().expect("source tempdir");
run_git(src.path(), &["init", "-b", "main", "."]);
run_git(src.path(), &["config", "user.email", "test@example.com"]);
run_git(src.path(), &["config", "user.name", "Test"]);
let source_path = src.path().join(relative);
std::fs::create_dir_all(source_path.parent().expect("source leaf has a parent"))
.expect("create source parent");
std::fs::write(&source_path, contents).expect("write source leaf");
run_git(src.path(), &["add", "-A"]);
run_git(src.path(), &["commit", "-m", "initial"]);
let commit = rev_parse(src.path(), "HEAD");
let url = src.path().to_string_lossy().into_owned();
(src, url, commit)
}
#[derive(Clone, Copy)]
enum PlainOffer {
All,
TemplatesOnly,
}
fn plain_copy_config(url: &str, target_path: &Path, offer: PlainOffer) -> Config {
let include = match offer {
PlainOffer::All => "",
PlainOffer::TemplatesOnly => "include = [\"*.tmpl\"]\n",
};
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n{include}\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", collapse = false }} }}\n\
layout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("plain copy config parses")
}
#[derive(Clone, Copy)]
enum RenameTake<'a> {
Destination(&'a str),
ExcludeAll,
}
fn rename_transition_config(url: &str, target_path: &Path, take: RenameTake<'_>) -> Config {
let take = match take {
RenameTake::Destination(destination) => {
format!("take = [{{ \"docs/readme.md\" = \"{destination}\" }}]")
}
RenameTake::ExcludeAll => "take = []".to_owned(),
};
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", {take} }} }}\n\
layout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("rename transition config parses")
}
fn assert_historical_old_rename(
registry: &FileStateStore,
target_path: &Path,
) -> (ArtifactKey, PathBuf) {
assert_eq!(
record_keys(registry),
BTreeSet::from(["old.md".to_owned()]),
"premise: the first run records exactly the historical rename destination"
);
let key = artifact_key("dest", "ed", "old.md");
assert!(
registry.artifact(&key).expect("registry read").is_some(),
"premise: the historical old.md registry record exists"
);
let path = target_path.join(by_source().artifact_path("ed", "old.md"));
assert_eq!(
std::fs::read(&path).expect("read historical old.md"),
b"# docs\n",
"premise: old.md contains the renamed source bytes"
);
(key, path)
}
#[test]
fn sync_prune_offer_narrowing_does_not_invent_template_history_for_plain_record() {
let (src, url, commit) = build_single_leaf_repo("plain.txt", b"plain bytes\n");
let td = TargetDir::new();
let (_git, _state, backend, registry) = fresh_backend_registry();
let initial = plain_copy_config(&url, &td.target_path(), PlainOffer::All);
let first = sync(
&input(&initial, None, None, None, false),
&backend,
®istry,
)
.expect("first sync deploys the ordinary plain leaf");
let key = artifact_key("dest", "ed", "plain.txt");
let record = registry
.artifact(&key)
.expect("registry read")
.expect("plain record exists after first sync");
assert!(
record.vars_digest.is_none(),
"premise: plain.txt has no historical template evidence"
);
assert_eq!(
first.base_lock.find_source("ed").expect("ed lock").commit,
commit,
"the first run records the unchanged source commit"
);
let deployed = td
.target_path()
.join(by_source().artifact_path("ed", "plain.txt"));
assert_eq!(
std::fs::read(&deployed).expect("read plain deploy"),
b"plain bytes\n"
);
let narrowed = plain_copy_config(&url, &td.target_path(), PlainOffer::TemplatesOnly);
let request = SyncInput {
base_lock: Some(first.base_lock.clone()),
prune: true,
..input(&narrowed, None, None, None, false)
};
sync(&request, &backend, ®istry).expect(
"config-only narrowing to *.tmpl must prune the non-template plain record, not invent \
a historical plain.txt.tmpl source and false-seal",
);
assert_eq!(
rev_parse(src.path(), "HEAD"),
commit,
"the source commit never moved"
);
assert!(registry.artifact(&key).expect("registry read").is_none());
assert!(
record_keys(®istry).is_empty(),
"the narrowed offer desires no artifacts, so the target registry must be exactly empty"
);
assert!(
!deployed.exists(),
"the intentionally excluded plain path is pruned"
);
let fabricated = td
.target_path()
.join(by_source().artifact_path("ed", "plain.txt.tmpl"));
assert!(
!fabricated.exists(),
"offer narrowing must not fabricate a plain.txt.tmpl replacement deployment"
);
}
#[test]
fn sync_prune_rename_destination_change_uses_historical_source_provenance() {
let (src, url, commit) = build_single_leaf_repo("docs/readme.md", b"# docs\n");
let td = TargetDir::new();
let (_git, _state, backend, registry) = fresh_backend_registry();
let initial =
rename_transition_config(&url, &td.target_path(), RenameTake::Destination("old.md"));
let first = sync(
&input(&initial, None, None, None, false),
&backend,
®istry,
)
.expect("first sync deploys old.md through a rename");
let (old_key, old_path) = assert_historical_old_rename(®istry, &td.target_path());
assert_eq!(
first.base_lock.find_source("ed").expect("ed lock").commit,
commit
);
let changed =
rename_transition_config(&url, &td.target_path(), RenameTake::Destination("new.md"));
let request = SyncInput {
base_lock: Some(first.base_lock.clone()),
prune: true,
..input(&changed, None, None, None, false)
};
let second = sync(&request, &backend, ®istry).expect(
"changing only a rename destination at one source commit must converge without a \
sealed-offer error",
);
assert_eq!(
second.base_lock.find_source("ed").expect("ed lock").commit,
commit
);
assert_eq!(
rev_parse(src.path(), "HEAD"),
commit,
"the source commit never moved"
);
let new_key = artifact_key("dest", "ed", "new.md");
assert!(
registry
.artifact(&old_key)
.expect("registry read")
.is_none()
);
assert!(
registry
.artifact(&new_key)
.expect("registry read")
.is_some()
);
assert_eq!(
record_keys(®istry),
BTreeSet::from(["new.md".to_owned()]),
"the rename transition must converge on exactly the new registry key"
);
let new_path = td
.target_path()
.join(by_source().artifact_path("ed", "new.md"));
assert!(!old_path.exists(), "the old rename destination is pruned");
assert_eq!(
std::fs::read(new_path).expect("read new rename"),
b"# docs\n"
);
}
#[test]
fn sync_prune_removed_rename_take_uses_historical_source_provenance() {
let (src, url, commit) = build_single_leaf_repo("docs/readme.md", b"# docs\n");
let td = TargetDir::new();
let (_git, _state, backend, registry) = fresh_backend_registry();
let initial =
rename_transition_config(&url, &td.target_path(), RenameTake::Destination("old.md"));
let first = sync(
&input(&initial, None, None, None, false),
&backend,
®istry,
)
.expect("first sync deploys old.md through a rename");
let (old_key, old_path) = assert_historical_old_rename(®istry, &td.target_path());
assert_eq!(
first.base_lock.find_source("ed").expect("ed lock").commit,
commit
);
let removed = rename_transition_config(&url, &td.target_path(), RenameTake::ExcludeAll);
let request = SyncInput {
base_lock: Some(first.base_lock.clone()),
prune: true,
..input(&removed, None, None, None, false)
};
let second = sync(&request, &backend, ®istry).expect(
"removing a renamed take at one source commit must prune the old destination without \
a sealed-offer error",
);
assert_eq!(
second.base_lock.find_source("ed").expect("ed lock").commit,
commit
);
assert_eq!(
rev_parse(src.path(), "HEAD"),
commit,
"the source commit never moved"
);
assert!(
registry
.artifact(&old_key)
.expect("registry read")
.is_none()
);
assert!(
!old_path.exists(),
"the removed rename destination is pruned"
);
assert!(
record_keys(®istry).is_empty(),
"no replacement artifact is desired"
);
}
#[cfg(unix)]
#[test]
fn prune_rejects_backslash_manifest_child_without_reinterpreting_nested_path() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_git, _state, backend, registry) = fresh_backend_registry();
let config = copy_shape_config(&url, &td.target_path(), Some("\"editor/a.md\""));
let artifact_root = td
.target_path()
.join(by_source().artifact_path("ed", "editor"));
let literal_backslash = artifact_root.join("a\\b");
let nested_slash = artifact_root.join("a/b");
std::fs::create_dir_all(nested_slash.parent().expect("nested path has parent"))
.expect("create distinct nested control parent");
std::fs::write(&literal_backslash, b"literal backslash\n")
.expect("write literal-backslash sibling");
std::fs::write(&nested_slash, b"nested slash\n").expect("write nested slash control");
let stale_key = artifact_key("dest", "ed", "editor");
let mut stale = dir_record("dest", "ed", "editor");
stale.files = vec![ManifestFile {
path: PathBuf::from("a\\b"),
kind: crate::sync::state::ManifestEntryKind::File,
size: 18,
mtime: 1_700_000_000,
blake3: "blake3:stale".to_owned(),
}];
registry
.put_artifact(&stale)
.expect("seed non-portable historical manifest record");
let outcome = sync(&pruning_sync(&config), &backend, ®istry);
assert!(
literal_backslash.exists(),
"fail-closed prune must leave the literal-backslash path untouched"
);
assert!(
nested_slash.exists(),
"a persisted `a\\b` must never be reinterpreted as `a/b` and delete the distinct \
nested control path"
);
assert!(
registry
.artifact(&stale_key)
.expect("registry read")
.is_some(),
"invalid historical manifest data must retain its stale record"
);
if let Err(error) = outcome {
let rendered = error.to_string().to_lowercase();
assert!(
rendered.contains("manifest")
&& (rendered.contains("backslash")
|| rendered.contains("portable")
|| rendered.contains("relative")),
"a fail-closed rejection must explain the invalid persisted manifest path: {error}"
);
}
drop(src);
}
#[test]
fn sync_prune_transitions_collapsed_copy_to_per_leaf_without_sealing() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let collapsed = copy_shape_config(&url, &td.target_path(), None);
sync(
&input(&collapsed, None, None, None, false),
&backend,
®istry,
)
.expect("first sync must deploy the collapsed directory");
assert_eq!(
record_keys(®istry),
BTreeSet::from(["editor".to_owned()]),
"premise: the first sync must record one collapsed `editor` directory"
);
let per_leaf = copy_shape_config(&url, &td.target_path(), Some("\"editor/a.md\""));
let out = sync(&pruning_sync(&per_leaf), &backend, ®istry).expect(
"changing only the take shape from collapsed to per-leaf must be a normal projection \
transition, not a sealed-offer violation",
);
assert!(
!out.had_failures,
"the shape transition must converge cleanly"
);
assert_eq!(
record_keys(®istry),
BTreeSet::from(["editor/a.md".to_owned()]),
"sync --prune must replace the stale collapsed record with the desired leaf record"
);
let leaf = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
assert_eq!(
std::fs::read(&leaf).expect("the desired leaf must survive the transition"),
b"alpha\n"
);
let editor_dir = leaf
.parent()
.expect("the desired leaf has an editor parent");
for absent in ["b.md", "plug/x.md", "plug/y.md"] {
let path = editor_dir.join(absent);
assert!(
std::fs::symlink_metadata(&path).is_err(),
"collapsed→per-leaf prune must remove the unselected path `{absent}`; found {}",
path.display()
);
}
drop(src);
}
#[test]
fn sync_prune_transitions_per_leaf_copy_to_collapsed_without_sealing() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let per_leaf = copy_shape_config(&url, &td.target_path(), Some("\"editor/a.md\""));
sync(
&input(&per_leaf, None, None, None, false),
&backend,
®istry,
)
.expect("first sync must deploy one leaf");
assert_eq!(
record_keys(®istry),
BTreeSet::from(["editor/a.md".to_owned()]),
"premise: the first sync must record the narrow per-leaf projection"
);
let collapsed = copy_shape_config(&url, &td.target_path(), None);
let out = sync(&pruning_sync(&collapsed), &backend, ®istry).expect(
"widening only the take shape from per-leaf to collapsed must be a normal projection \
transition, not a sealed-offer violation",
);
assert!(
!out.had_failures,
"the shape transition must converge cleanly"
);
assert_eq!(
record_keys(®istry),
BTreeSet::from(["editor".to_owned()]),
"sync --prune must replace the stale leaf record with the collapsed directory record"
);
let dir = td
.target_path()
.join(by_source().artifact_path("ed", "editor"));
for (relative, expected) in [
("a.md", b"alpha\n".as_slice()),
("b.md", b"beta\n".as_slice()),
("plug/x.md", b"ex\n".as_slice()),
("plug/y.md", b"why\n".as_slice()),
] {
assert_eq!(
std::fs::read(dir.join(relative))
.unwrap_or_else(|error| panic!("read collapsed `{relative}`: {error}")),
expected,
"per-leaf→collapsed sync must deploy exact source bytes for `{relative}`"
);
}
drop(src);
}
#[cfg(unix)]
fn assert_exact_link(path: &Path, source_target: &Path) {
let metadata = std::fs::symlink_metadata(path).expect("deployed link must exist");
assert!(
metadata.file_type().is_symlink(),
"the deployed path must remain a symlink"
);
assert_eq!(
std::fs::read_link(path).expect("read deployed link target"),
canonical_fixture_target(source_target),
"the deployed link must keep pointing at its canonical original live source target"
);
}
#[cfg(unix)]
fn assert_only_target_record(registry: &FileStateStore, expected: &ArtifactRecord) {
assert_eq!(
records(registry, "dest"),
vec![expected.clone()],
"the target registry must contain exactly the captured editor record"
);
}
#[cfg(unix)]
#[derive(Clone, Copy, Debug)]
enum RealGitLinkSelection {
ImplicitOfferWithTargetGlob,
LeafSpecificSourceOffer,
}
#[cfg(unix)]
#[derive(Clone, Copy, Debug)]
enum LinkDropPolicy {
Ordinary,
FastForward,
}
#[cfg(unix)]
struct RealGitLinkDropFixture {
source: TempDir,
_target: TargetDir,
_git_dir: TempDir,
_state_dir: TempDir,
backend: GitBackend,
registry: FileStateStore,
config: Config,
first_lock: Lock,
record: ArtifactRecord,
destination: PathBuf,
source_target: PathBuf,
head: String,
}
#[cfg(unix)]
impl RealGitLinkDropFixture {
fn new(selection: RealGitLinkSelection) -> Self {
let source = TempDir::new().expect("real Git link source");
run_git(source.path(), &["init", "-b", "main", "."]);
run_git(source.path(), &["config", "user.email", "test@example.com"]);
run_git(source.path(), &["config", "user.name", "Test"]);
std::fs::create_dir_all(source.path().join("editor")).expect("mkdir editor");
std::fs::write(source.path().join("editor/a.md"), b"alpha\n")
.expect("write link source leaf");
run_git(source.path(), &["add", "-A"]);
run_git(source.path(), &["commit", "-m", "initial"]);
let head = rev_parse(source.path(), "HEAD");
let target = TargetDir::new();
let (source_offer, target_sources) = match selection {
RealGitLinkSelection::ImplicitOfferWithTargetGlob => (
"",
"sources = { ed = { source = \"ed\", take = [\"editor/*.md\"] } }",
),
RealGitLinkSelection::LeafSpecificSourceOffer => {
("include = [\"editor/*.md\"]\n", "sources = [\"ed\"]")
}
};
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\
{source_offer}\n\
[targets.dest]\npath = \"{}\"\n{target_sources}\nlayout = \"by-source\"\n",
source.path().display(),
target.target_path().display(),
);
let config = Config::parse(&toml).expect("real Git link-drop config parses");
let (git_dir, state_dir, backend, registry) = fresh_backend_registry();
let first = sync(
&input(&config, None, None, None, false),
&backend,
®istry,
)
.expect("first real Git link sync must deploy");
assert!(!first.had_failures, "the first link sync must be clean");
let first_records = records(®istry, "dest");
assert_eq!(
first_records.len(),
1,
"the first sync must persist exactly one collapsed link record"
);
let record = first_records[0].clone();
assert_eq!(
record.key.artifact, "editor",
"the only source leaf must collapse to the editor directory key"
);
assert!(
record.linked && record.kind == RecordKind::Dir,
"the collapsed artifact must persist as one linked Dir record"
);
assert!(
record.files.is_empty(),
"a linked directory record intentionally carries no leaf manifest"
);
assert_eq!(
record.commit, "link",
"a persisted mutable-link record uses the link sentinel"
);
let current_commit = &first
.base_lock
.find_source("ed")
.expect("resolved link source must appear in the returned lock")
.commit;
assert_eq!(
current_commit, &head,
"the current resolved identity for a real Git link source is its exact HEAD SHA"
);
assert_ne!(
&record.commit, current_commit,
"the contract requires the real persisted/current identity mismatch: link != HEAD"
);
let destination = target
.target_path()
.join(by_source().artifact_path("ed", "editor"));
let source_target = source.path().join("editor");
assert_only_target_record(®istry, &record);
assert_exact_link(&destination, &source_target);
Self {
source,
_target: target,
_git_dir: git_dir,
_state_dir: state_dir,
backend,
registry,
config,
first_lock: first.base_lock,
record,
destination,
source_target,
head,
}
}
fn delete_leaf_without_moving_head(&self) {
std::fs::remove_file(self.source.path().join("editor/a.md"))
.expect("remove live link source leaf without committing");
assert_eq!(
rev_parse(self.source.path(), "HEAD"),
self.head,
"deleting the working-tree leaf must leave real Git HEAD unchanged"
);
}
fn request(&self, policy: LinkDropPolicy) -> SyncInput<'_> {
SyncInput {
base_lock: Some(self.first_lock.clone()),
prune: true,
fast_forward: matches!(policy, LinkDropPolicy::FastForward),
..input(&self.config, None, None, None, false)
}
}
fn assert_exact_state_preserved(&self) {
assert_eq!(
self.registry
.artifact(&self.record.key)
.expect("registry read"),
Some(self.record.clone()),
"a rejected link drop must preserve the exact managed record"
);
assert_only_target_record(&self.registry, &self.record);
assert_exact_link(&self.destination, &self.source_target);
}
fn assert_fail_open_drop_happened(&self, policy: LinkDropPolicy) {
assert!(
self.registry
.artifact(&self.record.key)
.expect("registry read")
.is_none(),
"the current {policy:?} defect is expected to delete the managed link record"
);
assert!(
std::fs::symlink_metadata(&self.destination).is_err(),
"the current {policy:?} defect is expected to unlink the managed destination"
);
}
}
#[cfg(unix)]
fn assert_link_d9_diagnostic(rendered: &str) {
assert_sealed_offer_diagnostic(rendered, "dest", "ed", "editor");
assert!(
rendered.contains("restore") && rendered.contains("eject"),
"a mutable-link D9 must retain restore/eject escape guidance; got:\n{rendered}"
);
assert!(
!rendered.contains("--fast-forward"),
"a mutable link can never be authorized by commit inequality, so its D9 diagnostic \
must not recommend --fast-forward; got:\n{rendered}"
);
}
#[cfg(unix)]
fn expect_leaf_offer_link_drop_rejected(policy: LinkDropPolicy) {
let fixture = RealGitLinkDropFixture::new(RealGitLinkSelection::LeafSpecificSourceOffer);
fixture.delete_leaf_without_moving_head();
if let Err(error) = sync(
&fixture.request(policy),
&fixture.backend,
&fixture.registry,
) {
assert_link_d9_diagnostic(&error.to_string());
fixture.assert_exact_state_preserved();
} else {
fixture.assert_fail_open_drop_happened(policy);
panic!(
"B21-R3-H2: an unchanged leaf-specific source offer must not launder a \
collapsed mutable-link drop under {policy:?} prune"
);
}
}
#[cfg(unix)]
#[test]
fn sealed_offer_suffix_glob_recovers_source_leaf_from_collapsed_link_record() {
let wt = TempDir::new().expect("link working tree");
std::fs::create_dir_all(wt.path().join("editor")).expect("mkdir editor");
std::fs::write(wt.path().join("editor/a.md"), b"alpha\n").expect("write a.md");
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/*.md\"] }} }}\n\
layout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("suffix-glob link config parses");
let (_g, _s, backend, registry) = fresh_backend_registry();
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync must deploy the collapsed link");
let first_records = records(®istry, "dest");
assert_eq!(
first_records.len(),
1,
"the first sync must record exactly one target artifact"
);
let record = first_records[0].clone();
assert_eq!(record.key.artifact, "editor");
assert!(
record.linked && record.kind == RecordKind::Dir,
"premise: suffix-glob selection must collapse to one linked directory record"
);
assert_eq!(
record.commit, "link",
"premise: a live link deployment records the stable mutable-source identity"
);
let key = record.key.clone();
let dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor"));
let source_target = wt.path().join("editor");
assert_only_target_record(®istry, &record);
assert_exact_link(&dst, &source_target);
std::fs::remove_file(wt.path().join("editor/a.md")).expect("remove offered source leaf");
let Err(err) = sync(&pruning_sync(&cfg), &backend, ®istry) else {
panic!(
"removing a suffix-glob-selected source leaf must trip the sealed-offer guard; \
synthetic probe names cannot prove that a collapsed record was config-narrowed"
);
};
assert_sealed_offer_diagnostic(&err.to_string(), "dest", "ed", "editor");
assert_eq!(
registry.artifact(&key).expect("registry read"),
Some(record.clone()),
"a rejected ordinary prune must preserve the exact managed record"
);
assert_only_target_record(®istry, &record);
assert_exact_link(&dst, &source_target);
let fast_forward = SyncInput {
fast_forward: true,
prune: true,
..input(&cfg, None, None, None, false)
};
let Err(err) = sync(&fast_forward, &backend, ®istry) else {
panic!(
"fast-forward must not exempt a mutable link source whose leaf disappeared at \
the unchanged `link` identity"
);
};
assert_sealed_offer_diagnostic(&err.to_string(), "dest", "ed", "editor");
assert_eq!(
registry.artifact(&key).expect("registry read"),
Some(record.clone()),
"a rejected fast-forward prune must preserve the exact managed record"
);
assert_only_target_record(®istry, &record);
assert_exact_link(&dst, &source_target);
}
#[cfg(unix)]
#[test]
fn real_git_link_record_never_fast_forwards_by_sentinel_sha_inequality() {
let fixture =
RealGitLinkDropFixture::new(RealGitLinkSelection::ImplicitOfferWithTargetGlob);
fixture.delete_leaf_without_moving_head();
let ordinary_result = sync(
&fixture.request(LinkDropPolicy::Ordinary),
&fixture.backend,
&fixture.registry,
);
let Err(ordinary_error) = ordinary_result else {
panic!(
"ordinary prune must seal an ambiguous mutable-link drop at unchanged real Git HEAD"
);
};
let ordinary_rendered = ordinary_error.to_string();
assert_sealed_offer_diagnostic(&ordinary_rendered, "dest", "ed", "editor");
fixture.assert_exact_state_preserved();
let fast_forward_result = sync(
&fixture.request(LinkDropPolicy::FastForward),
&fixture.backend,
&fixture.registry,
);
let Err(fast_forward_error) = fast_forward_result else {
fixture.assert_fail_open_drop_happened(LinkDropPolicy::FastForward);
panic!(
"B21-R3-H1: persisted `link` != current HEAD SHA must never authorize deletion \
of a mutable linked directory under --fast-forward --prune"
);
};
assert_link_d9_diagnostic(&ordinary_rendered);
assert_link_d9_diagnostic(&fast_forward_error.to_string());
fixture.assert_exact_state_preserved();
}
#[cfg(unix)]
#[test]
fn real_git_leaf_specific_offer_seals_collapsed_link_under_ordinary_prune() {
expect_leaf_offer_link_drop_rejected(LinkDropPolicy::Ordinary);
}
#[cfg(unix)]
#[test]
fn real_git_leaf_specific_offer_seals_collapsed_link_under_fast_forward_prune() {
expect_leaf_offer_link_drop_rejected(LinkDropPolicy::FastForward);
}
#[cfg(unix)]
#[test]
fn link_wholly_taken_nested_subtree_collapses_to_one_dir_symlink_keyed_by_subtree() {
let wt = build_link_tree_with_nested_plug_dir();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/plug/**\"] }} }}\n\
layout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link collapse config parses");
let (_g, _s, backend, registry) = fresh_backend_registry();
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("link-collapse sync runs to deploy");
assert!(
!out.had_failures,
"a clean link-collapse deploy must not fail"
);
let dir_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor/plug"));
let meta = std::fs::symlink_metadata(&dir_dst)
.expect("the collapsed subtree must materialize at <target>/ed/editor/plug");
assert!(
meta.file_type().is_symlink(),
"a wholly-taken link subtree must deploy as ONE directory symlink, not N per-leaf links"
);
assert_eq!(
std::fs::read_link(&dir_dst).expect("collapsed dir symlink readable"),
canonical_fixture_target(&wt.path().join("editor/plug")),
"the collapsed symlink must point at canonical <git>/editor/plug, the taken subtree"
);
let recs = records(®istry, "dest");
assert_eq!(
recs.len(),
1,
"a wholly-taken subtree collapses to exactly ONE record, not one per top-level dir; got {recs:?}"
);
assert_eq!(
recs[0].kind,
RecordKind::Dir,
"the collapsed record is kind=Dir"
);
assert_eq!(
recs[0].key.artifact, "editor/plug",
"the collapsed record key is the TAKEN subtree key `editor/plug`, not the top-level \
`editor` dir the old discovery would record; got {:?}",
recs[0].key.artifact
);
}
#[cfg(unix)]
#[test]
fn link_within_dir_exclude_falls_back_to_per_leaf_symlinks_and_file_records() {
let wt = build_flat_two_leaf_link_tree();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\
exclude = [\"editor/b.md\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link per-leaf config parses");
let (_g, _s, backend, registry) = fresh_backend_registry();
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("per-leaf link sync runs to deploy");
assert!(
!out.had_failures,
"a clean per-leaf link deploy must not fail"
);
let kept = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
let kept_meta = std::fs::symlink_metadata(&kept)
.expect("the kept leaf must materialize as its own symlink at <target>/ed/editor/a.md");
assert!(
kept_meta.file_type().is_symlink(),
"a collapse-blocked link must deploy INDIVIDUAL per-leaf symlinks"
);
let excluded = td
.target_path()
.join(by_source().artifact_path("ed", "editor/b.md"));
assert!(
std::fs::symlink_metadata(&excluded).is_err(),
"the excluded leaf editor/b.md must be absent on disk; got a present entry"
);
let recs = records(®istry, "dest");
assert!(
recs.iter().all(|r| r.kind == RecordKind::File),
"per-leaf fallback records every kept leaf as kind=File; got {recs:?}"
);
let keys: BTreeSet<String> = recs.iter().map(|r| r.key.artifact.clone()).collect();
assert_eq!(
keys,
BTreeSet::from(["editor/a.md".to_owned()]),
"exactly the kept leaf is recorded, keyed by its leaf path; the excluded leaf is unrecorded; got {keys:?}"
);
}
#[cfg(unix)]
#[test]
fn link_leaf_points_at_source_file_not_a_directory() {
let wt = build_flat_two_leaf_link_tree();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\
exclude = [\"editor/b.md\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link per-leaf config parses");
let (_g, _s, backend, registry) = fresh_backend_registry();
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("per-leaf link sync runs to deploy");
assert!(
!out.had_failures,
"a clean per-leaf link deploy must not fail"
);
let leaf = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
let meta = std::fs::symlink_metadata(&leaf).expect("the link leaf must materialize");
assert!(
meta.file_type().is_symlink(),
"a link-mode leaf must deploy as a symlink"
);
let target = std::fs::read_link(&leaf).expect("the link leaf must be readable");
assert_eq!(
target,
canonical_fixture_target(&wt.path().join("editor/a.md")),
"a link-mode FILE leaf must point at the canonical source FILE; the kind threaded \
into link_artifact must be RecordKind::File so Windows selects symlink_file, not \
symlink_dir"
);
let target_meta =
std::fs::metadata(&target).expect("the link target must resolve to the source file");
assert!(
target_meta.is_file(),
"the link target must be a regular FILE, not a directory; got {target_meta:?}"
);
let recs = records(®istry, "dest");
assert!(
recs.iter().any(|r| r.kind == RecordKind::File && r.linked),
"a link-mode leaf must record kind=File and linked=true so the file-symlink choice is \
type-driven; got {recs:?}"
);
}
#[test]
fn copy_single_leaf_take_deploys_one_file_and_one_file_record() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/a.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("copy single-leaf take config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("copy single-leaf take must deploy");
assert!(!out.had_failures, "a clean single-leaf copy must not fail");
let leaf_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
assert_eq!(
std::fs::read(&leaf_dst).expect("the taken leaf must be a real file on disk"),
b"alpha\n",
"a copy take of one leaf must materialize exactly that file's content"
);
let other = td
.target_path()
.join(by_source().artifact_path("ed", "editor/b.md"));
assert!(
!other.exists(),
"the untaken sibling editor/b.md must not be deployed"
);
let recs = records(®istry, "dest");
assert_eq!(recs.len(), 1, "exactly one leaf record; got {recs:?}");
assert_eq!(
recs[0].kind,
RecordKind::File,
"a copy leaf records kind=File"
);
assert_eq!(
recs[0].key.artifact, "editor/a.md",
"the record key is the leaf path; got {:?}",
recs[0].key.artifact
);
drop(src);
}
#[test]
fn copy_wholly_taken_subtree_deploys_subtree_and_records_dir_kind_keyed_by_subtree() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/plug/**\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("copy whole-dir config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("copy whole-dir take must deploy");
assert!(!out.had_failures, "a clean whole-dir copy must not fail");
let dir_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor/plug"));
assert_eq!(
std::fs::read(dir_dst.join("x.md")).expect("subtree file x.md deployed"),
b"ex\n",
"a wholly-taken copy subtree must materialize the whole subtree"
);
let untaken = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
assert!(
!untaken.exists(),
"the untaken sibling editor/a.md must not be deployed"
);
let recs = records(®istry, "dest");
assert_eq!(
recs.len(),
1,
"a collapsed copy subtree is one record; got {recs:?}"
);
assert_eq!(
recs[0].kind,
RecordKind::Dir,
"a wholly-taken copy subtree records kind=Dir; got {recs:?}"
);
assert_eq!(
recs[0].key.artifact, "editor/plug",
"the record key is the TAKEN subtree key `editor/plug`, not the top-level `editor` \
dir the old discovery would record; got {:?}",
recs[0].key.artifact
);
drop(src);
}
#[test]
fn copy_take_rename_is_destructive_and_record_keyed_by_renamed_dest() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [{{ \"editor/a.md\" = \"editor/renamed.md\" }}] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("rename take config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("a rename take must deploy");
assert!(!out.had_failures, "a clean rename take must not fail");
let renamed = td
.target_path()
.join(by_source().artifact_path("ed", "editor/renamed.md"));
assert_eq!(
std::fs::read(&renamed).expect("the renamed dest must hold the source content"),
b"alpha\n",
"a rename deploys the file at its renamed destination"
);
let original = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
assert!(
!original.exists(),
"a rename is destructive: the original source path must be ABSENT on disk"
);
let recs = records(®istry, "dest");
let keys: BTreeSet<String> = recs.iter().map(|r| r.key.artifact.clone()).collect();
assert_eq!(
keys,
BTreeSet::from(["editor/renamed.md".to_owned()]),
"the record key is the RENAMED dest, never the source path; got {keys:?}"
);
drop(src);
}
#[test]
fn take_rename_to_reserved_device_name_is_rejected_at_sync() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [{{ \"editor/a.md\" = \"CON\" }}] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("reserved-dest take config parses");
let Err(err) = sync(&input(&cfg, None, None, None, false), &backend, ®istry) else {
panic!(
"a rename dest that is a reserved DOS device name (`CON`) must be REJECTED at sync \
time; safe_relpath must not be bypassed for rename dests on the live deploy path"
);
};
assert!(
err.to_string().contains("CON"),
"the rejection must name the offending dest `CON`; got: {err}"
);
assert!(
!td.target_path().join("CON").exists(),
"no write may reach the reserved-name dest"
);
drop(src);
}
#[test]
fn take_rename_to_colon_dest_is_rejected_at_sync() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [{{ \"editor/a.md\" = \"a:b\" }}] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("colon-dest take config parses");
let Err(err) = sync(&input(&cfg, None, None, None, false), &backend, ®istry) else {
panic!(
"a rename dest carrying a colon (NTFS ADS / drive separator) must be REJECTED at \
sync; the live deploy path must route rename dests through safe_relpath"
);
};
assert!(
err.to_string().contains("a:b"),
"the rejection must name the offending dest `a:b`; got: {err}"
);
drop(src);
}
#[test]
fn rename_records_one_leaf_under_active_layout_never_map() {
let (src, url) = build_two_leaf_dir_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [{{ \"editor/a.md\" = \"editor/renamed.md\" }}] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("rename layout config parses");
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("rename deploy must succeed");
let recs = records(®istry, "dest");
assert!(
recs.iter().all(|r| r.layout != "map"),
"no deployed record may carry layout == \"map\"; a rename is a normal leaf record \
under the active layout; got {recs:?}"
);
let keys: BTreeSet<String> = recs.iter().map(|r| r.key.artifact.clone()).collect();
assert_eq!(
keys,
BTreeSet::from(["editor/renamed.md".to_owned()]),
"a rename deploys exactly ONE leaf record at the renamed dest key under the active \
layout — NOT a dir record keyed `editor` (the old discovery), and NOT a map record; \
got {keys:?}"
);
assert_eq!(
recs[0].layout, "by-source",
"the rename record carries the active `by-source` layout label (canonical, matching \
config), not the Debug-lowercased `bysource`; got {recs:?}"
);
assert_eq!(
recs[0].kind,
RecordKind::File,
"a renamed single leaf records kind=File; got {recs:?}"
);
drop(src);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_templated_leaf_repo() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor")).unwrap();
std::fs::write(p.join("editor/motd.tmpl"), b"hello {{ greeting }}!\n").unwrap();
std::fs::write(p.join("editor/plain.md"), b"verbatim\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn suffix_filtered_template_config(url: &str, target_path: &Path) -> Config {
let toml = format!(
"version = 1\n\n[vars]\ngreeting = \"world\"\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\ninclude = [\"editor/*.tmpl\"]\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/*.tmpl\"], collapse = false }} }}\n\
layout = \"by-source\"\n",
target_path.display(),
);
Config::parse(&toml).expect("suffix-filtered template config parses")
}
#[test]
fn sealed_offer_template_suffix_maps_published_key_back_to_source_leaf() {
let (src, url) = build_templated_leaf_repo();
let td = TargetDir::new();
let cfg = suffix_filtered_template_config(&url, &td.target_path());
let (_g, _s, backend, registry) = fresh_backend_registry();
sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("first sync must deploy the rendered template leaf");
let key = artifact_key("dest", "ed", "editor/motd");
assert_eq!(
record_keys(®istry),
BTreeSet::from(["editor/motd".to_owned()]),
"premise: the first sync must record the suffix-stripped published key"
);
let record = registry
.artifact(&key)
.expect("registry read")
.expect("the suffix-stripped template record must exist");
assert_eq!(record.kind, RecordKind::File);
let dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor/motd"));
assert_eq!(
std::fs::read(&dst).expect("rendered template is deployed"),
b"hello world!\n"
);
std::fs::remove_file(src.path().join("editor/motd.tmpl"))
.expect("remove the offered template source leaf");
run_git(src.path(), &["add", "-A"]);
run_git(src.path(), &["commit", "-m", "drop-template"]);
let Err(err) = sync(&pruning_sync(&cfg), &backend, ®istry) else {
panic!(
"ordinary sync --prune must seal a source-dropped `.tmpl` leaf even though its \
registry key carries the suffix-stripped published name"
);
};
let rendered = err.to_string();
assert_sealed_offer_diagnostic(&rendered, "dest", "ed", "editor/motd");
assert!(
rendered.contains("--fast-forward"),
"the source pin moved, so the diagnostic must offer --fast-forward; got:\n{rendered}"
);
assert!(
registry.artifact(&key).expect("registry read").is_some() && dst.exists(),
"a rejected ordinary prune must preserve both the template record and deployed path"
);
let fast_forward = SyncInput {
fast_forward: true,
prune: true,
..input(&cfg, None, None, None, false)
};
sync(&fast_forward, &backend, ®istry)
.expect("--fast-forward may follow the moved pin and remove the dropped template");
assert!(
registry.artifact(&key).expect("registry read").is_none() && !dst.exists(),
"fast-forward must remove both the dropped template record and deployed path"
);
drop(src);
}
#[test]
fn copy_identity_templated_leaf_renders_and_strips_tmpl_suffix() {
let (src, url) = build_templated_leaf_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[vars]\ngreeting = \"world\"\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/motd.tmpl\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("templated identity-leaf take config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("templated leaf copy must deploy");
assert!(
!out.had_failures,
"a clean templated leaf copy must not fail"
);
let rendered = td
.target_path()
.join(by_source().artifact_path("ed", "editor/motd"));
assert_eq!(
std::fs::read(&rendered)
.expect("the rendered leaf must land at the .tmpl-stripped name `editor/motd`"),
b"hello world!\n",
"an identity take of a `.tmpl` leaf must RENDER through minijinja with the config \
vars and deploy at the stripped name, not the raw source bytes"
);
let raw = td
.target_path()
.join(by_source().artifact_path("ed", "editor/motd.tmpl"));
assert!(
!raw.exists(),
"the `.tmpl` suffix must be stripped: no `editor/motd.tmpl` may land at the target"
);
let recs = records(®istry, "dest");
assert_eq!(recs.len(), 1, "exactly one leaf record; got {recs:?}");
assert!(
recs[0].vars_digest.is_some(),
"a rendered copy leaf must carry a vars_digest so drift on a var change is detected; \
got {recs:?}"
);
drop(src);
}
#[test]
fn copy_rename_templated_leaf_renders_from_source_at_rename_dest() {
let (src, url) = build_templated_leaf_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[vars]\ngreeting = \"world\"\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [{{ \"editor/motd.tmpl\" = \"editor/banner\" }}] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("templated rename-leaf take config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("templated rename leaf copy must deploy");
assert!(
!out.had_failures,
"a clean templated rename leaf copy must not fail"
);
let renamed = td
.target_path()
.join(by_source().artifact_path("ed", "editor/banner"));
assert_eq!(
std::fs::read(&renamed)
.expect("the rendered renamed leaf must land at `editor/banner`"),
b"hello world!\n",
"a rename take of a `.tmpl` leaf must RENDER from the source content and land at the \
explicit rename dest, not deploy the raw template bytes"
);
let recs = records(®istry, "dest");
assert_eq!(recs.len(), 1, "exactly one leaf record; got {recs:?}");
assert!(
recs[0].vars_digest.is_some(),
"a rendered renamed copy leaf must carry a vars_digest; got {recs:?}"
);
drop(src);
}
#[test]
fn copy_non_templated_leaf_deploys_byte_identical_without_vars_digest() {
let (src, url) = build_templated_leaf_repo();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n[vars]\ngreeting = \"world\"\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/plain.md\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("non-templated leaf take config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("non-templated leaf copy must deploy");
assert!(
!out.had_failures,
"a clean non-templated leaf copy must not fail"
);
let leaf = td
.target_path()
.join(by_source().artifact_path("ed", "editor/plain.md"));
assert_eq!(
std::fs::read(&leaf).expect("the plain leaf must deploy at its source name"),
b"verbatim\n",
"a non-templated copy leaf must deploy byte-identical with no name rewrite"
);
let recs = records(®istry, "dest");
assert_eq!(recs.len(), 1, "exactly one leaf record; got {recs:?}");
assert!(
recs[0].vars_digest.is_none(),
"a non-rendered copy leaf must NOT carry a vars_digest (no spurious drift on a var \
change); got {recs:?}"
);
drop(src);
}
#[expect(
clippy::unwrap_used,
reason = "fixture setup fails loudly; git CLI is assumed present"
)]
fn build_dir_repo_with_secret() -> (TempDir, String) {
let src = TempDir::new().unwrap();
let p = src.path();
run_git(p, &["init", "-b", "main", "."]);
run_git(p, &["config", "user.email", "test@example.com"]);
run_git(p, &["config", "user.name", "Test"]);
std::fs::create_dir_all(p.join("editor/plug")).unwrap();
std::fs::write(p.join("editor/a.md"), b"alpha\n").unwrap();
std::fs::write(p.join("editor/b.md"), b"beta\n").unwrap();
std::fs::write(p.join("editor/secret"), b"top-secret\n").unwrap();
std::fs::write(p.join("editor/plug/x.md"), b"ex\n").unwrap();
std::fs::write(p.join("editor/plug/secret"), b"plug-secret\n").unwrap();
run_git(p, &["add", "-A"]);
run_git(p, &["commit", "-m", "init"]);
let url = p.to_string_lossy().into_owned();
(src, url)
}
fn build_link_tree_with_secret() -> TempDir {
let td = TempDir::new().expect("link tree tempdir");
let base = td.path();
std::fs::create_dir_all(base.join("editor")).expect("mkdir editor");
std::fs::write(base.join("editor/a.md"), b"alpha\n").expect("write a.md");
std::fs::write(base.join("editor/b.md"), b"beta\n").expect("write b.md");
std::fs::write(base.join("editor/secret"), b"top-secret\n").expect("write secret");
td
}
#[test]
fn copy_collapse_with_offer_exclude_prunes_excluded_child() {
let (src, url) = build_dir_repo_with_secret();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\
include = [\"editor/**\"]\nexclude = [\"editor/secret\", \"editor/plug/**\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("copy collapse offer-exclude config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("copy collapse deploy must run");
assert!(!out.had_failures, "a clean copy collapse must not fail");
let dir_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor"));
assert_eq!(
std::fs::read(dir_dst.join("a.md")).expect("kept leaf editor/a.md deployed"),
b"alpha\n",
"the offered-kept leaf must materialize under the collapsed dir"
);
let leaked = dir_dst.join("secret");
assert!(
std::fs::symlink_metadata(&leaked).is_err(),
"an OFFER-EXCLUDED child must NOT leak into a copy CollapsedDir; found {}",
leaked.display()
);
let recs = records(®istry, "dest");
assert_eq!(
recs.len(),
1,
"a copy collapse is one dir record; got {recs:?}"
);
let leaked_in_record = recs[0]
.files
.iter()
.any(|f| f.path.file_name().is_some_and(|n| n == "secret"));
assert!(
!leaked_in_record,
"the excluded child must NOT appear in the dir record's files; got {:?}",
recs[0].files
);
drop(src);
}
#[test]
fn copy_partial_take_recollapse_with_offer_exclude_prunes_excluded_child() {
let (src, url) = build_dir_repo_with_secret();
let td = TargetDir::new();
let (_g, _s, backend, registry) = fresh_backend_registry();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{url}\"\nbranch = \"main\"\n\
include = [\"editor/**\"]\nexclude = [\"editor/plug/secret\"]\n\n\
[targets.dest]\npath = \"{}\"\n\
sources = {{ ed = {{ source = \"ed\", take = [\"editor/b.md\", \"editor/plug/**\"] }} }}\n\
layout = \"by-source\"\n",
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("copy partial-take recollapse config parses");
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("copy partial-take recollapse deploy must run");
assert!(
!out.had_failures,
"a clean partial-take recollapse must not fail"
);
let plug_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor/plug"));
assert_eq!(
std::fs::read(plug_dst.join("x.md")).expect("kept leaf editor/plug/x.md deployed"),
b"ex\n",
"the kept subtree leaf must materialize under the re-collapsed plug dir"
);
let leaked = plug_dst.join("secret");
assert!(
std::fs::symlink_metadata(&leaked).is_err(),
"an OFFER-EXCLUDED child under the re-collapsed dir must NOT leak; found {}",
leaked.display()
);
let recs = records(®istry, "dest");
let plug_rec = recs
.iter()
.find(|r| r.key.artifact == "editor/plug")
.expect("a re-collapsed plug dir record must exist");
let leaked_in_record = plug_rec
.files
.iter()
.any(|f| f.path.file_name().is_some_and(|n| n == "secret"));
assert!(
!leaked_in_record,
"the excluded child must NOT appear in the re-collapsed dir record's files; got {:?}",
plug_rec.files
);
drop(src);
}
#[cfg(unix)]
#[test]
fn link_offer_excluded_physical_child_falls_back_to_per_leaf_and_omits_excluded() {
let wt = build_link_tree_with_secret();
let td = TargetDir::new();
let toml = format!(
"version = 1\n\n\
[sources.ed]\ngit = \"{}\"\nbranch = \"main\"\ndeploy = \"link\"\n\
include = [\"editor/**\"]\nexclude = [\"editor/secret\"]\n\n\
[targets.dest]\npath = \"{}\"\nsources = [\"ed\"]\nlayout = \"by-source\"\n",
wt.path().display(),
td.target_path().display(),
);
let cfg = Config::parse(&toml).expect("link offer-exclude config parses");
let (_g, _s, backend, registry) = fresh_backend_registry();
let out = sync(&input(&cfg, None, None, None, false), &backend, ®istry)
.expect("link offer-exclude sync runs to deploy");
assert!(
!out.had_failures,
"a clean link offer-exclude deploy must not fail"
);
let dir_dst = td
.target_path()
.join(by_source().artifact_path("ed", "editor"));
let dir_is_symlink =
std::fs::symlink_metadata(&dir_dst).is_ok_and(|m| m.file_type().is_symlink());
assert!(
!dir_is_symlink,
"an offer-excluded physical child must block the dir symlink so the excluded child \
cannot leak through it; the dir must NOT be one symlink"
);
let kept = td
.target_path()
.join(by_source().artifact_path("ed", "editor/a.md"));
assert!(
std::fs::symlink_metadata(&kept)
.expect("kept leaf editor/a.md symlink present")
.file_type()
.is_symlink(),
"a collapse-blocked link must deploy individual per-leaf symlinks"
);
let excluded = td
.target_path()
.join(by_source().artifact_path("ed", "editor/secret"));
assert!(
std::fs::symlink_metadata(&excluded).is_err(),
"the offer-excluded leaf editor/secret must be absent on disk"
);
let recs = records(®istry, "dest");
let keys: BTreeSet<String> = recs.iter().map(|r| r.key.artifact.clone()).collect();
assert!(
!keys.contains("editor/secret"),
"the offer-excluded leaf must not be recorded; got {keys:?}"
);
}
}
fn by_source_layout() -> crate::config::LayoutConfig {
crate::config::LayoutConfig {
kind: LayoutKind::BySource,
separator: String::new(),
}
}
#[test]
fn prune_deletes_orphan_files_using_persisted_deploy_root() {
let orphan_root = TempDir::new().expect("orphan deploy root");
let orphan_dst = orphan_root
.path()
.join(by_source_layout().artifact_path("ed", "orphaned"));
std::fs::create_dir_all(orphan_dst.parent().expect("orphan parent"))
.expect("mkdir orphan parent");
std::fs::write(&orphan_dst, b"orphaned bytes\n").expect("plant orphan file on disk");
let registry = fx_registry();
let mut orphan = leaf_record("gone", "ed", "orphaned");
orphan.deploy_root = Some(orphan_root.path().to_string_lossy().into_owned());
registry
.put_artifact(&orphan)
.expect("seed orphan record carrying a persisted deploy_root");
let legacy_key = artifact_key("also-gone", "ed", "legacy");
registry
.put_artifact(&leaf_record("also-gone", "ed", "legacy"))
.expect("seed legacy pathless orphan record (deploy_root: None)");
let cfg = Config::parse(
"version = 1\n\n[sources.ed]\ngit = \"https://example.com/ed.git\"\nbranch = \"main\"\n",
)
.expect("source-only config parses");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let commits = one_commit(&parsed, "ed", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
let resolved_sources = BTreeMap::new();
let protected = test_protected(&std::env::temp_dir());
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx_backend(),
&commits,
&resolved_sources,
)
.expect("empty-target projection builds");
prune_projected(&projection, &cfg, ®istry, &protected)
.expect("prune runs over an orphaned registry");
assert!(
!orphan_dst.exists(),
"prune must physically DELETE the orphan's on-disk file at {} using the persisted \
deploy_root; today an out-of-config target skips file deletion and strands the file",
orphan_dst.display()
);
assert!(
registry
.artifact(&artifact_key("gone", "ed", "orphaned"))
.expect("registry read")
.is_none(),
"prune must drop the orphan record AFTER removing its files"
);
assert!(
registry
.artifact(&legacy_key)
.expect("registry read")
.is_none(),
"a legacy pathless orphan (deploy_root: None) gets record-only cleanup"
);
}
#[test]
fn prune_keeps_orphan_record_when_its_path_overlaps_a_live_destination() {
let (src, _git, backend, url, commit) = seed_two_leaf_dir_repo();
let td = TargetDir::new();
let cfg = config_one_source_one_target("ed", &url, "dest", &td.target_path(), "by-source");
let live_leaf = td.artifact_dst(&by_source_layout(), "ed", "editor/a.md");
std::fs::create_dir_all(live_leaf.parent().expect("live parent")).expect("mkdir live parent");
std::fs::write(&live_leaf, b"alpha\n").expect("plant the live deployed leaf");
let registry = fx_registry();
let mut orphan = dir_record("gone", "ed", "editor");
orphan.deploy_root = Some(td.target_path().to_string_lossy().into_owned());
registry
.put_artifact(&orphan)
.expect("seed overlapping orphan record");
prune_one(&cfg, &backend, ®istry, &commit).expect("prune runs");
assert!(
live_leaf.exists(),
"overlap guard: prune must NOT delete the live leaf {} that lies under the orphan's \
reconstructed directory path",
live_leaf.display()
);
assert!(
registry
.artifact(&artifact_key("gone", "ed", "editor"))
.expect("registry read")
.is_some(),
"overlap guard skips+keeps: an orphan record whose files overlap a live destination must \
be KEPT, not dropped (a dropped-but-file-kept record would leak, per BUG-PRUNE-004)"
);
drop(src);
}
#[test]
fn undecided_conflict_at_apply_errors_unresolved() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target(
"editor-src",
&fx.url,
"dest",
&td.target_path(),
"by-source",
);
let target = cfg.targets.get("dest").expect("dest target present");
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let commits = one_commit(&parsed, "editor-src", &fx.head_sha);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx.backend,
&commits,
&resolved_sources,
)
.expect("projection builds over the seeded mirror");
let target_projection = projection
.targets
.iter()
.find(|p| p.target == "dest")
.expect("projection must include target `dest`");
let changes: Vec<crate::sync::model::SyncChange> = target_projection
.bindings
.iter()
.flat_map(|binding| {
binding
.artifacts
.iter()
.map(move |artifact| crate::sync::model::SyncChange::Conflict {
target: "dest".to_owned(),
source: binding.identity.clone(),
artifact: artifact.materialization.published_key().to_owned(),
kind: crate::sync::model::ConflictKind::Foreign,
})
})
.collect();
assert!(
!changes.is_empty(),
"premise: the projection must yield at least one artifact to conflict on"
);
let changeset = crate::sync::model::ChangeSet { changes };
let observed = crate::sync::model::ObservedProjectState::<ArtifactRecord> {
artifacts: Vec::new(),
};
let reconciliation = Reconciliation::new(&changeset, &observed, &[], BTreeMap::new());
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
let protected = test_protected(fx.src.path());
let run = TargetRun {
parsed: &parsed,
target_name: "dest",
target,
remotes: &remotes,
resolved_sources: &resolved_sources,
vars: &BTreeMap::new(),
protected: &protected,
content_store: None,
};
let err = deploy_reconciled_target(
run,
target_projection,
&reconciliation,
&fx.backend,
&fx.registry,
&journal,
)
.expect_err(
"a Conflict reaching apply with no preflight decision must fail closed, not deploy or skip",
);
let msg = err.to_string();
assert!(
msg.contains("unresolved conflict"),
"the apply path must reject an undecided Conflict with an `unresolved conflict` diagnostic, \
got: {msg}"
);
}
#[test]
fn observe_workspace_full_registry_scan_follows_prune_policy() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target(
"editor-src",
&fx.url,
"dest",
&td.target_path(),
"by-source",
);
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
let commits = one_commit(&parsed, "editor-src", &fx.head_sha);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let projection = project_workspace(
&cfg,
&parsed,
&remotes,
&fx.backend,
&commits,
&resolved_sources,
)
.expect("projection builds");
let protected = test_protected(fx.src.path());
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
let orphan_record = linked_flat_record("retired", "legacy", "orphan");
let orphan_key = orphan_record.key.clone();
fx.registry
.put_artifact(&orphan_record)
.expect("seed registry-only orphan absent from projection");
let registry = FullScanCountingRegistry::new(&fx.registry);
for (prune, expected_scans) in [(false, 0), (true, 1)] {
registry.reset();
let mut si = input(&cfg, None, None, None, false);
si.prune = prune;
let ctx = DeployAll {
config: &cfg,
parsed: &parsed,
remotes: &remotes,
resolved_sources: &resolved_sources,
projection: &projection,
protected: &protected,
content_store: None,
input: &si,
backend: &fx.backend,
registry: ®istry,
journal: &journal,
};
let observed = super::observe::observe_workspace(&ctx, &projection)
.expect("workspace observation succeeds");
let observed_orphan = observed.artifacts.iter().any(|entry| {
matches!(
&entry.observation,
crate::sync::model::ObservedArtifact::Managed(managed)
if managed.record.key == orphan_key
)
});
assert_eq!(
registry.full_scan_count(),
expected_scans,
"KeepOrphans must perform no full registry scan; RemoveOrphans must perform exactly one"
);
assert_eq!(
observed_orphan, prune,
"the seeded registry-only row must appear only when RemoveOrphans scans registry state"
);
}
}
#[test]
fn observe_workspace_rejects_duplicate_triplet() {
let fx = build_sync_fixture();
let td = TargetDir::new();
let cfg = config_one_source_one_target(
"editor-src",
&fx.url,
"dest",
&td.target_path(),
"by-source",
);
let parsed = cfg.parsed_sources().expect("sources parse");
let remotes = resolved_remotes(&cfg, &parsed).expect("remotes resolve");
seed_git_mirror(&fx.backend, "editor-src", &fx.url);
let resolved_sources = resolved_git_map(&fx.backend, "editor-src", &fx.url, &fx.head_sha);
let protected = test_protected(fx.src.path());
let journal = Journal::open(&fx.registry.journal_root()).expect("open journal");
let colliding_artifact = || crate::projection::model::ProjectedArtifact {
destination: crate::projection::model::TargetPath::new("editor").expect("valid dest"),
source: crate::projection::model::ResolvedSourceRef::new("editor-src", &fx.head_sha),
materialization: crate::projection::model::Materialization::CollapsedDir {
dir: "editor".to_owned(),
},
kept_leaves: Vec::new(),
leaves: Vec::new(),
};
let binding = crate::projection::model::BindingProjection {
identity: "editor-src".to_owned(),
source: "editor-src".to_owned(),
commit: fx.head_sha.clone(),
attribution: crate::projection::model::BindingAttribution::default(),
artifacts: vec![colliding_artifact(), colliding_artifact()],
warnings: Vec::new(),
};
let projection = crate::projection::model::Projection {
targets: vec![crate::projection::model::TargetProjection {
target: "dest".to_owned(),
bindings: vec![binding],
artifacts: Vec::new(),
warnings: Vec::new(),
}],
warnings: Vec::new(),
};
let si = input(&cfg, None, None, None, false);
let ctx = DeployAll {
config: &cfg,
parsed: &parsed,
remotes: &remotes,
resolved_sources: &resolved_sources,
projection: &projection,
protected: &protected,
content_store: None,
input: &si,
backend: &fx.backend,
registry: &fx.registry,
journal: &journal,
};
let err = super::observe::observe_workspace(&ctx, &projection).expect_err(
"two observations on the same (target, identity, published_key) triplet must fail closed, \
not silently collapse to a last-wins single entry",
);
let msg = err.to_string();
assert!(
msg.contains("duplicate observed artifact"),
"the observation producer must reject a duplicate triplet with a `duplicate observed \
artifact` diagnostic, got: {msg}"
);
}