Skip to content

Improve conflict detection #368

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
geofflamrock merged 6 commits into from
Sep 11, 2025
Merged

Improve conflict detection #368

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
420e242
Improve conflict detection
geofflamrock Sep 8, 2025
0a012c7
Formatting
geofflamrock Sep 10, 2025
043af29
Logging improvements
geofflamrock Sep 10, 2025
eb72d0f
Cleanup
geofflamrock Sep 11, 2025
8061d49
Fix test names
geofflamrock Sep 11, 2025
249b33a
Fix issue with missing orig_head
geofflamrock Sep 11, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
258 changes: 77 additions & 181 deletions src/Stack.Tests/Commands/Helpers/StackActionsTests.cs
View file
Open in desktop

Large diffs are not rendered by default.

357 changes: 357 additions & 0 deletions src/Stack.Tests/Git/ConflictResolutionDetectorTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,357 @@
using System.Threading;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.Extensions.Logging;
using Meziantou.Extensions.Logging.Xunit;
using Stack.Git;
using Stack.Tests.Helpers;
using Xunit;
using Xunit.Abstractions;
using System.IO;
using System.Diagnostics;

namespace Stack.Tests.Git;

public class ConflictResolutionDetectorTests(ITestOutputHelper testOutputHelper)
{
private ILogger CreateLogger<T>() => XUnitLogger.CreateLogger<T>(testOutputHelper);

private static void RunGit(string workingDir, string args)
{
var psi = new ProcessStartInfo("git", args)
{
WorkingDirectory = workingDir,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
};
using var p = Process.Start(psi)!;
p.WaitForExit();
if (p.ExitCode != 0)
{
throw new Exception($"git {args} failed: {p.StandardError.ReadToEnd()}");
}
}

[Fact]
public async Task WaitForConflictResolution_WhenNotStarted_ReturnsNotStarted()
{
using var repo = new TestGitRepositoryBuilder().Build();
var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Merge,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromMilliseconds(200),
CancellationToken.None);

result.Should().Be(ConflictResolutionResult.NotStarted);
}

[Fact]
public async Task WaitForConflictResolution_WhenMergeCompletes_ReturnsCompleted()
{
var branchBase = Some.BranchName();
var branchOther = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(branchBase))
.WithBranch(b => b.WithName(branchOther).FromSourceBranch(branchBase))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// create conflicting change on base
git.ChangeBranch(branchBase);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

// different conflicting change on other branch
git.ChangeBranch(branchOther);
File.WriteAllText(filePath, "other");
repo.Stage(relFile);
repo.Commit();

// start merge that will conflict
git.ChangeBranch(branchBase);
try { git.MergeFromLocalSourceBranch(branchOther); } catch (ConflictException) { }

// small spin to ensure merge state file created before detector call
var spinStart = DateTime.UtcNow;
while (!git.IsMergeInProgress() && DateTime.UtcNow - spinStart < TimeSpan.FromMilliseconds(200))
{
await Task.Delay(10);
}

// Resolve conflict after a short delay
var resolver = Task.Run(async () =>
{
await Task.Delay(250); // ensure detector captured initial head/in-progress
File.WriteAllText(filePath, "resolved");
RunGit(repo.LocalDirectoryPath, $"add {relFile}");
RunGit(repo.LocalDirectoryPath, "commit -m resolved-merge");
});

var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Merge,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromSeconds(2),
CancellationToken.None);

await resolver;
result.Should().Be(ConflictResolutionResult.Completed);
}

[Fact]
public async Task WaitForConflictResolution_WhenMergeAborted_ReturnsAborted()
{
var branchBase = Some.BranchName();
var branchOther = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(branchBase))
.WithBranch(b => b.WithName(branchOther).FromSourceBranch(branchBase))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// conflicting commits
git.ChangeBranch(branchBase);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(branchOther);
File.WriteAllText(filePath, "other");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(branchBase);
try { git.MergeFromLocalSourceBranch(branchOther); } catch (ConflictException) { }

// Abort after delay
var aborter = Task.Run(async () => { await Task.Delay(60); git.AbortMerge(); });

var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Merge,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromSeconds(2),
CancellationToken.None);

await aborter;
result.Should().Be(ConflictResolutionResult.Aborted);
}

[Fact]
public async Task WaitForConflictResolution_WhenTimeoutReached_ReturnsTimeout()
{
var branchBase = Some.BranchName();
var branchOther = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(branchBase))
.WithBranch(b => b.WithName(branchOther).FromSourceBranch(branchBase))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// conflicting commits
git.ChangeBranch(branchBase);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(branchOther);
File.WriteAllText(filePath, "other");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(branchBase);
try { git.MergeFromLocalSourceBranch(branchOther); } catch (ConflictException) { }

// Do not resolve or abort; should timeout
var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Merge,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromMilliseconds(150),
CancellationToken.None);

result.Should().Be(ConflictResolutionResult.Timeout);
}

[Fact]
public async Task WaitForConflictResolution_WhenCancelled_Throws()
{
var branchBase = Some.BranchName();
var branchOther = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(branchBase))
.WithBranch(b => b.WithName(branchOther).FromSourceBranch(branchBase))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// conflicting commits to start rebase later
git.ChangeBranch(branchBase);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(branchOther);
File.WriteAllText(filePath, "other");
repo.Stage(relFile);
repo.Commit();

// start rebase that will conflict
try { git.RebaseFromLocalSourceBranch(branchBase); } catch (ConflictException) { }

using var cts = new CancellationTokenSource();
cts.CancelAfter(50);
var act = async () => await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Rebase,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromSeconds(2),
cts.Token);

await act.Should().ThrowAsync<OperationCanceledException>();
}

[Fact]
public async Task WaitForConflictResolution_WhenRebaseCompletes_ReturnsCompleted()
{
var baseBranch = Some.BranchName();
var featureBranch = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(baseBranch))
.WithBranch(b => b.WithName(featureBranch).FromSourceBranch(baseBranch))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// conflicting commits
git.ChangeBranch(baseBranch);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(featureBranch);
File.WriteAllText(filePath, "feature");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(featureBranch);
try { git.RebaseFromLocalSourceBranch(baseBranch); } catch (ConflictException) { }

// spin until rebase detected
var spinStart = DateTime.UtcNow;
while (!git.IsRebaseInProgress() && DateTime.UtcNow - spinStart < TimeSpan.FromMilliseconds(200))
{
await Task.Delay(10);
}

var resolver = Task.Run(async () =>
{
await Task.Delay(120);
File.WriteAllText(filePath, "resolved");
RunGit(repo.LocalDirectoryPath, $"add {relFile}");
var start = DateTime.UtcNow;
while (git.IsRebaseInProgress() && DateTime.UtcNow - start < TimeSpan.FromSeconds(3))
{
try
{
// Provide inline editor config so git doesn't try to launch an interactive editor
RunGit(repo.LocalDirectoryPath, "-c core.editor=true rebase --continue");
}
catch (Exception)
{
// If still conflicts (unlikely after we wrote resolved file) just wait and retry
}
await Task.Delay(40);
}
});

var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Rebase,
TimeSpan.FromMilliseconds(10),
null,
CancellationToken.None);

await resolver;
result.Should().Be(ConflictResolutionResult.Completed);
}

[Fact]
public async Task WaitForConflictResolution_WhenRebaseAborted_ReturnsAborted()
{
var baseBranch = Some.BranchName();
var featureBranch = Some.BranchName();
using var repo = new TestGitRepositoryBuilder()
.WithBranch(b => b.WithName(baseBranch))
.WithBranch(b => b.WithName(featureBranch).FromSourceBranch(baseBranch))
.Build();

var logger = CreateLogger<ConflictResolutionDetectorTests>();
var git = new GitClient(XUnitLogger.CreateLogger<GitClient>(testOutputHelper), repo.ExecutionContext);

var relFile = Some.Name();
var filePath = Path.Join(repo.LocalDirectoryPath, relFile);

// conflicting commits
git.ChangeBranch(baseBranch);
File.WriteAllText(filePath, "base");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(featureBranch);
File.WriteAllText(filePath, "feature");
repo.Stage(relFile);
repo.Commit();

git.ChangeBranch(featureBranch);
try { git.RebaseFromLocalSourceBranch(baseBranch); } catch (ConflictException) { }

var aborter = Task.Run(async () => { await Task.Delay(60); git.AbortRebase(); });

var result = await ConflictResolutionDetector.WaitForConflictResolution(
git,
logger,
ConflictOperationType.Rebase,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromSeconds(2),
CancellationToken.None);

await aborter;
result.Should().Be(ConflictResolutionResult.Aborted);
}
}
Loading
Loading