mod common;
use common::*;
#[tokio::test]
async fn test_finish_command_workflow() -> 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())?;
let branch_name = "codetree_test_finish_op";
git_manager.create_branch(branch_name, None).await?;
let mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
branch_manager.register_branch(
branch_name,
vec!["src/test.rs".to_string()],
"Test finish workflow".to_string()
).await?;
git_manager.checkout_branch(branch_name).await?;
tokio::fs::create_dir_all(repo_path.join("src")).await?;
tokio::fs::write(repo_path.join("src/test.rs"), "// test content\n").await?;
git_manager.add_all().await?;
git_manager.commit("Test commit for finish").await?;
commands::finish_command(Some(branch_name.to_string()), None, false).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let info = branch_manager.get_branch(branch_name).unwrap();
assert_eq!(info.status, BranchStatus::Merged);
let branches = git_manager.list_branches()?;
assert!(!branches.iter().any(|b| b.name == branch_name));
Ok(())
}
#[tokio::test]
async fn test_withdraw_command_workflow() -> 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())?;
let branch_name = "codetree_test_withdraw_op";
git_manager.create_branch(branch_name, None).await?;
let mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
branch_manager.register_branch(
branch_name,
vec!["src/test.rs".to_string()],
"Test withdraw workflow".to_string()
).await?;
git_manager.checkout_branch(branch_name).await?;
tokio::fs::create_dir_all(repo_path.join("src")).await?;
tokio::fs::write(repo_path.join("src/test.rs"), "// test content\n").await?;
git_manager.add_all().await?;
git_manager.commit("Test commit for withdraw").await?;
commands::withdraw_command(Some(branch_name.to_string()), None).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let info = branch_manager.get_branch(branch_name).unwrap();
assert_eq!(info.status, BranchStatus::Archived);
let branches = git_manager.list_branches()?;
assert!(!branches.iter().any(|b| b.name == branch_name));
Ok(())
}
#[tokio::test]
async fn test_full_agent_workflow_parallel_start_save_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(
"Fix login bug".to_string(),
true, false, false, None, None, None, None, None, false).await?;
commands::start_command(
"Refactor auth".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 current = git_manager.get_current_branch().await?;
assert_eq!(current, "main");
assert!(branches.iter().any(|b| b.name.starts_with("codetree_") && b.name.contains("fix_login_bug")));
assert!(branches.iter().any(|b| b.name.starts_with("codetree_") && b.name.contains("refactor_auth")));
let op1_branch = branches.iter()
.find(|b| b.name.contains("fix_login_bug"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op1_branch).await?;
tokio::fs::write(repo_path.join("login.rs"), "fn login() {}\n").await?;
commands::save_command(vec![], false, false, None).await?;
let op2_branch = branches.iter()
.find(|b| b.name.contains("refactor_auth"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op2_branch).await?;
tokio::fs::write(repo_path.join("auth.rs"), "fn auth() {}\n").await?;
commands::save_command(vec![], false, false, None).await?;
commands::compare_command().await?;
commands::finish_command(Some(op1_branch.clone()), None, false).await?;
commands::withdraw_command(Some(op2_branch.clone()), None).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let info1 = branch_manager.get_branch(&op1_branch).unwrap();
let info2 = branch_manager.get_branch(&op2_branch).unwrap();
assert_eq!(info1.status, BranchStatus::Merged);
assert_eq!(info2.status, BranchStatus::Archived);
Ok(())
}
#[tokio::test]
async fn test_undo_list_and_selective() -> 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("First op".to_string(), false, false, false, None, None, None, None, None, false).await?;
commands::start_command("Second op".to_string(), false, false, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
commands::undo_command(None, true).await?;
let branches = git_manager.list_branches()?;
let op_branches: Vec<_> = branches.iter().filter(|b| b.name.starts_with("codetree_")).collect();
assert_eq!(op_branches.len(), 2);
commands::undo_command(Some(0), false).await?;
let branches = git_manager.list_branches()?;
let op_branches: Vec<_> = branches.iter().filter(|b| b.name.starts_with("codetree_")).collect();
assert_eq!(op_branches.len(), 1);
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
assert_eq!(branch_manager.list_branches().len(), 1);
Ok(())
}
#[tokio::test]
async fn test_per_file_assignment_scoped_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 git_manager = VcsManager::new(repo_path.clone())?;
commands::start_command(
"Fix login".to_string(),
true, false,
false,
Some(vec!["src/auth.rs".to_string(), "src/login.html".to_string()]),
None, None,
None,
None,
false,
).await?;
let branches = git_manager.list_branches()?;
let op_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_branch).await?;
tokio::fs::create_dir_all(repo_path.join("src")).await?;
tokio::fs::write(repo_path.join("src/auth.rs"), "// auth fix\n").await?;
tokio::fs::write(repo_path.join("src/other.rs"), "// unrelated\n").await?;
commands::save_command(vec![], false, false, None).await?;
let status = git_manager.get_status().await?;
assert!(status.modified.iter().any(|f| f == "src/other.rs") || status.untracked.iter().any(|f| f == "src/other.rs"));
Ok(())
}
#[tokio::test]
async fn test_branchless_auto_absorb() -> 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(
"Fix login".to_string(),
false, false, true, None, None, None, None,
None, false).await?;
let current = git_manager.get_current_branch().await?;
assert_eq!(current, "main");
tokio::fs::write(repo_path.join("auth.rs"), "// v1\n").await?;
commands::save_command(vec![], false, false, None).await?;
let history1 = git_manager.get_commit_history("main", 5)?;
let first_commit_hash = history1[0].hash.clone();
tokio::fs::write(repo_path.join("auth.rs"), "// v2\n").await?;
commands::save_command(vec![], false, false, None).await?;
let history2 = git_manager.get_commit_history("main", 5)?;
let second_commit_hash = history2[0].hash.clone();
assert_ne!(first_commit_hash, second_commit_hash, "Amended commit should have new hash");
assert_eq!(history1[1].hash, history2[1].hash, "Parent commit should be unchanged");
Ok(())
}
#[tokio::test]
async fn test_snapshot_clean_tree_no_snapshot() -> 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())?;
git_manager.add_all().await?;
git_manager.commit("Add .gitignore").await?;
let result = git_manager.snapshot_working_tree().await?;
assert!(result.is_none(), "clean tree should not produce a snapshot");
Ok(())
}
#[tokio::test]
async fn test_snapshot_dirty_tree_and_restore() -> 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())?;
git_manager.add_all().await?;
git_manager.commit("Add .gitignore").await?;
tokio::fs::write(repo_path.join("work.rs"), "fn work() { 42 }\n").await?;
let result = git_manager.snapshot_working_tree().await?;
assert!(result.is_some(), "dirty tree should produce a snapshot");
let snap = result.unwrap();
assert_eq!(snap.file_count, 2); assert_eq!(snap.branch, "main");
assert!(!snap.commit_hash.is_empty());
let mut mgr = SnapshotManager::load(&git_manager.snapshots_path()).await?;
let id = mgr.add(snap.commit_hash.clone(), snap.timestamp, snap.branch.clone(), snap.file_count);
mgr.save(&git_manager.snapshots_path()).await?;
tokio::fs::write(repo_path.join("work.rs"), "fn lost() {}\n").await?;
commands::restore_snapshot_command(id, false).await?;
let content = tokio::fs::read_to_string(repo_path.join("work.rs")).await?;
assert_eq!(content, "fn work() { 42 }\n");
Ok(())
}
#[tokio::test]
async fn test_auto_snapshot_before_switch() -> 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("test op".to_string(), true, false, false, None, None, None, None, None, false).await?;
tokio::fs::write(repo_path.join("uncommitted.rs"), "fn temp() {}\n").await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches = git_manager.list_branches()?;
let op_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_") && b.name != "main")
.map(|b| b.name.clone())
.unwrap();
commands::switch_command(op_branch).await?;
let mgr = SnapshotManager::load(&git_manager.snapshots_path()).await?;
assert!(!mgr.is_empty(), "auto-snapshot should have been created before switch");
let snap = mgr.list().last().unwrap();
assert_eq!(snap.branch, "main");
assert!(snap.file_count > 0);
let commit = git_manager.repo().read_commit(&snap.commit_hash)?;
assert_eq!(commit.message, "Working copy snapshot");
Ok(())
}
#[tokio::test]
async fn test_save_clears_snapshots() -> 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())?;
tokio::fs::write(repo_path.join("file.rs"), "fn main() {}\n").await?;
commands::snapshot_command(false).await?;
let mgr = SnapshotManager::load(&git_manager.snapshots_path()).await?;
assert!(!mgr.is_empty(), "snapshot should exist");
commands::save_command(vec!["save work".to_string()], false, false, None).await?;
let mgr = SnapshotManager::load(&git_manager.snapshots_path()).await?;
assert!(mgr.is_empty(), "save should clear snapshots");
Ok(())
}
#[tokio::test]
async fn test_checkpoint_rewind_workflow() -> 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())?;
tokio::fs::write(repo_path.join("a.txt"), "v1\n").await?;
commands::checkpoint_command(Some("before risky refactor".to_string())).await?;
let snapshots_path = repo_path.join(".codetree").join("snapshots.json");
let mgr = SnapshotManager::load(&snapshots_path).await?;
assert_eq!(mgr.len(), 1);
assert_eq!(mgr.get(0).unwrap().label.as_deref(), Some("before risky refactor"));
tokio::fs::write(repo_path.join("a.txt"), "v2 broken\n").await?;
tokio::fs::write(repo_path.join("stray.txt"), "stray\n").await?;
commands::rewind_command(0, true).await?;
assert_eq!(tokio::fs::read_to_string(repo_path.join("a.txt")).await?, "v2 broken\n");
assert!(repo_path.join("stray.txt").exists());
let head_before = git_manager.get_head_hash()?;
commands::rewind_command(0, false).await?;
assert_eq!(tokio::fs::read_to_string(repo_path.join("a.txt")).await?, "v1\n");
assert!(!repo_path.join("stray.txt").exists(), "rewind removes files created after the checkpoint");
assert_eq!(git_manager.get_head_hash()?, head_before, "rewind must not move HEAD");
Ok(())
}
#[tokio::test]
async fn test_checkpoint_survives_save_and_clean_checkpoint_targets_head() -> 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())?;
tokio::fs::write(repo_path.join("a.txt"), "v1\n").await?;
commands::checkpoint_command(Some("turn 1".to_string())).await?;
commands::save_command(vec!["save a".to_string()], false, false, None).await?;
let snapshots_path = repo_path.join(".codetree").join("snapshots.json");
let mgr = SnapshotManager::load(&snapshots_path).await?;
assert_eq!(mgr.len(), 1, "labeled checkpoint survives save");
assert_eq!(mgr.get(0).unwrap().label.as_deref(), Some("turn 1"));
commands::checkpoint_command(Some("turn 2".to_string())).await?;
let mgr = SnapshotManager::load(&snapshots_path).await?;
assert_eq!(mgr.len(), 2);
let head = git_manager.get_head_hash()?;
assert_eq!(mgr.get(1).unwrap().commit_hash, head, "clean checkpoint targets HEAD's tree");
assert_eq!(mgr.get(1).unwrap().label.as_deref(), Some("turn 2"));
tokio::fs::write(repo_path.join("a.txt"), "broken\n").await?;
tokio::fs::write(repo_path.join("stray.txt"), "x\n").await?;
commands::rewind_command(1, false).await?;
assert_eq!(tokio::fs::read_to_string(repo_path.join("a.txt")).await?, "v1\n");
assert!(!repo_path.join("stray.txt").exists());
Ok(())
}
#[tokio::test]
async fn test_operation_tags_grouping() -> 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(
"Fix login".to_string(),
true, false, false,
None, None, None,
Some(vec!["sprint-42".to_string()]),
None,
false,
).await?;
commands::start_command(
"Fix logout".to_string(),
true, false, false,
None, None, None,
Some(vec!["sprint-42".to_string()]),
None,
false,
).await?;
commands::start_command(
"Refactor parser".to_string(),
true, false, false,
None, None, None,
Some(vec!["tech-debt".to_string()]),
None,
false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches = git_manager.list_branches()?;
let codetree_branches: Vec<_> = branches.iter().filter(|b| b.name.starts_with("codetree_")).collect();
assert_eq!(codetree_branches.len(), 3);
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let sprint_branches = branch_manager.list_branches_by_tag("sprint-42");
assert_eq!(sprint_branches.len(), 2);
let tech_debt_branches = branch_manager.list_branches_by_tag("tech-debt");
assert_eq!(tech_debt_branches.len(), 1);
let sprint_names: Vec<_> = sprint_branches.iter().map(|b| b.name.clone()).collect();
for name in &sprint_names {
commands::withdraw_command(Some(name.clone()), None).await?;
}
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
for name in &sprint_names {
let info = branch_manager.get_branch(name).unwrap();
assert_eq!(info.status, BranchStatus::Archived);
}
let tech_debt_name = tech_debt_branches[0].name.clone();
let info = branch_manager.get_branch(&tech_debt_name).unwrap();
assert_eq!(info.status, BranchStatus::Active);
Ok(())
}
#[tokio::test]
async fn test_next_prev_navigation() -> 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("Alpha fix".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::start_command("Beta fix".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::start_command("Gamma fix".to_string(), true, false, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
commands::next_command().await?;
let current = git_manager.get_current_branch().await?;
let branches = git_manager.list_branches()?;
let mut active: Vec<_> = branches.iter().filter(|b| b.name.starts_with("codetree_")).map(|b| b.name.clone()).collect();
active.sort();
assert_eq!(current, active[0], "next from main should go to first active op");
commands::next_command().await?;
let current = git_manager.get_current_branch().await?;
assert_eq!(current, active[1], "next should advance to second op");
commands::prev_command().await?;
let current = git_manager.get_current_branch().await?;
assert_eq!(current, active[0], "prev should go back to first op");
commands::prev_command().await?;
let current = git_manager.get_current_branch().await?;
assert_eq!(current, active[2], "prev at first should wrap to last op");
commands::next_command().await?;
let current = git_manager.get_current_branch().await?;
assert_eq!(current, active[0], "next at last should wrap to first op");
Ok(())
}
#[tokio::test]
async fn test_staleness_warning() -> 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())?;
let branch_name = "codetree_stale_op";
git_manager.create_branch(branch_name, None).await?;
let mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
branch_manager.register_branch(
branch_name,
vec!["src/main.rs".to_string()],
"Stale op".to_string()
).await?;
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs();
let ten_days_ago = now - 10 * 86400;
if let Some(branch) = branch_manager.branches.get_mut(branch_name) {
branch.updated_at = ten_days_ago;
}
branch_manager.save().await?;
commands::status_command(false).await?;
commands::smartlog_command(false, false, None, None, false, false).await?;
Ok(())
}
#[tokio::test]
async fn test_snapshot_with_ops_backup() -> 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())?;
let branch1 = "codetree_op_snapshot_ops";
git_manager.create_branch(branch1, None).await?;
let mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
branch_manager.register_branch(branch1, vec![], "Ops snapshot test".to_string()).await?;
tokio::fs::write(repo_path.join("file.rs"), "fn main() {}\n").await?;
commands::snapshot_command(true).await?;
let backup_dir = repo_path.join(".codetree").join("ops_backups");
assert!(backup_dir.exists(), "ops_backups directory should exist");
let mut found_backup = false;
for entry in std::fs::read_dir(&backup_dir)? {
let entry = entry?;
if entry.file_type()?.is_dir() {
let backup_file = entry.path().join("branches.json");
if backup_file.exists() {
found_backup = true;
break;
}
}
}
assert!(found_backup, "branches.json should be backed up");
Ok(())
}
#[tokio::test]
async fn test_redo_start_operation() -> 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("Redo test op".to_string(), true, false, false, None, None, None, None, None, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches_before = git_manager.list_branches()?;
let op_branch = branches_before.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
assert!(git_manager.branch_exists(&op_branch), "Branch should exist before undo");
commands::undo_command(None, false).await?;
let branches_after_undo = git_manager.list_branches()?;
assert!(!branches_after_undo.iter().any(|b| b.name == op_branch), "Branch should be gone after undo");
commands::redo_command(None, false).await?;
let branches_after_redo = git_manager.list_branches()?;
assert!(branches_after_redo.iter().any(|b| b.name == op_branch), "Branch should exist again after redo");
Ok(())
}
#[tokio::test]
async fn test_redo_list_empty() -> 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::redo_command(None, true).await?;
Ok(())
}
#[tokio::test]
async fn test_undo_then_redo_then_undo_again() -> 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("Cycle test".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 op_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
commands::undo_command(None, false).await?;
assert!(!git_manager.branch_exists(&op_branch), "Branch gone after undo");
commands::redo_command(None, false).await?;
assert!(git_manager.branch_exists(&op_branch), "Branch back after redo");
commands::undo_command(None, false).await?;
assert!(!git_manager.branch_exists(&op_branch), "Branch gone after second undo");
Ok(())
}
#[tokio::test]
async fn test_switch_toggle() -> 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("Op A".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::start_command("Op B".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 op_a = branches.iter().find(|b| b.name.contains("op_a")).map(|b| b.name.clone()).unwrap();
let op_b = branches.iter().find(|b| b.name.contains("op_b")).map(|b| b.name.clone()).unwrap();
commands::switch_command(op_a.clone()).await?;
assert_eq!(git_manager.get_current_branch().await?, op_a);
commands::switch_command(op_b.clone()).await?;
assert_eq!(git_manager.get_current_branch().await?, op_b);
commands::switch_command("-".to_string()).await?;
assert_eq!(git_manager.get_current_branch().await?, op_a, "switch - should toggle back to op_a");
commands::switch_command("-".to_string()).await?;
assert_eq!(git_manager.get_current_branch().await?, op_b, "switch - should toggle back to op_b");
Ok(())
}
#[tokio::test]
async fn test_finish_dry_run() -> 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("Dry run finish test".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 op_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
commands::finish_command(Some(op_branch.clone()), None, true).await?;
assert!(git_manager.branch_exists(&op_branch), "Branch should still exist after dry-run finish");
Ok(())
}
#[tokio::test]
async fn test_start_checkout_switches_to_branch() -> 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(
"Checkout test".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let current = git_manager.get_current_branch().await?;
assert!(current.contains("checkout_test"), "Non-parallel start should checkout the new branch");
Ok(())
}
#[tokio::test]
async fn test_save_with_explicit_message() -> 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(
"Explicit msg test".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let current = git_manager.get_current_branch().await?;
tokio::fs::write(repo_path.join("msg_test.rs"), "// test\n").await?;
commands::save_command(vec!["My explicit save message".to_string()], false, false, None).await?;
let history = git_manager.get_commit_history(¤t, 5)?;
assert!(history.iter().any(|c| c.message == "My explicit save message"),
"Commit with explicit message should exist");
Ok(())
}
#[tokio::test]
async fn test_withdraw_nonexistent_branch_errors() -> 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 result = commands::withdraw_command(Some("nonexistent_branch".to_string()), None).await;
assert!(result.is_err(), "Withdrawing a non-existent branch should error");
Ok(())
}
#[tokio::test]
async fn test_finish_nonexistent_branch_errors() -> 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 result = commands::finish_command(Some("nonexistent_branch".to_string()), None, false).await;
assert!(result.is_err(), "Finishing a non-existent branch should error");
Ok(())
}
#[tokio::test]
async fn test_batch_withdraw_by_tag() -> 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(
"Batch A".to_string(),
true, false, false,
None, None, None,
Some(vec!["batch-test".to_string()]),
None, false,
).await?;
commands::start_command(
"Batch B".to_string(),
true, false, false,
None, None, None,
Some(vec!["batch-test".to_string()]),
None, false,
).await?;
commands::start_command(
"Unrelated".to_string(),
true, false, false,
None, None, None, None,
None, false,
).await?;
commands::withdraw_command(None, Some("batch-test".to_string())).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let batch_branches: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| b.tags.iter().any(|t| t == "batch-test"))
.collect();
assert_eq!(batch_branches.len(), 2);
for b in &batch_branches {
assert_eq!(b.status, BranchStatus::Archived, "Batch-tagged op should be archived");
}
let active: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| matches!(b.status, BranchStatus::Active))
.collect();
assert_eq!(active.len(), 1, "Unrelated op should still be active");
Ok(())
}
#[tokio::test]
async fn test_batch_finish_by_tag() -> 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(
"Finish A".to_string(),
false, false, false,
None, None, None,
Some(vec!["fin-tag".to_string()]),
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_a = branch_manager.list_branches()
.into_iter()
.filter(|b| b.tags.iter().any(|t| t == "fin-tag"))
.find(|b| b.name.contains("finish_a"))
.map(|b| b.name.clone())
.unwrap();
tokio::fs::write(repo_path.join("a.rs"), "// a\n").await?;
git_manager.add_all().await?;
git_manager.commit("A commit").await?;
git_manager.checkout_branch("main").await?;
commands::start_command(
"Finish B".to_string(),
false, false, false,
None, None, None,
Some(vec!["fin-tag".to_string()]),
None, false,
).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let op_b = branch_manager.list_branches()
.into_iter()
.filter(|b| b.tags.iter().any(|t| t == "fin-tag"))
.find(|b| b.name.contains("finish_b"))
.map(|b| b.name.clone())
.unwrap();
tokio::fs::write(repo_path.join("b.rs"), "// b\n").await?;
git_manager.add_all().await?;
git_manager.commit("B commit").await?;
git_manager.checkout_branch("main").await?;
commands::finish_command(None, Some("fin-tag".to_string()), false).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
for name in &[&op_a, &op_b] {
let info = branch_manager.get_branch(name).unwrap();
assert_eq!(info.status, BranchStatus::Merged, "Batch-finished op should be merged");
}
Ok(())
}
#[tokio::test]
async fn test_status_command_runs() -> 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("Status test".to_string(), true, false, false, None, None, None, None, None, false).await?;
tokio::fs::write(repo_path.join("new_file.rs"), "// new\n").await?;
tokio::fs::write(repo_path.join("README.md"), "# updated\n").await?;
commands::status_command(false).await?;
Ok(())
}
#[tokio::test]
async fn test_worktree_add_and_remove() -> 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(
"Worktree test".to_string(),
false, true, false,
None, None, None, None,
None, false,
).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let op = branch_manager.list_branches()
.into_iter()
.find(|b| matches!(b.status, BranchStatus::Active))
.unwrap();
assert!(op.worktree.is_some(), "Worktree path should be set");
let worktree_path = op.worktree.clone().unwrap();
assert!(worktree_path.exists(), "Worktree directory should exist on disk");
commands::worktree_list_command().await?;
commands::worktree_remove_command(op.name.clone()).await?;
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let op_after = branch_manager.get_branch(&op.name).unwrap();
assert!(op_after.worktree.is_none(), "Worktree should be cleared after remove");
Ok(())
}
#[tokio::test]
async fn test_undo_save_reverts_last_commit() -> 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(
"Undo save test".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let current = git_manager.get_current_branch().await?;
tokio::fs::write(repo_path.join("undo_save.rs"), "// v1\n").await?;
commands::save_command(vec!["First save".to_string()], false, false, None).await?;
let history_before = git_manager.get_commit_history(¤t, 10)?;
let save_commits_before: Vec<_> = history_before.iter()
.filter(|c| c.message == "First save")
.collect();
assert_eq!(save_commits_before.len(), 1);
commands::undo_command(None, false).await?;
let history_after = git_manager.get_commit_history(¤t, 10)?;
let save_commits_after: Vec<_> = history_after.iter()
.filter(|c| c.message == "First save")
.collect();
assert_eq!(save_commits_after.len(), 0, "Save commit should be reverted by undo");
Ok(())
}
#[tokio::test]
async fn test_init_force_reinitializes() -> 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?;
assert!(repo_path.join(".codetree").exists());
let config_path = repo_path.join(".codetree").join("config.toml");
let mut config = Config::load(&config_path).await?;
config.git.branch_prefix = "custom_prefix".to_string();
config.save(&config_path).await?;
commands::init_command(true).await?;
assert!(repo_path.join(".codetree").exists());
Ok(())
}
#[tokio::test]
async fn test_start_with_template() -> 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(
"Fix null pointer".to_string(),
true, false, false,
None, None,
Some("bugfix".to_string()),
None, None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches = git_manager.list_branches()?;
let op_branch = branches.iter()
.find(|b| b.name.starts_with("codetree_") || b.name.starts_with("fix_"))
.map(|b| b.name.clone())
.unwrap();
assert!(op_branch.starts_with("fix_"), "Branch with bugfix template should start with 'fix_': {}", op_branch);
Ok(())
}
#[tokio::test]
async fn test_start_unknown_template_errors() -> 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 result = commands::start_command(
"Bad template".to_string(),
true, false, false,
None, None,
Some("nonexistent_template".to_string()),
None, None, false,
).await;
assert!(result.is_err(), "Start with unknown template should error");
Ok(())
}
#[tokio::test]
async fn test_stacked_operation_creation() -> 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(
"Base op".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let first_branch = git_manager.get_current_branch().await?;
tokio::fs::write(repo_path.join("base.rs"), "// base\n").await?;
git_manager.add_all().await?;
git_manager.commit("Base op commit").await?;
commands::start_command(
"Stacked op".to_string(),
false, false, false,
None, None, None, None,
None, false,
).await?;
let second_branch = git_manager.get_current_branch().await?;
assert_ne!(first_branch, second_branch, "Should be on a new branch");
let branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
let parent = branch_manager.get_parent_branch(&second_branch);
assert_eq!(parent, Some(first_branch.as_str()), "Second op should be stacked on first op");
Ok(())
}
#[tokio::test]
async fn test_merge_base_into_itself_errors() -> 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 result = commands::merge_command(Some("main".to_string()), false).await;
assert!(result.is_err(), "Merging base branch into itself should error");
Ok(())
}
#[tokio::test]
async fn test_stat_cache_re_stages_modified_file() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (temp_dir, repo_path) = create_test_repo().await?;
let _ = &temp_dir;
let _guard = DirGuard::new(&repo_path);
let mgr = VcsManager::new(repo_path.clone())?;
tokio::fs::write(repo_path.join("cached.rs"), "fn v1() {}\n").await?;
mgr.add_all().await?;
mgr.commit("v1").await?;
mgr.add_all().await?;
let status = mgr.get_status().await?;
assert!(status.modified.is_empty(), "clean tree after re-add, got {:?}", status.modified);
tokio::fs::write(repo_path.join("cached.rs"), "fn v2_much_longer_name() {}\n").await?;
mgr.add_all().await?;
mgr.commit("v2").await?;
let status = mgr.get_status().await?;
assert!(status.modified.is_empty(), "tree clean after commit of new content, got {:?}", status.modified);
let head = mgr.get_current_branch().await?;
let history = mgr.get_commit_history(&head, 2)?;
assert_eq!(history.len(), 2);
Ok(())
}
#[tokio::test]
async fn test_checkout_skips_matching_files() -> Result<()> {
let _serial = WORKDIR_LOCK.lock().await;
let (temp_dir, repo_path) = create_test_repo().await?;
let _ = &temp_dir;
let _guard = DirGuard::new(&repo_path);
let mgr = VcsManager::new(repo_path.clone())?;
tokio::fs::write(repo_path.join("a.txt"), "alpha\n").await?;
tokio::fs::write(repo_path.join("b.txt"), "beta\n").await?;
mgr.add_all().await?;
mgr.commit("base files").await?;
mgr.create_branch("feature", None).await?;
tokio::fs::write(repo_path.join("a.txt"), "alpha-main\n").await?;
mgr.add_all().await?;
mgr.commit("main change").await?;
mgr.checkout_branch("feature").await?;
let a = tokio::fs::read_to_string(repo_path.join("a.txt")).await?;
let b = tokio::fs::read_to_string(repo_path.join("b.txt")).await?;
assert_eq!(a, "alpha\n", "checkout must restore a.txt to branch content");
assert_eq!(b, "beta\n", "untouched file must survive checkout (skip-if-match)");
mgr.checkout_branch("main").await?;
let a = tokio::fs::read_to_string(repo_path.join("a.txt")).await?;
assert_eq!(a, "alpha-main\n");
Ok(())
}