mod common;
use common::*;
#[tokio::test]
async fn test_dependency_graph_and_finish_blocking() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
commands::start_command(
"Refactor auth".to_string(),
true, false, false,
None, None, None, None,
None, false).await?;
let branches = git_manager.list_branches()?;
let auth_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
commands::start_command(
"Add OAuth".to_string(),
true, false, false,
None,
Some(vec![auth_branch.clone()]),
None,
None,
None,
false,
).await?;
let branches = git_manager.list_branches()?;
let oauth_branch = branches.iter()
.filter(|b| b.name.starts_with("codetree_"))
.find(|b| b.name != auth_branch)
.map(|b| b.name.clone())
.unwrap();
let result = commands::finish_command(Some(oauth_branch.clone()), None, false).await;
assert!(result.is_err(), "Should not be able to finish OAuth before auth is finished");
commands::finish_command(Some(auth_branch.clone()), None, false).await?;
commands::finish_command(Some(oauth_branch.clone()), None, false).await?;
Ok(())
}
#[tokio::test]
async fn test_file_locking_acquired_on_start() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"lock test".to_string(),
true, true, false,
Some(vec!["src/a.rs".to_string(), "src/b.rs".to_string()]),
None, None, None,
None,
false,
).await?;
let locks_path = repo_path.join(".codetree").join("locks.json");
assert!(locks_path.exists(), "locks.json should exist after start --files");
let lock_manager = codetree::lock::LockManager::load(locks_path)?;
assert!(lock_manager.is_locked("src/a.rs"));
assert!(lock_manager.is_locked("src/b.rs"));
let result = commands::start_command(
"conflict test".to_string(),
true, true, false,
Some(vec!["src/a.rs".to_string()]),
None, None, None,
None,
false,
).await;
assert!(result.is_err(), "Should not be able to lock an already-locked file");
Ok(())
}
#[tokio::test]
async fn test_file_lock_released_on_withdraw() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"lock release test".to_string(),
true, true, false,
Some(vec!["src/c.rs".to_string()]),
None, None, None,
None,
false,
).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let branch_name = branch_manager.list_branches()
.into_iter()
.find(|b| matches!(b.status, BranchStatus::Active))
.map(|b| b.name.clone())
.unwrap();
commands::withdraw_command(Some(branch_name.clone()), None).await?;
let locks_path = repo_path.join(".codetree").join("locks.json");
let lock_manager = codetree::lock::LockManager::load(locks_path)?;
assert!(!lock_manager.is_locked("src/c.rs"), "Lock should be released after withdraw");
Ok(())
}
#[tokio::test]
async fn test_code_freezing_blocks_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let frozen_path = repo_path.join(".codetree").join("frozen.json");
let mut frozen = codetree::freeze::FrozenPaths::new(frozen_path.clone());
frozen.freeze("src/protected.rs");
frozen.save()?;
commands::start_command(
"freeze test".to_string(),
false, false, false,
Some(vec!["src/protected.rs".to_string()]),
None, None, None,
None,
false,
).await?;
std::fs::create_dir_all(repo_path.join("src"))?;
std::fs::write(repo_path.join("src/protected.rs"), "content")?;
let result = commands::save_command(vec!["modify protected".to_string()], false, false, None).await;
assert!(result.is_err(), "Save should be rejected for frozen files");
let err_msg = result.unwrap_err().to_string();
assert!(err_msg.contains("frozen"), "Error should mention frozen: {}", err_msg);
Ok(())
}
#[tokio::test]
async fn test_code_freezing_unfreeze_allows_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let frozen_path = repo_path.join(".codetree").join("frozen.json");
let mut frozen = codetree::freeze::FrozenPaths::new(frozen_path);
frozen.freeze("src/unfrozen.rs");
frozen.save()?;
frozen.unfreeze("src/unfrozen.rs");
frozen.save()?;
let loaded = codetree::freeze::FrozenPaths::load(repo_path.join(".codetree").join("frozen.json"))?;
assert!(!loaded.is_frozen("src/unfrozen.rs"));
Ok(())
}
#[tokio::test]
async fn test_solution_candidate_group() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let candidates_path = repo_path.join(".codetree").join("candidates.json");
let mut cand_mgr = codetree::candidates::CandidateManager::new(candidates_path.clone());
commands::start_command("solution A".to_string(), true, true, false, None, None, None, None, None, false).await?;
commands::start_command("solution B".to_string(), true, true, false, None, None, None, None, None, false).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let active_ops: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| matches!(b.status, BranchStatus::Active))
.collect();
assert_eq!(active_ops.len(), 2);
cand_mgr.add_candidate("auth-fix", &active_ops[0].name)?;
cand_mgr.add_candidate("auth-fix", &active_ops[1].name)?;
cand_mgr.save()?;
let loaded = codetree::candidates::CandidateManager::load(candidates_path)?;
assert_eq!(loaded.get_group("auth-fix").unwrap().len(), 2);
assert!(loaded.is_candidate("auth-fix", &active_ops[0].name));
assert!(loaded.is_candidate("auth-fix", &active_ops[1].name));
commands::evaluate_command("auth-fix".to_string()).await?;
Ok(())
}
#[tokio::test]
async fn test_freeze_and_unfreeze_commands() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::freeze_command("src/important.rs".to_string()).await?;
let frozen = codetree::freeze::FrozenPaths::load(
repo_path.join(".codetree").join("frozen.json")
)?;
assert!(frozen.is_frozen("src/important.rs"));
commands::frozen_command().await?;
commands::unfreeze_command("src/important.rs".to_string(), true).await?;
let frozen = codetree::freeze::FrozenPaths::load(
repo_path.join(".codetree").join("frozen.json")
)?;
assert!(!frozen.is_frozen("src/important.rs"));
Ok(())
}
#[tokio::test]
async fn test_locks_listing() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"locks list test".to_string(),
true, true, false,
Some(vec!["src/x.rs".to_string(), "src/y.rs".to_string()]),
None, None, None,
None,
false,
).await?;
commands::locks_command().await?;
let lock_manager = codetree::lock::LockManager::load(
repo_path.join(".codetree").join("locks.json")
)?;
let locks = lock_manager.list_locks();
assert!(locks.iter().any(|(p, _)| p == "src/x.rs"));
assert!(locks.iter().any(|(p, _)| p == "src/y.rs"));
Ok(())
}
#[tokio::test]
async fn test_validation_passes_then_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let config_path = repo_path.join(".codetree").join("config.toml");
let mut config = Config::load(&config_path).await?;
config.validation.mode = "required".to_string();
config.validation.command = Some("true".to_string());
config.save(&config_path).await?;
commands::start_command("validation test".to_string(), true, true, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch_manager = BranchManager::new(repo_path.join(".codetree").join("branches.json")).await?;
let op_branch = branch_manager.list_branches()
.into_iter()
.find(|b| b.name.contains("validation_test"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_branch).await?;
tokio::fs::write(repo_path.join("test.rs"), "fn test() {}\n").await?;
let result = commands::save_command(vec![], false, false, None).await;
assert!(result.is_ok(), "Save with passing validation should succeed: {:?}", result.err());
Ok(())
}
#[tokio::test]
async fn test_validation_fails_blocks_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let config_path = repo_path.join(".codetree").join("config.toml");
let mut config = Config::load(&config_path).await?;
config.validation.mode = "required".to_string();
config.validation.command = Some("false".to_string());
config.save(&config_path).await?;
commands::start_command("validation fail test".to_string(), true, true, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch_manager = BranchManager::new(repo_path.join(".codetree").join("branches.json")).await?;
let op_branch = branch_manager.list_branches()
.into_iter()
.find(|b| b.name.contains("validation_fail_test"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_branch).await?;
tokio::fs::write(repo_path.join("test.rs"), "fn test() {}\n").await?;
let result = commands::save_command(vec![], false, false, None).await;
assert!(result.is_err(), "Save with failing validation should be blocked");
let err_msg = result.unwrap_err().to_string();
assert!(err_msg.contains("Validation failed"), "Error should mention validation failure: {}", err_msg);
Ok(())
}
#[tokio::test]
async fn test_validation_no_validate_skips() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let config_path = repo_path.join(".codetree").join("config.toml");
let mut config = Config::load(&config_path).await?;
config.validation.mode = "required".to_string();
config.validation.command = Some("false".to_string());
config.save(&config_path).await?;
commands::start_command("validation skip test".to_string(), true, true, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch_manager = BranchManager::new(repo_path.join(".codetree").join("branches.json")).await?;
let op_branch = branch_manager.list_branches()
.into_iter()
.find(|b| b.name.contains("validation_skip_test"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_branch).await?;
tokio::fs::write(repo_path.join("test.rs"), "fn test() {}\n").await?;
let result = commands::save_command(vec![], false, true, None).await;
assert!(result.is_ok(), "Save with --no-validate should skip validation: {:?}", result.err());
Ok(())
}
#[tokio::test]
async fn test_validation_off_by_default() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let config_path = repo_path.join(".codetree").join("config.toml");
let config = Config::load(&config_path).await?;
assert!(config.validation.is_off(), "Validation should be off by default");
commands::start_command("no validation test".to_string(), true, true, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch_manager = BranchManager::new(repo_path.join(".codetree").join("branches.json")).await?;
let op_branch = branch_manager.list_branches()
.into_iter()
.find(|b| b.name.contains("no_validation_test"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_branch).await?;
tokio::fs::write(repo_path.join("test.rs"), "fn test() {}\n").await?;
let result = commands::save_command(vec![], false, false, None).await;
assert!(result.is_ok(), "Save with no validation should succeed: {:?}", result.err());
Ok(())
}
#[tokio::test]
async fn test_agent_id_tracking() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command("agent A task".to_string(), true, false, false, None, None, None, None, Some("agent-A".to_string()), false).await?;
commands::start_command("agent B task".to_string(), true, false, false, None, None, None, None, Some("agent-B".to_string()), false).await?;
commands::start_command("agent A task 2".to_string(), true, false, false, None, None, None, None, Some("agent-A".to_string()), false).await?;
let branch_manager = BranchManager::new(repo_path.join(".codetree").join("branches.json")).await?;
let agent_a_ops = branch_manager.list_branches_by_agent("agent-A");
assert_eq!(agent_a_ops.len(), 2, "Agent A should have 2 operations");
let agent_b_ops = branch_manager.list_branches_by_agent("agent-B");
assert_eq!(agent_b_ops.len(), 1, "Agent B should have 1 operation");
let all_branches = branch_manager.list_branches();
for b in all_branches {
if matches!(b.status, BranchStatus::Active) {
assert!(b.agent_id.is_some(), "All active branches should have agent_id");
}
}
commands::agents_command().await?;
Ok(())
}
#[tokio::test]
async fn test_agent_id_in_ops_log() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command("tracked op".to_string(), true, false, false, None, None, None, None, Some("test-agent-42".to_string()), false).await?;
let ops_path = repo_path.join(".codetree").join("ops.json");
let ops_content = std::fs::read_to_string(&ops_path)?;
assert!(ops_content.contains("test-agent-42"), "ops.json should contain agent_id: {}", ops_content);
Ok(())
}
#[tokio::test]
async fn test_file_lock_released_on_finish() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"lock finish test".to_string(),
true, true, false,
Some(vec!["src/fin.rs".to_string()]),
None, None, None,
None, false,
).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let branch_name = branch_manager.list_branches()
.into_iter()
.find(|b| matches!(b.status, BranchStatus::Active))
.map(|b| b.name.clone())
.unwrap();
let git_manager = VcsManager::new(repo_path.clone())?;
git_manager.checkout_branch(&branch_name).await?;
tokio::fs::create_dir_all(repo_path.join("src")).await?;
tokio::fs::write(repo_path.join("src/fin.rs"), "// fin\n").await?;
git_manager.add_all().await?;
git_manager.commit("Lock finish commit").await?;
commands::finish_command(Some(branch_name.clone()), None, false).await?;
let locks_path = repo_path.join(".codetree").join("locks.json");
let lock_manager = codetree::lock::LockManager::load(locks_path)?;
assert!(!lock_manager.is_locked("src/fin.rs"), "Lock should be released after finish");
Ok(())
}
#[tokio::test]
async fn test_unlock_command_releases_lock() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"unlock test".to_string(),
true, true, false,
Some(vec!["src/unlock.rs".to_string()]),
None, None, None,
None, false,
).await?;
let locks_path = repo_path.join(".codetree").join("locks.json");
let lock_manager = codetree::lock::LockManager::load(locks_path.clone())?;
assert!(lock_manager.is_locked("src/unlock.rs"));
commands::unlock_command("src/unlock.rs".to_string()).await?;
let lock_manager = codetree::lock::LockManager::load(locks_path)?;
assert!(!lock_manager.is_locked("src/unlock.rs"), "unlock_command should release the lock");
Ok(())
}
#[tokio::test]
async fn test_lock_enforcement_on_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command(
"Lock owner".to_string(),
true, true, false,
Some(vec!["src/shared.rs".to_string()]),
None, None, None,
None, false,
).await?;
commands::start_command(
"Lock violator".to_string(),
true, false, false,
None,
None, None, None,
None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches = git_manager.list_branches()?;
let violator_branch = branches.iter()
.find(|b| b.name.contains("lock_violator"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&violator_branch).await?;
tokio::fs::create_dir_all(repo_path.join("src")).await?;
tokio::fs::write(repo_path.join("src/shared.rs"), "// violator\n").await?;
let result = commands::save_command(vec!["violate lock".to_string()], false, false, None).await;
assert!(result.is_err(), "Save should be rejected when touching a file locked by another op");
Ok(())
}
#[tokio::test]
async fn test_promote_candidate() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::start_command("Solution A".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::start_command("Solution B".to_string(), true, false, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let active_ops: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| matches!(b.status, BranchStatus::Active))
.collect();
assert_eq!(active_ops.len(), 2);
let candidates_path = repo_path.join(".codetree").join("candidates.json");
let mut cand_mgr = codetree::candidates::CandidateManager::new(candidates_path.clone());
cand_mgr.add_candidate("auth-fix", &active_ops[0].name)?;
cand_mgr.add_candidate("auth-fix", &active_ops[1].name)?;
cand_mgr.save()?;
let winner = &active_ops[0].name;
git_manager.checkout_branch(winner).await?;
tokio::fs::write(repo_path.join("solution.rs"), "// winning solution\n").await?;
git_manager.add_all().await?;
git_manager.commit("Winning solution").await?;
commands::promote_command("auth-fix".to_string(), winner.clone()).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let winner_info = branch_manager.get_branch(winner).unwrap();
assert_eq!(winner_info.status, BranchStatus::Merged);
let loser = &active_ops[1].name;
let loser_info = branch_manager.get_branch(loser).unwrap();
assert_eq!(loser_info.status, BranchStatus::Archived);
let loaded_cands = codetree::candidates::CandidateManager::load(candidates_path)?;
assert!(loaded_cands.get_group("auth-fix").is_none(), "Candidate group should be deleted after promote");
Ok(())
}
#[tokio::test]
async fn test_freeze_directory_blocks_save() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
commands::freeze_command("src/protected/".to_string()).await?;
commands::start_command(
"Freeze dir test".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
std::fs::create_dir_all(repo_path.join("src/protected"))?;
std::fs::write(repo_path.join("src/protected/file.rs"), "content")?;
let result = commands::save_command(vec!["modify frozen dir".to_string()], false, false, None).await;
assert!(result.is_err(), "Save should be rejected for files under a frozen directory");
Ok(())
}
#[tokio::test]
async fn test_save_validate_flag_triggers_validation() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let config_path = repo_path.join(".codetree").join("config.toml");
let mut config = Config::load(&config_path).await?;
config.validation.mode = "off".to_string();
config.validation.command = Some("false".to_string());
config.save(&config_path).await?;
commands::start_command(
"Validate flag test".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
tokio::fs::write(repo_path.join("validate_test.rs"), "// test\n").await?;
let result = commands::save_command(vec![], true, false, None).await;
assert!(result.is_err(), "Save with --validate and failing command should be blocked");
Ok(())
}
#[tokio::test]
async fn test_concurrent_starts_disjoint_files_both_locks_survive() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let mut handles = Vec::new();
for (desc, file) in [("Concurrent Op A", "a_shared.rs"), ("Concurrent Op B", "b_shared.rs")] {
let files = vec![file.to_string()];
handles.push(tokio::spawn(async move {
commands::start_command(
desc.to_string(), true, false, false, Some(files),
None, None, None, None, false,
).await
}));
}
let mut results = Vec::new();
for h in handles {
results.push(h.await.unwrap());
}
assert_eq!(results.iter().filter(|r| r.is_ok()).count(), 2,
"both agents should acquire their disjoint locks: {:?}",
results.iter().map(|r| r.as_ref().err().map(|e| e.to_string())).collect::<Vec<_>>());
let locks = codetree::lock::LockManager::load(repo_path.join(".codetree").join("locks.json"))?;
let entries = locks.list_locks();
assert_eq!(entries.len(), 2);
let files: std::collections::HashSet<_> = entries.iter().map(|(f, _)| f.clone()).collect();
assert!(files.contains("a_shared.rs") && files.contains("b_shared.rs"));
Ok(())
}
#[tokio::test]
async fn test_lock_conflict_then_release_via_atomic_rmw() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (_temp_dir, repo_path) = create_test_repo().await?;
let _guard = DirGuard::new(&repo_path);
commands::init_command(false).await?;
let files = vec!["contested.rs".to_string()];
commands::start_command(
"Holder Op".to_string(), true, false, false, Some(files.clone()),
None, None, None, None, false,
).await?;
let err = commands::start_command(
"Conflicting Op".to_string(), true, false, false, Some(files.clone()),
None, None, None, None, false,
).await.unwrap_err();
assert!(err.to_string().contains("locked by operation"),
"unexpected error: {}", err);
commands::unlock_command("contested.rs".to_string()).await?;
commands::start_command(
"Conflicting Op".to_string(), true, false, false, Some(files.clone()),
None, None, None, None, false,
).await?;
let locks = codetree::lock::LockManager::load(repo_path.join(".codetree").join("locks.json"))?;
assert_eq!(locks.lock_holder("contested.rs").map(|s| s.to_string()).unwrap(),
locks.list_locks().iter().find(|(f, _)| f == "contested.rs").unwrap().1.clone());
Ok(())
}
#[tokio::test]
async fn test_ref_writes_atomic_and_listings_clean() -> Result<()> {
let (_temp_dir, repo_path) = create_test_repo().await?;
let mgr = VcsManager::new(repo_path.clone())?;
let refs = mgr.repo().refs();
for i in 0..5 {
refs.set_branch(&format!("branch-{}", i), &format!("commit-{}", i))?;
refs.set_head("main")?;
}
let heads_dir = repo_path.join(".codetree").join("refs").join("heads");
let listing: Vec<_> = std::fs::read_dir(&heads_dir)?
.map(|e| e.unwrap().file_name().to_string_lossy().to_string())
.collect();
for name in &listing {
assert!(!name.ends_with(".lock") && !name.starts_with('.'),
"atomic-write litter leaked into refs listing: {}", name);
}
assert!(listing.iter().any(|n| n == "main"));
Ok(())
}