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

refactor(ui): test planning detail pane via real ViewModel and restore merge-all IsEnabled binding

Browse Source 
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
mika kuns
2026-04-24 16:31:54 +02:00
parent 9d04d1d9f6
commit 1aead9dad0
5 changed files with 162 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/ClaudeDo.Ui/AssemblyInfo.cs Normal file
View File

@@ -0,0 +1,2 @@
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("ClaudeDo.Ui.Tests")]

16
src/ClaudeDo.Ui/Services/IWorkerClient.cs
View File

@@ -1,7 +1,14 @@
using System.ComponentModel;
using ClaudeDo.Data.Models;
namespace ClaudeDo.Ui.Services;
public interface IWorkerClient
public interface IWorkerClient : INotifyPropertyChanged
{
bool IsConnected { get; }
event Action<string, string, DateTime>? TaskStartedEvent;
event Action<string, string, string, DateTime>? TaskFinishedEvent;
event Action<string>? TaskUpdatedEvent;
event Action<string>? WorktreeUpdatedEvent;
event Action<string, string>? TaskMessageEvent;
@@ -13,6 +20,13 @@ public interface IWorkerClient
event Action<string>? PlanningCompletedEvent;
Task WakeQueueAsync();
Task RunNowAsync(string taskId);
Task ContinueTaskAsync(string taskId, string followUpPrompt);
Task ResetTaskAsync(string taskId);
Task CancelTaskAsync(string taskId);
Task<List<AgentInfo>> GetAgentsAsync();
Task<ListConfigDto?> GetListConfigAsync(string listId);
Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsDto dto);
Task StartPlanningSessionAsync(string taskId, CancellationToken ct = default);
Task ResumePlanningSessionAsync(string taskId, CancellationToken ct = default);
Task DiscardPlanningSessionAsync(string taskId, CancellationToken ct = default);

6
src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs
View File

@@ -16,7 +16,7 @@ namespace ClaudeDo.Ui.ViewModels.Islands;
public sealed partial class DetailsIslandViewModel : ViewModelBase
{
private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
private readonly WorkerClient _worker;
private readonly IWorkerClient _worker;
private readonly IServiceProvider _services;
// Current task row (set by IslandsShellViewModel via Bind)
@@ -151,7 +151,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase
// Set by the view so DeleteTaskCommand can show an error message
public Func<string, System.Threading.Tasks.Task>? ShowErrorAsync { get; set; }
public DetailsIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, WorkerClient worker, IServiceProvider services)
public DetailsIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker, IServiceProvider services)
{
_dbFactory = dbFactory;
_worker = worker;
@@ -545,7 +545,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase
catch { /* best-effort */ }
}
private void RecomputeCanMergeAll()
internal void RecomputeCanMergeAll()
{
var notDone = Subtasks.Count(c => c.Status != ClaudeDo.Data.Models.TaskStatus.Done);
if (notDone > 0)

1
src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml
View File

@@ -157,6 +157,7 @@
<Button Content="Review combined diff"
Command="{Binding ReviewCombinedDiffCommand}"/>
<Button Content="Merge all subtasks"
IsEnabled="{Binding CanMergeAll}"
Command="{Binding MergeAllCommand}"
ToolTip.Tip="{Binding MergeAllDisabledReason}"/>
</StackPanel>

192
tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandPlanningTests.cs
View File

@@ -1,45 +1,52 @@
using System.Collections.ObjectModel;
using System.ComponentModel;
using ClaudeDo.Data;
using ClaudeDo.Data.Models;
using ClaudeDo.Ui.Services;
using ClaudeDo.Ui.ViewModels.Islands;
using Microsoft.EntityFrameworkCore;
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
namespace ClaudeDo.Ui.Tests.ViewModels;
public class DetailsIslandPlanningTests
public class DetailsIslandPlanningTests : IDisposable
{
// Minimal shim exercising RecomputeCanMergeAll logic without needing WorkerClient
private sealed class PlanningVmShim
{
public ObservableCollection<SubtaskRowViewModel> Subtasks { get; } = new();
public bool CanMergeAll { get; private set; }
public string? MergeAllDisabledReason { get; private set; }
private readonly string _dbPath;
public void RecomputeCanMergeAll()
public DetailsIslandPlanningTests()
{
var notDone = Subtasks.Count(c => c.Status != TaskStatus.Done);
if (notDone > 0)
_dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_details_test_{Guid.NewGuid():N}.db");
using var ctx = NewContext();
ctx.Database.EnsureCreated();
}
public void Dispose()
{
CanMergeAll = false;
MergeAllDisabledReason = $"{notDone} subtask(s) not done";
return;
try { File.Delete(_dbPath); } catch { }
try { File.Delete(_dbPath + "-wal"); } catch { }
try { File.Delete(_dbPath + "-shm"); } catch { }
}
var badWt = Subtasks.FirstOrDefault(c =>
c.WorktreeState == WorktreeState.Discarded ||
c.WorktreeState == WorktreeState.Kept);
if (badWt is not null)
private ClaudeDoDbContext NewContext()
{
CanMergeAll = false;
MergeAllDisabledReason = "at least one worktree was discarded/kept";
return;
}
CanMergeAll = true;
MergeAllDisabledReason = null;
var opts = new DbContextOptionsBuilder<ClaudeDoDbContext>()
.UseSqlite($"Data Source={_dbPath}")
.Options;
return new ClaudeDoDbContext(opts);
}
private sealed class TestDbFactory : IDbContextFactory<ClaudeDoDbContext>
{
private readonly Func<ClaudeDoDbContext> _create;
public TestDbFactory(Func<ClaudeDoDbContext> create) => _create = create;
public ClaudeDoDbContext CreateDbContext() => _create();
}
private sealed class FakeWorkerClient : IWorkerClient
{
public event PropertyChangedEventHandler? PropertyChanged;
public event Action<string, string, DateTime>? TaskStartedEvent;
public event Action<string, string, string, DateTime>? TaskFinishedEvent;
public event Action<string>? TaskUpdatedEvent;
public event Action<string>? WorktreeUpdatedEvent;
public event Action<string, string>? TaskMessageEvent;
@@ -49,9 +56,17 @@ public class DetailsIslandPlanningTests
public event Action<string>? PlanningMergeAbortedEvent;
public event Action<string>? PlanningCompletedEvent;
public bool IsConnected => false;
public MergeTargetsDto? MergeTargetsResult { get; set; }
public Task WakeQueueAsync() => Task.CompletedTask;
public Task RunNowAsync(string taskId) => Task.CompletedTask;
public Task ContinueTaskAsync(string taskId, string followUpPrompt) => Task.CompletedTask;
public Task ResetTaskAsync(string taskId) => Task.CompletedTask;
public Task CancelTaskAsync(string taskId) => Task.CompletedTask;
public Task<List<AgentInfo>> GetAgentsAsync() => Task.FromResult(new List<AgentInfo>());
public Task<ListConfigDto?> GetListConfigAsync(string listId) => Task.FromResult<ListConfigDto?>(null);
public Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsDto dto) => Task.CompletedTask;
public Task StartPlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
public Task ResumePlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
public Task DiscardPlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
@@ -65,70 +80,135 @@ public class DetailsIslandPlanningTests
public Task MergeAllPlanningAsync(string planningTaskId, string targetBranch) => Task.CompletedTask;
public Task ContinuePlanningMergeAsync(string planningTaskId) => Task.CompletedTask;
public Task AbortPlanningMergeAsync(string planningTaskId) => Task.CompletedTask;
}
public void FireTaskUpdated(string id) => TaskUpdatedEvent?.Invoke(id);
public void FireWorktreeUpdated(string id) => WorktreeUpdatedEvent?.Invoke(id);
private sealed class NullServiceProvider : IServiceProvider
{
public object? GetService(Type serviceType) => null;
}
private DetailsIslandViewModel BuildVm(FakeWorkerClient worker)
{
var factory = new TestDbFactory(NewContext);
return new DetailsIslandViewModel(factory, worker, new NullServiceProvider());
}
private static SubtaskRowViewModel MakeSubtask(TaskStatus status, WorktreeState wt = WorktreeState.Active) =>
new() { Id = Guid.NewGuid().ToString(), Title = "t", Status = status, WorktreeState = wt };
// ── CanMergeAll tests exercising the real VM ─────────────────────────────
[Fact]
public void CanMergeAll_AllChildrenDoneActiveWorktrees_True()
{
var shim = new PlanningVmShim();
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
var vm = BuildVm(new FakeWorkerClient());
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
shim.RecomputeCanMergeAll();
vm.RecomputeCanMergeAll();
Assert.True(shim.CanMergeAll);
Assert.Null(shim.MergeAllDisabledReason);
Assert.True(vm.CanMergeAll);
Assert.Null(vm.MergeAllDisabledReason);
}
[Fact]
public void CanMergeAll_AnyChildNotDone_FalseWithReason()
{
var shim = new PlanningVmShim();
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
shim.Subtasks.Add(MakeSubtask(TaskStatus.Running, WorktreeState.Active));
var vm = BuildVm(new FakeWorkerClient());
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
vm.Subtasks.Add(MakeSubtask(TaskStatus.Running, WorktreeState.Active));
shim.RecomputeCanMergeAll();
vm.RecomputeCanMergeAll();
Assert.False(shim.CanMergeAll);
Assert.NotNull(shim.MergeAllDisabledReason);
Assert.Contains("1 subtask", shim.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
Assert.Contains("not done", shim.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
Assert.False(vm.CanMergeAll);
Assert.NotNull(vm.MergeAllDisabledReason);
Assert.Contains("1 subtask", vm.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
Assert.Contains("not done", vm.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void CanMergeAll_AnyChildDiscarded_FalseWithReason()
{
var shim = new PlanningVmShim();
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Discarded));
var vm = BuildVm(new FakeWorkerClient());
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Discarded));
shim.RecomputeCanMergeAll();
vm.RecomputeCanMergeAll();
Assert.False(shim.CanMergeAll);
Assert.NotNull(shim.MergeAllDisabledReason);
Assert.False(vm.CanMergeAll);
Assert.NotNull(vm.MergeAllDisabledReason);
Assert.True(
shim.MergeAllDisabledReason!.Contains("discarded", StringComparison.OrdinalIgnoreCase) ||
shim.MergeAllDisabledReason.Contains("kept", StringComparison.OrdinalIgnoreCase));
vm.MergeAllDisabledReason!.Contains("discarded", StringComparison.OrdinalIgnoreCase) ||
vm.MergeAllDisabledReason.Contains("kept", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void MergeTargetBranches_LoadedFromWorkerOnPlanningParent()
public void CanMergeAll_AnyChildKept_FalseWithReason()
{
var fake = new FakeWorkerClient();
fake.MergeTargetsResult = new MergeTargetsDto("main", new[] { "main", "dev" });
var vm = BuildVm(new FakeWorkerClient());
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Kept));
var result = fake.GetMergeTargetsAsync("any-task-id").GetAwaiter().GetResult();
vm.RecomputeCanMergeAll();
Assert.NotNull(result);
Assert.Equal("main", result!.DefaultBranch);
Assert.Contains("main", result.LocalBranches);
Assert.Contains("dev", result.LocalBranches);
Assert.False(vm.CanMergeAll);
Assert.NotNull(vm.MergeAllDisabledReason);
Assert.True(
vm.MergeAllDisabledReason!.Contains("kept", StringComparison.OrdinalIgnoreCase) ||
vm.MergeAllDisabledReason.Contains("discarded", StringComparison.OrdinalIgnoreCase));
}
// ── Branch-load test exercising the VM via Bind ──────────────────────────
[Fact]
public async Task MergeTargetBranches_LoadedFromWorkerOnPlanningParent()
{
// Seed a Planning parent with one child that has a worktree
const string parentId = "parent-1";
const string childId = "child-1";
const string listId = "list-1";
await using (var ctx = NewContext())
{
ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
ctx.Tasks.Add(new TaskEntity
{
Id = parentId, ListId = listId, Title = "Parent",
Status = TaskStatus.Planning, CreatedAt = DateTime.UtcNow,
});
ctx.Tasks.Add(new TaskEntity
{
Id = childId, ListId = listId, Title = "Child",
Status = TaskStatus.Done, ParentTaskId = parentId, CreatedAt = DateTime.UtcNow,
});
ctx.Set<WorktreeEntity>().Add(new WorktreeEntity
{
TaskId = childId, Path = "/tmp/wt", BranchName = "branch",
BaseCommit = "abc", CreatedAt = DateTime.UtcNow,
});
await ctx.SaveChangesAsync();
}
var fake = new FakeWorkerClient
{
MergeTargetsResult = new MergeTargetsDto("main", new[] { "main", "dev" }),
};
var vm = BuildVm(fake);
// Bind triggers BindAsync → LoadPlanningChildrenAsync → GetMergeTargetsAsync
var parentRow = new TaskRowViewModel { Id = parentId };
parentRow.Status = TaskStatus.Planning;
vm.Bind(parentRow);
// Wait for the background load to settle
var deadline = DateTime.UtcNow.AddSeconds(5);
while (DateTime.UtcNow < deadline && vm.MergeTargetBranches.Count == 0)
await Task.Delay(20);
Assert.Contains("main", vm.MergeTargetBranches);
Assert.Contains("dev", vm.MergeTargetBranches);
Assert.Equal("main", vm.SelectedMergeTarget);
}
}