DiffRunnerTests.cs

#if NET10_0
[NotInParallel]
// Needs the Windows only FakeDiffTool.exe, or the Win32 process APIs.
[RunOn(TUnit.Core.Enums.OS.Windows)]
public class DiffRunnerTests
{
    static string SourceDirectory { get; } = Path.GetDirectoryName(GetSourceFile())!;
    static string GetSourceFile([CallerFilePath] string path = "") => path;

    static ResolvedTool tool;
    string file2;
    string file1;
    string command;

    [Test]
    [Skip("Explicit")]
    public async Task MaxInstancesToLaunch()
    {
        DiffRunner.MaxInstancesToLaunch(1);
        try
        {
            await Task.Delay(500);
            ProcessCleanup.Refresh();
            var result = await DiffRunner.LaunchAsync(file1, "fake.txt");
            await Task.Delay(300);
            await Assert.That(result).IsEqualTo(LaunchResult.StartedNewInstance);
            ProcessCleanup.Refresh();
            result = await DiffRunner.LaunchAsync(file2, "fake.txt");
            await Assert.That(result).IsEqualTo(LaunchResult.TooManyRunningDiffTools);
            ProcessCleanup.Refresh();
            DiffRunner.Kill(file1, "fake.txt");
            DiffRunner.Kill(file2, "fake.txt");
        }
        finally
        {
            DiffRunner.MaxInstancesToLaunch(5);
        }
    }

    [Test]
    [Skip("Explicit")]
    public async Task MaxInstancesToLaunchAsync()
    {
        DiffRunner.MaxInstancesToLaunch(1);
        try
        {
            await Task.Delay(500);
            ProcessCleanup.Refresh();
            var result = await DiffRunner.LaunchAsync(file1, "fake.txt");
            await Task.Delay(300);
            await Assert.That(result).IsEqualTo(LaunchResult.StartedNewInstance);
            ProcessCleanup.Refresh();
            result = await DiffRunner.LaunchAsync(file2, "fake.txt");
            await Assert.That(result).IsEqualTo(LaunchResult.TooManyRunningDiffTools);
            ProcessCleanup.Refresh();
            DiffRunner.Kill(file1, "fake.txt");
            DiffRunner.Kill(file2, "fake.txt");
        }
        finally
        {
            DiffRunner.MaxInstancesToLaunch(5);
        }
    }

    static async Task Launch()
    {
        var targetFile = "";
        var tempFile = "";

        #region DiffRunnerLaunch

        await DiffRunner.LaunchAsync(tempFile, targetFile);

        #endregion
    }

    [Test]
    [Skip("Explicit")]
    public async Task KillAsync()
    {
        await DiffRunner.LaunchAsync(file1, file2);
        ProcessCleanup.Refresh();

        #region DiffRunnerKill

        DiffRunner.Kill(file1, file2);

        #endregion
    }

    [Test]
    public async Task LaunchAndKillDisabled()
    {
        DiffRunner.Disabled = true;
        try
        {
            await WaitForRunning(false);
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
            var result = await DiffRunner.LaunchAsync(file1, file2);
            await Assert.That(result).IsEqualTo(LaunchResult.Disabled);
            Thread.Sleep(500);
            ProcessCleanup.Refresh();
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
            DiffRunner.Kill(file1, file2);
            Thread.Sleep(500);
            ProcessCleanup.Refresh();
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
        }
        finally
        {
            DiffRunner.Disabled = false;
        }
    }

    [Test]
    public async Task LaunchAndKillDisabledAsync()
    {
        DiffRunner.Disabled = true;
        try
        {
            await WaitForRunning(false);
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
            var result = await DiffRunner.LaunchAsync(file1, file2);
            await Assert.That(result).IsEqualTo(LaunchResult.Disabled);
            Thread.Sleep(500);
            ProcessCleanup.Refresh();
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
            DiffRunner.Kill(file1, file2);
            Thread.Sleep(500);
            ProcessCleanup.Refresh();
            await Assert.That(IsRunning()).IsFalse();
            await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
        }
        finally
        {
            DiffRunner.Disabled = false;
        }
    }

    [Test]
    public async Task LaunchAndKill()
    {
        await WaitForRunning(false);
        await Assert.That(IsRunning()).IsFalse();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
        var result = await DiffRunner.LaunchAsync(file1, file2);
        await Assert.That(result).IsEqualTo(LaunchResult.StartedNewInstance);
        await WaitForRunning(true);
        await Assert.That(IsRunning()).IsTrue();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsTrue();
        DiffRunner.Kill(file1, file2);
        await WaitForRunning(false);
        await Assert.That(IsRunning()).IsFalse();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
    }

    [Test]
    public async Task LaunchAndKillAsync()
    {
        await WaitForRunning(false);
        await Assert.That(IsRunning()).IsFalse();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
        var result = await DiffRunner.LaunchAsync(file1, file2);
        await Assert.That(result).IsEqualTo(LaunchResult.StartedNewInstance);
        await WaitForRunning(true);
        await Assert.That(IsRunning()).IsTrue();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsTrue();
        DiffRunner.Kill(file1, file2);
        await WaitForRunning(false);
        await Assert.That(IsRunning()).IsFalse();
        await Assert.That(ProcessCleanup.IsRunning(command)).IsFalse();
    }

    // Match this test's exact command, not any FakeDiffTool: DiffEngineTray.Tests
    // runs concurrently in the same CI job and launches its own FakeDiffTool
    // instances, which a machine-wide substring scan would see.
    bool IsRunning()
    {
        var expected = command;
        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            expected = expected.Replace("\"", "");
        }

        return ProcessCleanup
            .FindAll()
            .Any(_ => _.Command == expected);
    }

    // Process spawn and kill are asynchronous, so poll instead of guessing with a
    // fixed sleep. Also used at test start: the previous test's kill may still be
    // completing when the next test begins.
    // Both views must agree before returning: IsRunning() scans processes fresh,
    // while ProcessCleanup.IsRunning(command) reads the cached list from the last
    // Refresh(). A process dying between the two reads would otherwise leave the
    // cache stale and fail the cached assert.
    async Task WaitForRunning(bool expected)
    {
        for (var attempt = 0; attempt < 40; attempt++)
        {
            ProcessCleanup.Refresh();
            if (ProcessCleanup.IsRunning(command) == expected &&
                IsRunning() == expected)
            {
                return;
            }

            await Task.Delay(250);
        }
    }

    public DiffRunnerTests()
    {
        file1 = Path.Combine(SourceDirectory, "DiffRunner.file1.txt");
        file2 = Path.Combine(SourceDirectory, "DiffRunner.file2.txt");
        command = tool.BuildCommand(file1, file2);
    }

    static DiffRunnerTests() =>
        tool = DiffTools.AddTool(
            name: "FakeDiffTool",
            autoRefresh: true,
            isMdi: false,
            supportsText: true,
            useShellExecute: true,
            requiresTarget: true,
            launchArguments: new(
                Left: (tempFile, targetFile) => $"\"{tempFile}\" \"{targetFile}\"",
                Right: (tempFile, targetFile) => $"\"{targetFile}\" \"{tempFile}\""),
            exePath: FakeDiffTool.Exe,
            binaryExtensions: [".knownBin"])!;
}
#endif