mod common;
use common::*;
#[tokio::test]
async fn test_test_command_pass() -> 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("check.sh"), "#!/bin/bash\necho ok\n").await?;
git_manager.add_all().await?;
let commit_hash = git_manager.commit("add check script").await?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mut perms = std::fs::metadata(repo_path.join("check.sh"))?.permissions();
perms.set_mode(0o755);
std::fs::set_permissions(repo_path.join("check.sh"), perms)?;
}
let result = commands::test_command(
commit_hash.clone(),
vec!["true".to_string()],
).await;
assert!(result.is_ok(), "test command should pass with 'true'");
Ok(())
}
#[tokio::test]
async fn test_test_command_fail() -> 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?;
let commit_hash = git_manager.commit("base").await?;
let result = commands::test_command(
commit_hash.clone(),
vec!["false".to_string()],
).await;
assert!(result.is_err(), "test command should fail with 'false'");
Ok(())
}
#[tokio::test]
async fn test_test_command_restores_working_tree() -> 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("app.rs"), "fn main() { /* v1 */ }\n").await?;
git_manager.add_all().await?;
let commit1 = git_manager.commit("v1").await?;
tokio::fs::write(repo_path.join("app.rs"), "fn main() { /* v2 */ }\n").await?;
git_manager.add_all().await?;
let _commit2 = git_manager.commit("v2").await?;
let result = commands::test_command(
commit1.clone(),
vec!["true".to_string()],
).await;
assert!(result.is_ok());
let content = tokio::fs::read_to_string(repo_path.join("app.rs")).await?;
assert_eq!(content, "fn main() { /* v2 */ }\n", "working tree should be restored after test");
Ok(())
}
#[tokio::test]
async fn test_smartlog_command() -> 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, None,
None, false).await?;
commands::start_command(
"Fix logout".to_string(),
true, false, false,
None, None, None, None,
None, false).await?;
commands::start_command(
"Quick hotfix".to_string(),
false, false, true,
None, None, None, None,
None, false).await?;
commands::smartlog_command(false, false, None, None, false, false).await?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branches = git_manager.list_branches()?;
let first_op = branches.iter()
.filter(|b| b.name.starts_with("codetree_"))
.find(|b| b.name.contains("fix_login"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&first_op).await?;
tokio::fs::write(repo_path.join("login.rs"), "fn login() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("Login implementation").await?;
commands::finish_command(Some(first_op.clone()), None, false).await?;
commands::smartlog_command(false, false, None, None, false, false).await?;
Ok(())
}
#[tokio::test]
async fn test_smartlog_verbose() -> 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("Feature work".to_string(), true, false, false, None, None, None, None, None, false).await?;
let branches = git_manager.list_branches()?;
let op_name = branches.iter()
.find(|b| b.name.starts_with("codetree_"))
.map(|b| b.name.clone())
.unwrap();
git_manager.checkout_branch(&op_name).await?;
tokio::fs::write(repo_path.join("file1.rs"), "// file1\n").await?;
git_manager.add_all().await?;
git_manager.commit("First commit").await?;
tokio::fs::write(repo_path.join("file2.rs"), "// file2\n").await?;
git_manager.add_all().await?;
git_manager.commit("Second commit").await?;
git_manager.checkout_branch("main").await?;
commands::smartlog_command(true, false, None, None, false, false).await?;
commands::smartlog_command(false, false, None, None, false, false).await?;
Ok(())
}
#[tokio::test]
async fn test_list_query_filter() -> 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_one";
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![], "Op one".to_string()).await?;
branch_manager.add_tag(branch1, "sprint-42").await?;
let branch2 = "codetree_op_two";
git_manager.create_branch(branch2, None).await?;
branch_manager.register_branch(branch2, vec![], "Op two".to_string()).await?;
branch_manager.add_tag(branch2, "sprint-99").await?;
let branch3 = "codetree_op_three";
git_manager.create_branch(branch3, None).await?;
branch_manager.register_branch(branch3, vec![], "Op three".to_string()).await?;
branch_manager.mark_branch_merged(branch3).await?;
commands::list_command(None, Some("active && tag:sprint-42".to_string()), false, None).await?;
commands::list_command(None, Some("active".to_string()), false, None).await?;
commands::list_command(None, Some("merged".to_string()), false, None).await?;
commands::list_command(None, Some("active && tag:sprint-42 || merged".to_string()), false, None).await?;
commands::list_command(None, Some("active && tag:sprint-99".to_string()), false, None).await?;
Ok(())
}
#[tokio::test]
async fn test_list_query_negation_and_only_child() -> 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 child_a = "codetree_op_child_a";
git_manager.create_branch(child_a, None).await?;
let mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
branch_manager.register_branch(child_a, vec![], "Child A".to_string()).await?;
branch_manager.set_parent_branch(child_a, "main").await?;
let child_b = "codetree_op_child_b";
git_manager.create_branch(child_b, None).await?;
branch_manager.register_branch(child_b, vec![], "Child B".to_string()).await?;
branch_manager.set_parent_branch(child_b, "main").await?;
let child_c = "codetree_op_child_c";
git_manager.create_branch(child_c, None).await?;
branch_manager.register_branch(child_c, vec![], "Child C".to_string()).await?;
branch_manager.set_parent_branch(child_c, child_a).await?;
let merged = "codetree_op_merged";
git_manager.create_branch(merged, None).await?;
branch_manager.register_branch(merged, vec![], "Merged".to_string()).await?;
branch_manager.mark_branch_merged(merged).await?;
commands::list_command(None, Some("!active".to_string()), false, None).await?;
commands::list_command(None, Some("!".to_string()), false, None).await?;
commands::list_command(None, Some("active && !".to_string()), false, None).await?;
Ok(())
}
#[tokio::test]
async fn test_json_output_status() -> 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("app.rs"), "fn main() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("add app").await?;
tokio::fs::write(repo_path.join("new.rs"), "fn new() {}\n").await?;
commands::status_command(true).await?;
Ok(())
}
#[tokio::test]
async fn test_json_output_list() -> 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_json";
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![], "JSON test".to_string()).await?;
commands::list_command(None, None, true, None).await?;
commands::list_command(None, Some("active".to_string()), true, None).await?;
Ok(())
}
#[tokio::test]
async fn test_list_format_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?;
let git_manager = VcsManager::new(repo_path.clone())?;
let branch1 = "codetree_op_format";
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![], "Format test".to_string()).await?;
commands::list_command(
None,
None,
false,
Some("{name} | {status} | {description}".to_string()),
).await?;
Ok(())
}
#[tokio::test]
async fn test_smartlog_pagination() -> 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 mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
for i in 0..5 {
let name = format!("codetree_op_page_{}", i);
git_manager.create_branch(&name, None).await?;
branch_manager.register_branch(&name, vec![], format!("Page test {}", i)).await?;
}
commands::smartlog_command(false, false, None, None, false, false).await?;
commands::smartlog_command(false, false, Some(2), None, false, false).await?;
commands::smartlog_command(false, false, Some(2), Some(2), false, false).await?;
commands::smartlog_command(false, false, None, None, true, false).await?;
Ok(())
}
#[tokio::test]
async fn test_list_query_branches_pattern() -> 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 mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
for name in &["codetree_op_feat_auth", "codetree_op_feat_login", "codetree_op_fix_bug"] {
git_manager.create_branch(name, None).await?;
branch_manager.register_branch(name, vec![], "test".to_string()).await?;
}
commands::list_command(None, Some("branches(codetree_op_feat_*)".to_string()), false, None).await?;
commands::list_command(None, Some("branches(*fix*)".to_string()), false, None).await?;
commands::list_command(None, Some("merges()".to_string()), false, None).await?;
Ok(())
}
#[tokio::test]
async fn test_smartlog_exact() -> 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 mut branch_manager = BranchManager::new(
repo_path.join(".codetree").join("branches.json")
).await?;
git_manager.create_branch("codetree_op_exact_test", None).await?;
branch_manager.register_branch("codetree_op_exact_test", vec![], "test".to_string()).await?;
commands::smartlog_command(false, false, None, None, false, false).await?;
commands::smartlog_command(false, false, None, None, false, true).await?;
Ok(())
}
#[tokio::test]
async fn test_log_command() -> 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())?;
for i in 0..3 {
tokio::fs::write(repo_path.join(format!("file{}.rs", i)), format!("fn f{}() {{}}\n", i)).await?;
git_manager.add_all().await?;
git_manager.commit(&format!("commit {}", i)).await?;
}
commands::log_command(None, None, false).await?;
commands::log_command(None, Some(2), false).await?;
Ok(())
}
#[tokio::test]
async fn test_whereami_on_base() -> 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::whereami_command().await?;
Ok(())
}
#[tokio::test]
async fn test_whereami_on_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("Fix login".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();
git_manager.checkout_branch(&op_branch).await?;
commands::whereami_command().await?;
Ok(())
}
#[tokio::test]
async fn test_smartlog_position_flag() -> 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("Position test".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::smartlog_command(false, true, None, None, false, false).await?;
commands::smartlog_command(true, true, None, None, false, false).await?;
Ok(())
}
#[tokio::test]
async fn test_list_command_no_tag_filter() -> 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("List A".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::start_command("List B".to_string(), true, false, false, None, None, None, None, None, false).await?;
commands::list_command(None, None, false, None).await?;
commands::list_command(Some("nonexistent".to_string()), None, false, None).await?;
Ok(())
}
#[tokio::test]
async fn test_show_command() -> 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?;
git_manager.add_all().await?;
git_manager.commit("add file").await?;
commands::show_command("HEAD".to_string(), false).await?;
Ok(())
}
#[tokio::test]
async fn test_diff_command() -> 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?;
git_manager.add_all().await?;
git_manager.commit("initial").await?;
tokio::fs::write(repo_path.join("file.rs"), "fn main() { println!(\"hi\"); }\n").await?;
commands::diff_command(None).await?;
Ok(())
}
#[tokio::test]
async fn test_blame_command() -> 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"), "line1\nline2\nline3\n").await?;
git_manager.add_all().await?;
git_manager.commit("initial file").await?;
tokio::fs::write(repo_path.join("file.rs"), "line1\nline2 modified\nline3\n").await?;
git_manager.add_all().await?;
git_manager.commit("modify line 2").await?;
commands::blame_command("file.rs".to_string()).await?;
Ok(())
}
#[tokio::test]
async fn test_filelog_command() -> 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"), "v1\n").await?;
git_manager.add_all().await?;
git_manager.commit("first version").await?;
tokio::fs::write(repo_path.join("file.rs"), "v2\n").await?;
git_manager.add_all().await?;
git_manager.commit("second version").await?;
commands::filelog_command("file.rs".to_string()).await?;
Ok(())
}
#[tokio::test]
async fn test_clean_command() -> 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("tracked.rs"), "fn main() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("add tracked").await?;
tokio::fs::write(repo_path.join("untracked.rs"), "fn untracked() {}\n").await?;
assert!(repo_path.join("untracked.rs").exists());
commands::clean_command().await?;
assert!(!repo_path.join("untracked.rs").exists(), "untracked file should be removed");
assert!(repo_path.join("tracked.rs").exists(), "tracked file should remain");
Ok(())
}
#[tokio::test]
async fn test_gc_command() -> 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"), "v1\n").await?;
git_manager.add_all().await?;
git_manager.commit("first").await?;
tokio::fs::write(repo_path.join("file.rs"), "v2\n").await?;
git_manager.add_all().await?;
git_manager.commit("second").await?;
commands::reword_command("HEAD".to_string(), "reworded".to_string(), false).await?;
commands::gc_command().await?;
Ok(())
}
#[tokio::test]
async fn test_op_log_command() -> 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"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("test commit").await?;
commands::op_log_command().await?;
Ok(())
}
#[tokio::test]
async fn test_bisect() -> 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())?;
for i in 0..5 {
let content = if i >= 3 { "buggy\n" } else { "good\n" };
tokio::fs::write(repo_path.join("file.rs"), content).await?;
git_manager.add_all().await?;
git_manager.commit(&format!("commit {}", i)).await?;
}
commands::bisect_command(BisectAction::Start).await?;
let head_hash = git_manager.get_head_hash()?;
let repo = git_manager.repo();
let mut root = head_hash.clone();
loop {
let commit = repo.read_commit(&root)?;
if commit.parents.is_empty() {
break;
}
root = commit.parents[0].clone();
}
commands::bisect_command(BisectAction::Good(Some(root))).await?;
commands::bisect_command(BisectAction::Bad(None)).await?;
commands::bisect_command(BisectAction::Log).await?;
commands::bisect_command(BisectAction::Reset).await?;
Ok(())
}
#[tokio::test]
async fn test_tag_create_list_delete() -> 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"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("first").await?;
let head = git_manager.get_head_hash()?;
commands::tag_command(TagAction::Create {
name: "v1.0".to_string(),
commit: None,
annotate: None,
}).await?;
let repo = git_manager.repo();
let tag_commit = repo.refs().get_tag("v1.0")?;
assert_eq!(tag_commit, Some(head.clone()));
commands::tag_command(TagAction::List).await?;
commands::tag_command(TagAction::Create {
name: "v0.9".to_string(),
commit: Some("HEAD~1".to_string()),
annotate: None,
}).await?;
commands::tag_command(TagAction::Delete {
name: "v1.0".to_string(),
}).await?;
assert_eq!(repo.refs().get_tag("v1.0")?, None);
assert!(repo.refs().get_tag("v0.9")?.is_some());
Ok(())
}
#[tokio::test]
async fn test_tag_annotated() -> 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"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("release 1").await?;
commands::tag_command(TagAction::Create {
name: "v1.0".to_string(),
commit: None,
annotate: Some("Release 1.0 — first stable release".to_string()),
}).await?;
let repo = git_manager.repo();
assert!(repo.refs().get_tag("v1.0")?.is_some());
let annot_path = repo.refs().tag_path("v1.0").with_extension("annot");
assert!(annot_path.exists(), "Annotation file should exist");
let content = std::fs::read_to_string(&annot_path)?;
let ann: codetree::commands::tag::TagAnnotation = serde_json::from_str(&content)?;
assert_eq!(ann.message, "Release 1.0 — first stable release");
commands::tag_command(TagAction::List).await?;
commands::tag_command(TagAction::Delete {
name: "v1.0".to_string(),
}).await?;
assert!(!annot_path.exists(), "Annotation file should be deleted");
Ok(())
}
#[tokio::test]
async fn test_file_search() -> 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("main.rs"), "fn main() {\n println!(\"hello\");\n}\n").await?;
tokio::fs::write(repo_path.join("lib.rs"), "pub fn greet() {\n println!(\"hello\");\n}\n").await?;
git_manager.add_all().await?;
git_manager.commit("add files").await?;
commands::file_search_command("hello".to_string(), false).await?;
let results = git_manager.file_search("hello")?;
assert_eq!(results.len(), 2, "Should find 2 matches for 'hello'");
Ok(())
}
#[tokio::test]
async fn test_file_list() -> 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("file1.rs"), "content\n").await?;
tokio::fs::write(repo_path.join("file2.rs"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("add files").await?;
let files = git_manager.file_list(None)?;
assert!(files.contains(&"file1.rs".to_string()), "Should list file1.rs");
assert!(files.contains(&"file2.rs".to_string()), "Should list file2.rs");
commands::file_list_command(None).await?;
Ok(())
}
#[tokio::test]
async fn test_heads() -> 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"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("first").await?;
let heads = git_manager.heads()?;
assert!(!heads.is_empty(), "Should have at least one branch head");
commands::heads_command().await?;
Ok(())
}
#[tokio::test]
async fn test_log_count() -> 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())?;
for i in 0..3 {
tokio::fs::write(repo_path.join(format!("file{}.rs", i)), format!("content {}\n", i)).await?;
git_manager.add_all().await?;
git_manager.commit(&format!("commit {}", i)).await?;
}
commands::log_command(None, None, true).await?;
Ok(())
}
#[tokio::test]
async fn test_file_search_name_only() -> 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("main.rs"), "fn main() {}\n").await?;
tokio::fs::write(repo_path.join("lib.rs"), "pub fn lib() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("add files").await?;
let names = git_manager.file_search_names("main")?;
assert!(names.contains(&"main.rs".to_string()), "Should find main.rs by name");
commands::file_search_command("main".to_string(), true).await?;
Ok(())
}
#[tokio::test]
async fn test_forks() -> 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("base.rs"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("base").await?;
git_manager.create_branch("feature", None).await?;
let _forks = git_manager.forks()?;
commands::forks_command().await?;
Ok(())
}
#[tokio::test]
async fn test_merge_point() -> 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("base.rs"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("base").await?;
let base_hash = git_manager.get_head_hash()?;
tokio::fs::write(repo_path.join("a.rs"), "a\n").await?;
git_manager.add_all().await?;
git_manager.commit("a").await?;
let mp = git_manager.merge_point("HEAD", "HEAD")?;
assert!(mp.is_some(), "Merge point of HEAD with itself should exist");
let mp = git_manager.merge_point("HEAD", "HEAD~1")?;
assert_eq!(mp, Some(base_hash), "Merge point should be the base commit");
commands::merge_point_command("HEAD".to_string(), "HEAD~1".to_string()).await?;
Ok(())
}
#[tokio::test]
async fn test_verify() -> 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"), "content\n").await?;
git_manager.add_all().await?;
git_manager.commit("first").await?;
let issues = git_manager.verify_commit("HEAD")?;
assert!(issues.is_empty(), "HEAD should verify cleanly: {:?}", issues);
commands::verify_command("HEAD".to_string()).await?;
Ok(())
}
#[tokio::test]
async fn test_run_command() -> 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("file1.rs"), "fn f1() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("first").await?;
tokio::fs::write(repo_path.join("file2.rs"), "fn f2() {}\n").await?;
git_manager.add_all().await?;
git_manager.commit("second").await?;
commands::run_command("HEAD~1".to_string(), vec![
"sh".to_string(),
"-c".to_string(),
"echo running".to_string(),
]).await?;
let head_content = tokio::fs::read_to_string(repo_path.join("file2.rs")).await?;
assert_eq!(head_content, "fn f2() {}\n", "Working tree should be restored to HEAD after run");
Ok(())
}
#[tokio::test]
async fn test_config_get_set_list() -> 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::config_command(ConfigAction::List).await?;
commands::config_command(ConfigAction::Get("git.base_branch".to_string())).await?;
commands::config_command(ConfigAction::Set(
"git.base_branch".to_string(),
"develop".to_string(),
)).await?;
commands::config_command(ConfigAction::Get("git.base_branch".to_string())).await?;
Ok(())
}
#[tokio::test]
async fn test_provenance_prompt_and_why() -> Result<()> {
let (_temp_dir, repo_path) = create_test_repo().await?;
let _serial = WORKDIR_LOCK.lock().await;
let _guard = DirGuard::new(&repo_path);
commands::start_command(
"Fix login validation".to_string(),
false, false,
false,
None,
None,
None,
None,
Some("agent-7".to_string()),
false,
).await?;
tokio::fs::write(repo_path.join("login.rs"), "fn check() -> bool {\n true\n}\n").await?;
commands::save_command(
vec!["save work".to_string()],
false,
false,
Some("user asked to fix login validation".to_string()),
).await?;
let prov = codetree::provenance::ProvenanceLog::load(&repo_path)?;
assert_eq!(prov.entries.len(), 1);
let entry = &prov.entries[0];
assert_eq!(entry.agent_id.as_deref(), Some("agent-7"));
assert_eq!(entry.prompt.as_deref(), Some("user asked to fix login validation"));
assert!(entry.operation.contains("fix_login_validation"));
let mgr = VcsManager::new(repo_path.clone())?;
let info = commands::lookup_why(&mgr, &prov, "login.rs").await?;
assert_eq!(info.agent_id.as_deref(), Some("agent-7"));
assert_eq!(info.prompt.as_deref(), Some("user asked to fix login validation"));
assert!(info.operation.as_deref().unwrap().contains("fix_login_validation"));
let line_info = commands::lookup_why(&mgr, &prov, "login.rs:1").await?;
assert_eq!(line_info.commit, info.commit);
assert!(prov.get(&info.commit[..7]).is_some());
commands::why_command("login.rs".to_string()).await?;
commands::why_command("login.rs:1".to_string()).await?;
Ok(())
}