releases/ClaudeDo
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 24 Wiki Activity

Merge branch 'claudedo/9e3071992eca4eb79057d2c675cc57ca'

Browse Source
This commit is contained in:
mika kuns
2026-08-05 12:05:18 +02:00
parent 32c019bd5d 10e561f336
commit 3e7126b3f2
16 changed files with 1813 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs
Vendored
+105
View File
@@ -626,6 +626,39 @@ public sealed class ExternalMcpServiceTests : IDisposable
Assert.False(info.IsDirty);
}
[Fact]
public async Task GetTaskWorktree_BeforeMerge_MergeCommitIsNull()
{
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
var (task, _, _) = await SeedWorktreeAsync();
var sut = BuildSut(CreateQueue());
var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
Assert.Null(info.MergeCommit);
}
[Fact]
public async Task GetTaskWorktree_AfterMerge_ExposesMergeCommit()
{
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "new\n");
GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: add file");
var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
var sut = BuildSut(CreateQueue());
await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
var info = await sut.GetTaskWorktree(task.Id, CancellationToken.None);
var expected = GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim();
Assert.Equal(expected, info.MergeCommit);
}
// ── GetTaskDiff ────────────────────────────────────────────────────────────
[Fact]
@@ -1138,6 +1171,78 @@ public sealed class ExternalMcpServiceTests : IDisposable
Assert.Contains("mid-merge", ex.Message);
}
// ── RevertMerge ────────────────────────────────────────────────────────────
[Fact]
public async Task RevertMerge_NotMerged_Throws()
{
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
var (task, _, _) = await SeedWorktreeAsync(TaskStatus.Done);
var sut = BuildSut(CreateQueue());
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
() => sut.RevertMerge(task.Id, "main", CancellationToken.None));
Assert.Contains("expected Merged", ex.Message);
}
[Fact]
public async Task RevertMerge_AfterCleanMerge_RevertsAndReturnsTaskToWaitingForReview()
{
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
File.WriteAllText(Path.Combine(wt.WorktreePath, "added.txt"), "new\n");
GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: add file");
var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
var sut = BuildSut(CreateQueue());
await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
Assert.True(File.Exists(Path.Combine(list.WorkingDir!, "added.txt")));
var result = await sut.RevertMerge(task.Id, target, CancellationToken.None);
Assert.True(result.Reverted);
Assert.False(string.IsNullOrWhiteSpace(result.RevertCommit));
Assert.Empty(result.Conflicts);
Assert.False(File.Exists(Path.Combine(list.WorkingDir!, "added.txt")));
var reloaded = await _tasks.GetByIdAsync(task.Id);
Assert.Equal(TaskStatus.WaitingForReview, reloaded!.Status);
}
[Fact]
public async Task RevertMerge_ConflictingRevert_ReturnsRevertedFalseWithConflictsAndAbortsCleanly()
{
if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
var (task, list, wt) = await SeedWorktreeAsync(TaskStatus.Done);
File.WriteAllText(Path.Combine(wt.WorktreePath, "README.md"), "# test repo\nfeature\n");
GitRepoFixture.RunGit(wt.WorktreePath, "add", "-A");
GitRepoFixture.RunGit(wt.WorktreePath, "commit", "-m", "feat: append feature line");
var target = await new GitService().GetCurrentBranchAsync(list.WorkingDir!, CancellationToken.None);
var sut = BuildSut(CreateQueue());
await sut.MergeTask(task.Id, target, true, false, false, cancellationToken: CancellationToken.None);
// A later commit on main edits the exact line the merge introduced, so the revert conflicts.
File.WriteAllText(Path.Combine(list.WorkingDir!, "README.md"), "# test repo\npost-merge edit\n");
GitRepoFixture.RunGit(list.WorkingDir!, "add", "-A");
GitRepoFixture.RunGit(list.WorkingDir!, "commit", "-m", "chore: edit the same line");
var headBefore = GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim();
var result = await sut.RevertMerge(task.Id, target, CancellationToken.None);
Assert.False(result.Reverted);
Assert.Contains("README.md", result.Conflicts);
Assert.False(await new GitService().IsMidRevertAsync(list.WorkingDir!));
Assert.Equal(headBefore, GitRepoFixture.RunGit(list.WorkingDir!, "rev-parse", "HEAD").Trim());
var reloaded = await _tasks.GetByIdAsync(task.Id);
Assert.Equal(TaskStatus.Done, reloaded!.Status);
}
[Fact]
public async Task ContinueMerge_ParentUnitMergeConflict_RoutesToOrchestratorAndCompletes()
{
tests/ClaudeDo.Worker.Tests/Runner/GitServiceMergeTests.cs
+91
View File
@@ -226,4 +226,95 @@ public class GitServiceMergeTests : IDisposable
await git.MergeAbortAsync(repo.RepoDir);
}
[Fact]
public async Task IsMidRevertAsync_FreshRepo_ReturnsFalse()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var git = new GitService();
Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
}
[Fact]
public async Task IsMidRevertAsync_RevertHeadPresent_ReturnsTrue()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var revertHead = Path.Combine(repo.RepoDir, ".git", "REVERT_HEAD");
File.WriteAllText(revertHead, "0000000000000000000000000000000000000000\n");
var git = new GitService();
Assert.True(await git.IsMidRevertAsync(repo.RepoDir));
}
[Fact]
public async Task RevertMergeCommitAsync_CleanMerge_ReturnsZero_AndUndoesMergedChange()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "feature/revert");
File.WriteAllText(Path.Combine(repo.RepoDir, "feature.txt"), "hello\n");
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "feat: add feature.txt");
try { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "main"); }
catch { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "master"); }
var git = new GitService();
var (mergeExit, _) = await git.MergeNoFfAsync(repo.RepoDir, "feature/revert", "Merge feature/revert");
Assert.Equal(0, mergeExit);
var mergeSha = (await git.RevParseHeadAsync(repo.RepoDir)).Trim();
Assert.True(File.Exists(Path.Combine(repo.RepoDir, "feature.txt")));
var (revertExit, _) = await git.RevertMergeCommitAsync(repo.RepoDir, mergeSha);
Assert.Equal(0, revertExit);
Assert.False(File.Exists(Path.Combine(repo.RepoDir, "feature.txt")));
Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
// History stays intact — both the merge and the new revert commit are reachable.
var log = GitRepoFixture.RunGit(repo.RepoDir, "log", "--oneline");
Assert.Contains(mergeSha[..7], log);
}
[Fact]
public async Task RevertMergeCommitAsync_ConflictingSubsequentEdit_ReturnsNonZero_AndAbortCleansUp()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
GitRepoFixture.RunGit(repo.RepoDir, "checkout", "-b", "feature/revert-conflict");
File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\nfeature\n");
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "feat: append feature line");
try { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "main"); }
catch { GitRepoFixture.RunGit(repo.RepoDir, "checkout", "master"); }
var git = new GitService();
var (mergeExit, _) = await git.MergeNoFfAsync(repo.RepoDir, "feature/revert-conflict", "Merge feature/revert-conflict");
Assert.Equal(0, mergeExit);
var mergeSha = (await git.RevParseHeadAsync(repo.RepoDir)).Trim();
// A direct edit on main to the same line the merge introduced makes the revert conflict.
File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\npost-merge edit\n");
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "chore: edit the same line");
var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
var (revertExit, _) = await git.RevertMergeCommitAsync(repo.RepoDir, mergeSha);
Assert.NotEqual(0, revertExit);
Assert.True(await git.IsMidRevertAsync(repo.RepoDir));
var conflicted = await git.ListConflictedFilesAsync(repo.RepoDir);
Assert.Contains("README.md", conflicted);
await git.RevertAbortAsync(repo.RepoDir);
Assert.False(await git.IsMidRevertAsync(repo.RepoDir));
Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
Assert.True(string.IsNullOrWhiteSpace(GitRepoFixture.RunGit(repo.RepoDir, "status", "--porcelain")));
}
}
tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs
+212 -2
View File
@@ -54,7 +54,8 @@ public class TaskMergeServiceTests : IDisposable
}
private static async Task SeedWorktree(
DbFixture db, string taskId, string path, string branchName, string baseCommit)
DbFixture db, string taskId, string path, string branchName, string baseCommit,
WorktreeState state = WorktreeState.Active, string? mergeCommit = null)
{
var wt = new WorktreeEntity
{
@@ -62,7 +63,8 @@ public class TaskMergeServiceTests : IDisposable
Path = path,
BranchName = branchName,
BaseCommit = baseCommit,
State = WorktreeState.Active,
State = state,
MergeCommit = mergeCommit,
CreatedAt = DateTime.UtcNow,
};
using var ctx = db.CreateContext();
@@ -772,6 +774,214 @@ public class TaskMergeServiceTests : IDisposable
Assert.Equal("# resolved by user\n", File.ReadAllText(Path.Combine(repo.RepoDir, "README.md")));
Assert.False(await new GitService().IsMidMergeAsync(repo.RepoDir));
}
[Fact]
public async Task MergeAsync_Success_RecordsMergeCommitOnWorktree()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var db = NewDb();
var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
var wtMgr = BuildWorktreeManager(db);
var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
_wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
var (svc, _) = BuildService(db);
var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
var result = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: false,
commitMessage: "Merge task", ct: CancellationToken.None);
Assert.Equal("merged", result.Status);
var headSha = (await new GitService().RevParseHeadAsync(repo.RepoDir)).Trim();
using var ctx = db.CreateContext();
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
Assert.Equal(headSha, wt!.MergeCommit);
}
[Fact]
public async Task RevertMergeAsync_NoWorktree_ReturnsBlocked()
{
var db = NewDb();
var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
var (svc, _) = BuildService(db);
var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
Assert.Contains("no worktree", result.ErrorMessage ?? "");
}
[Fact]
public async Task RevertMergeAsync_TaskNotDone_ReturnsBlocked()
{
var db = NewDb();
var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.WaitingForReview);
await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
state: WorktreeState.Merged, mergeCommit: "cafebabe");
var (svc, _) = BuildService(db);
var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
Assert.Contains("not Done", result.ErrorMessage ?? "");
}
[Fact]
public async Task RevertMergeAsync_NoMergeCommitRecorded_ReturnsBlocked()
{
// Simulates a worktree merged before this feature existed — Merged state, no SHA.
var db = NewDb();
var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
state: WorktreeState.Merged, mergeCommit: null);
var (svc, _) = BuildService(db);
var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
Assert.Contains("no merge commit recorded", result.ErrorMessage ?? "");
}
[Fact]
public async Task RevertMergeAsync_WorktreeNotMerged_ReturnsBlocked()
{
var db = NewDb();
var (_, task) = await SeedListAndTask(db, workingDir: "/tmp", status: TaskStatus.Done);
await SeedWorktree(db, task.Id, "/tmp/wt", "claudedo/x", "deadbeef",
state: WorktreeState.Active, mergeCommit: null);
var (svc, _) = BuildService(db);
var result = await svc.RevertMergeAsync(task.Id, "main", CancellationToken.None);
Assert.Equal(TaskMergeService.StatusBlocked, result.Status);
Assert.Contains("expected Merged", result.ErrorMessage ?? "");
}
[Fact]
public async Task RevertMergeAsync_AfterCleanMerge_CreatesRevertCommitAndResetsState()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var db = NewDb();
var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
var wtMgr = BuildWorktreeManager(db);
var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
_wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
var (svc, proxy) = BuildService(db);
var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
commitMessage: "Merge task", ct: CancellationToken.None);
Assert.Equal("merged", mergeResult.Status);
Assert.True(File.Exists(Path.Combine(repo.RepoDir, "added.txt")));
var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
Assert.Equal(TaskMergeService.StatusReverted, revertResult.Status);
Assert.False(string.IsNullOrWhiteSpace(revertResult.RevertCommit));
Assert.Empty(revertResult.ConflictFiles);
Assert.False(File.Exists(Path.Combine(repo.RepoDir, "added.txt")));
using var ctx = db.CreateContext();
var updatedTask = await new TaskRepository(ctx).GetByIdAsync(task.Id);
Assert.Equal(TaskStatus.WaitingForReview, updatedTask!.Status);
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
Assert.Equal(WorktreeState.Kept, wt!.State);
Assert.Contains(proxy.Calls, c => c.Method == "WorktreeUpdated" && c.Args[0] is string s && s == task.Id);
}
[Fact]
public async Task RevertMergeAsync_UncommittedChangesInTarget_ReturnsBlocked()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var db = NewDb();
var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
var wtMgr = BuildWorktreeManager(db);
var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
_wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "added.txt"), "new\n");
await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
var (svc, _) = BuildService(db);
var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
commitMessage: "Merge task", ct: CancellationToken.None);
Assert.Equal("merged", mergeResult.Status);
// A concurrent session leaves an uncommitted, tracked-file change in the shared checkout.
File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "dirty from another session\n");
var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
Assert.Equal(TaskMergeService.StatusBlocked, revertResult.Status);
Assert.Contains("uncommitted", revertResult.ErrorMessage ?? "");
Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
using var ctx = db.CreateContext();
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
Assert.Equal(WorktreeState.Merged, wt!.State);
}
[Fact]
public async Task RevertMergeAsync_ConflictingRevert_AbortsCleanlyAndReportsConflictFiles()
{
if (!GitRepoFixture.IsGitAvailable()) return;
var repo = NewRepo();
var db = NewDb();
var (list, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.Done);
var wtMgr = BuildWorktreeManager(db);
var wtCtx = await wtMgr.CreateAsync(task, list, CancellationToken.None);
_wtCleanups.Add((repo.RepoDir, wtCtx.WorktreePath));
File.WriteAllText(Path.Combine(wtCtx.WorktreePath, "README.md"), "# test repo\nfeature\n");
await wtMgr.CommitIfChangedAsync(wtCtx, task, list, CancellationToken.None);
var (svc, _) = BuildService(db);
var currentBranch = await new GitService().GetCurrentBranchAsync(repo.RepoDir);
var mergeResult = await svc.MergeAsync(task.Id, currentBranch, removeWorktree: true,
commitMessage: "Merge task", ct: CancellationToken.None);
Assert.Equal("merged", mergeResult.Status);
// A later commit on the target edits the exact line the merge introduced, so the revert conflicts.
File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# test repo\npost-merge edit\n");
GitRepoFixture.RunGit(repo.RepoDir, "add", "-A");
GitRepoFixture.RunGit(repo.RepoDir, "commit", "-m", "chore: edit the same line");
var headBefore = GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim();
var revertResult = await svc.RevertMergeAsync(task.Id, currentBranch, CancellationToken.None);
Assert.Equal(TaskMergeService.StatusConflictAborted, revertResult.Status);
Assert.Contains("README.md", revertResult.ConflictFiles);
Assert.False(await new GitService().IsMidRevertAsync(repo.RepoDir));
Assert.Equal(headBefore, GitRepoFixture.RunGit(repo.RepoDir, "rev-parse", "HEAD").Trim());
Assert.True(string.IsNullOrWhiteSpace(GitRepoFixture.RunGit(repo.RepoDir, "status", "--porcelain")));
// Task/worktree state must not change on a conflicted, aborted revert.
using var ctx = db.CreateContext();
var updatedTask = await new TaskRepository(ctx).GetByIdAsync(task.Id);
Assert.Equal(TaskStatus.Done, updatedTask!.Status);
var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.Id);
Assert.Equal(WorktreeState.Merged, wt!.State);
}
}
#region Test doubles