// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Text;
using Aspire.Cli.Diagnostics;
using Aspire.Cli.Git;
using Aspire.Cli.Interaction;
using Aspire.Cli.Resources;
using Aspire.Cli.Tests.TestServices;
using Microsoft.AspNetCore.InternalTesting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing;
namespace Aspire.Cli.Tests.Git;
public partial class GitCommandRunnerTests(ITestOutputHelper outputHelper) : IDisposable
{
private readonly ILoggerFactory _loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Trace).AddXunit(outputHelper));
private readonly ConsoleEnvironment _consoleEnvironment = TestHelpers.CreateConsoleEnvironment(TextWriter.Null, TextWriter.Null);
public void Dispose() => _loggerFactory.Dispose();
private GitCommandRunner CreateRunner() =>
new(TestHelpers.CreateInteractiveHostEnvironment(), new TestInteractionService(), _consoleEnvironment, _loggerFactory.CreateLogger<GitCommandRunner>());
[Fact]
public void CreateStartInfo_CapturedCommandsUseLiteralArgumentsAndPreserveCredentialHelpers()
{
var runner = CreateRunner();
var startInfo = runner.CreateStartInfo(Environment.CurrentDirectory,
["fetch", "--", "-repository with spaces", "HEAD"], GitCommandMode.Captured);
Assert.Equal("git", startInfo.FileName);
Assert.Equal(["--literal-pathspecs", "fetch", "--", "-repository with spaces", "HEAD"], startInfo.ArgumentList);
Assert.Equal("0", startInfo.Environment["GIT_TERMINAL_PROMPT"]);
Assert.Equal("C", startInfo.Environment["LC_ALL"]);
startInfo.Environment.TryGetValue("GCM_INTERACTIVE", out var credentialManager);
Assert.Equal(Environment.GetEnvironmentVariable("GCM_INTERACTIVE"), credentialManager);
Assert.True(startInfo.RedirectStandardInput);
Assert.True(startInfo.RedirectStandardOutput);
Assert.True(startInfo.RedirectStandardError);
Assert.True(startInfo.CreateNoWindow);
}
[Theory]
[InlineData("GIT_DIR", true)]
[InlineData("GIT_WORK_TREE", true)]
[InlineData("GIT_INDEX_FILE", true)]
[InlineData("GIT_OBJECT_DIRECTORY", true)]
[InlineData("GIT_ALTERNATE_OBJECT_DIRECTORIES", true)]
[InlineData("GIT_COMMON_DIR", true)]
[InlineData("GIT_NAMESPACE", true)]
[InlineData("GIT_SHALLOW_FILE", true)]
[InlineData("git_dir", true)]
[InlineData("GIT_ASKPASS", false)]
[InlineData("GIT_SSH_COMMAND", false)]
[InlineData("GIT_CONFIG_COUNT", false)]
[InlineData("HOME", false)]
[InlineData("PATH", false)]
public void FilterEnvironment_IsolatesRepositoryButPreservesAuthentication(string name, bool removed)
{
var environment = new Dictionary<string, string?> { [name] = "test-value" };
GitCommandRunner.FilterEnvironment(environment, GitCommandMode.Captured);
Dictionary<string, string?> expected = removed ? [] : new() { [name] = "test-value" };
Assert.Equal(expected, environment);
}
[Theory]
[InlineData(nameof(GitCommandMode.Interactive))]
[InlineData(nameof(GitCommandMode.Unattended))]
public void FilterEnvironment_PreservesConfigurationSourceIsolationPolicy(string mode)
{
var environment = new Dictionary<string, string?>
{
["GIT_DIR"] = "other-repository",
["GIT_COMMON_DIR"] = "existing-common-directory",
["GIT_CONFIG_COUNT"] = "1",
["GIT_SSH_COMMAND"] = "configured-ssh"
};
GitCommandRunner.FilterEnvironment(environment, Enum.Parse<GitCommandMode>(mode));
Assert.Equal(new Dictionary<string, string?>
{
["GIT_COMMON_DIR"] = "existing-common-directory",
["GIT_CONFIG_COUNT"] = "1",
["GIT_SSH_COMMAND"] = "configured-ssh"
}, environment);
}
[Theory]
[InlineData(nameof(GitCommandMode.Interactive), false)]
[InlineData(nameof(GitCommandMode.Interactive), true)]
[InlineData(nameof(GitCommandMode.Unattended), false)]
[InlineData(nameof(GitCommandMode.Unattended), true)]
public void FilterEnvironment_UsesDictionaryCaseSensitivityForConfigurationSources(string mode, bool ignoreCase)
{
var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
string[] repositoryVariables =
[
"git_dir", "Git_Work_Tree", "git_index_file", "Git_Object_Directory", "git_alternate_object_directories"
];
var environment = new Dictionary<string, string?>(comparer);
foreach (var key in repositoryVariables)
{
environment[key] = "other-repository";
}
environment["GIT_CONFIG_COUNT"] = "1";
GitCommandRunner.FilterEnvironment(environment, Enum.Parse<GitCommandMode>(mode));
var expected = new Dictionary<string, string?>(comparer) { ["GIT_CONFIG_COUNT"] = "1" };
if (!ignoreCase)
{
foreach (var key in repositoryVariables)
{
expected[key] = "other-repository";
}
}
Assert.Equal(expected, environment);
}
[Theory]
[InlineData("fatal: repository not found", nameof(GitFailure.RepositoryUnavailable))]
[InlineData("fatal: could not resolve host", nameof(GitFailure.RepositoryUnavailable))]
[InlineData("fatal: unable to access repository", nameof(GitFailure.RepositoryUnavailable))]
[InlineData("fatal: could not read from remote repository", nameof(GitFailure.RepositoryUnavailable))]
[InlineData("fatal: Authentication failed", nameof(GitFailure.AuthenticationFailed))]
[InlineData("Permission denied (publickey).", nameof(GitFailure.AuthenticationFailed))]
[InlineData("fatal: could not read Username", nameof(GitFailure.AuthenticationFailed))]
[InlineData("fatal: could not read Password", nameof(GitFailure.AuthenticationFailed))]
[InlineData("fatal: unexpected failure", nameof(GitFailure.CommandFailed))]
public async Task RunProcess_NonzeroExitLogsDiagnosticsWithoutExposingPrivateDetailsInException(string diagnostic, string expectedFailure)
{
var logger = new FakeLogger<GitCommandRunner>();
var interaction = new TestInteractionService();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), interaction, _consoleEnvironment, logger);
var message = $"{diagnostic}: repository-diagnostic-marker";
var startInfo = CreateShellStartInfo($"printf '%s' '{message}' >&2; exit 128",
$"[Console]::Error.Write('{message}'); exit 128");
var exception = await Assert.ThrowsAsync<GitCommandException>(() =>
runner.RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, TestContext.Current.CancellationToken));
var failure = Enum.Parse<GitFailure>(expectedFailure);
Assert.Equal(failure, exception.Failure);
Assert.Equal(128, exception.ExitCode);
Assert.Equal(failure switch
{
GitFailure.AuthenticationFailed => ErrorStrings.GitAuthenticationFailed,
GitFailure.RepositoryUnavailable => ErrorStrings.GitRepositoryUnavailable,
_ => ErrorStrings.GitCommandFailed
}, exception.Message);
Assert.Null(exception.InnerException);
Assert.Equal((message, (ConsoleOutput?)ConsoleOutput.Error), Assert.Single(interaction.DisplayedRawText));
Assert.Equal(message, GetLoggedOutput(logger, "stderr"));
Assert.Equal(string.Empty, GetLoggedOutput(logger, "stdout"));
}
[Theory]
[InlineData(nameof(GitCommandMode.Captured), nameof(GitFailure.AuthenticationFailed))]
[InlineData(nameof(GitCommandMode.Interactive), nameof(GitFailure.CommandFailed))]
[InlineData(nameof(GitCommandMode.Unattended), nameof(GitFailure.CommandFailed))]
public void CreateCommandException_PreservesPasswordDiagnosticClassification(string mode, string expectedFailure)
{
var exception = GitCommandRunner.CreateCommandException("fatal: could not read Password", 128, Enum.Parse<GitCommandMode>(mode));
Assert.Equal(Enum.Parse<GitFailure>(expectedFailure), exception.Failure);
}
[Fact]
public async Task RunProcess_MissingExecutableReportsSafeStartupFailure()
{
using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
var startInfo = new ProcessStartInfo(Path.Combine(workspace.Path, "missing-private-executable"))
{
RedirectStandardOutput = true,
RedirectStandardError = true
};
var exception = await Assert.ThrowsAsync<GitCommandException>(() =>
CreateRunner().RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, TestContext.Current.CancellationToken));
Assert.Equal(GitFailure.Unavailable, exception.Failure);
Assert.Equal(ErrorStrings.GitUnavailable, exception.Message);
Assert.Null(exception.ExitCode);
Assert.Null(exception.InnerException);
}
[Fact]
public async Task RunProcess_AlreadyCancelledDoesNotStartExecutable()
{
var startInfo = new ProcessStartInfo("missing-executable");
await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
CreateRunner().RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, new CancellationToken(canceled: true)));
}
[Fact]
public async Task RunProcess_PreservesNulDelimitersNewlinesAndPartialLines()
{
var logger = new FakeLogger<GitCommandRunner>();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), new TestInteractionService(), _consoleEnvironment, logger);
var startInfo = CreateShellStartInfo("printf 'first\\r\\nsecond\\000last'", "[Console]::Out.Write(\"first`r`nsecond`0last\")");
var output = await runner.RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, TestContext.Current.CancellationToken);
Assert.Equal("first\r\nsecond\0last", output);
Assert.Equal(output.ReplaceLineEndings(string.Empty), GetLoggedOutput(logger, "stdout").ReplaceLineEndings(string.Empty));
}
[Theory]
[InlineData(0)]
[InlineData(128)]
public async Task RunProcess_LogsBothStreamsWithoutTruncation(int exitCode)
{
var logger = new FakeLogger<GitCommandRunner>();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), new TestInteractionService(), _consoleEnvironment, logger);
var startInfo = CreateShellStartInfo(
$"printf '%71680s' '' | tr ' ' o; printf '\\r\\n\\000last'; printf '%71680s' '' | tr ' ' e >&2; printf '\\r\\nlast' >&2; exit {exitCode}",
$"[Console]::Out.Write(('o' * 71680) + \"`r`n`0last\"); [Console]::Error.Write(('e' * 71680) + \"`r`nlast\"); exit {exitCode}");
var expectedOutput = new string('o', 71680) + "\r\n\0last";
var expectedError = new string('e', 71680) + "\r\nlast";
var run = runner.RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, TestContext.Current.CancellationToken);
if (exitCode == 0)
{
Assert.Equal(expectedOutput, await run);
}
else
{
var exception = await Assert.ThrowsAsync<GitCommandException>(() => run);
Assert.Equal(exitCode, exception.ExitCode);
Assert.Equal(ErrorStrings.GitCommandFailed, exception.Message);
}
Assert.Equal(expectedOutput.ReplaceLineEndings(string.Empty), GetLoggedOutput(logger, "stdout").ReplaceLineEndings(string.Empty));
Assert.Equal(expectedError.ReplaceLineEndings(string.Empty), GetLoggedOutput(logger, "stderr").ReplaceLineEndings(string.Empty));
}
[Fact]
public async Task RunProcess_LogFileDoesNotAddBlankLinesAndPreservesRawOutput()
{
using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
var logPath = Path.Combine(workspace.Path, "git.log");
var startInfo = CreateShellStartInfo(
"printf 'stdout\\n'; printf 'stderr\\n' >&2",
"[Console]::Out.WriteLine('stdout'); [Console]::Error.WriteLine('stderr')");
using (var provider = new FileLoggerProvider(logPath, new TestStartupErrorWriter()))
using (var loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Debug).AddProvider(provider)))
{
var runner = new GitCommandRunner(TestHelpers.CreateInteractiveHostEnvironment(), new TestInteractionService(),
_consoleEnvironment, loggerFactory.CreateLogger<GitCommandRunner>());
var output = await runner.RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, TestContext.Current.CancellationToken);
Assert.Equal("stdout" + Environment.NewLine, output);
}
var logLines = await File.ReadAllLinesAsync(logPath, TestContext.Current.CancellationToken);
Assert.All(logLines, Assert.NotEmpty);
Assert.Single(logLines, line => line.EndsWith("Git stdout: stdout", StringComparison.Ordinal));
Assert.Single(logLines, line => line.EndsWith("Git stderr: stderr", StringComparison.Ordinal));
}
[Theory]
[InlineData("fetch", 0)]
[InlineData("fetch", 128)]
[InlineData("ls-remote", 0)]
[InlineData("ls-remote", 128)]
public async Task RunProcess_InteractiveRemoteForwardsAndLogsBothStreams(string command, int exitCode)
{
using var stdout = new StringWriter();
using var stderr = new StringWriter();
var logger = new FakeLogger<GitCommandRunner>();
var interaction = new TestInteractionService();
var consoleEnvironment = TestHelpers.CreateConsoleEnvironment(stdout, stderr);
var runner = new GitCommandRunner(TestHelpers.CreateInteractiveHostEnvironment(), interaction, consoleEnvironment, logger);
var startInfo = runner.CreateStartInfo(Environment.CurrentDirectory, [command], GitCommandMode.Interactive);
var shell = CreateShellStartInfo(
$"printf 'refs\\000blob'; printf 'Authentication required: ' >&2; exit {exitCode}",
$"[Console]::Out.Write(\"refs`0blob\"); [Console]::Error.Write('Authentication required: '); exit {exitCode}");
startInfo.FileName = shell.FileName;
startInfo.ArgumentList.Clear();
foreach (var argument in shell.ArgumentList)
{
startInfo.ArgumentList.Add(argument);
}
var run = runner.RunProcessAsync(startInfo, captureCancellationOutput: false,
GitCommandMode.Interactive, TestContext.Current.CancellationToken);
if (exitCode == 0)
{
Assert.Equal(command == "fetch" ? string.Empty : "refs\0blob", await run);
}
else
{
var exception = await Assert.ThrowsAsync<GitCommandException>(() => run);
Assert.Equal(GitFailure.AuthenticationFailed, exception.Failure);
Assert.Equal(128, exception.ExitCode);
}
Assert.False(startInfo.RedirectStandardInput);
Assert.Equal(command == "fetch" ? "refs\0blob" : string.Empty, stdout.ToString());
Assert.Equal("Authentication required: ", stderr.ToString());
Assert.Empty(interaction.DisplayedRawText);
Assert.Equal("refs\0blob", GetLoggedOutput(logger, "stdout"));
Assert.Equal("Authentication required: ", GetLoggedOutput(logger, "stderr"));
}
[Fact]
public async Task RunProcess_CancellationKeepsPartialOutputInLogs()
{
var logger = new FakeLogger<GitCommandRunner>();
var interaction = new TestInteractionService();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), interaction, _consoleEnvironment, logger);
var startInfo = CreateShellStartInfo(
"printf 'partial stdout'; printf 'Enter passphrase: ' >&2; sleep 60",
"[Console]::Out.Write('partial stdout'); [Console]::Error.Write('Enter passphrase: '); Start-Sleep -Seconds 60");
using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
var run = runner.RunProcessAsync(startInfo, captureCancellationOutput: true, GitCommandMode.Unattended, cancellation.Token);
try
{
await AsyncTestHelpers.AssertIsTrueRetryAsync(
() => GetLoggedOutput(logger, "stdout") == "partial stdout" && GetLoggedOutput(logger, "stderr") == "Enter passphrase: ",
"Git output should be logged before the process exits.");
Assert.False(run.IsCompleted);
}
finally
{
cancellation.Cancel();
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => run.DefaultTimeout());
}
Assert.Equal("partial stdout", GetLoggedOutput(logger, "stdout"));
Assert.Equal("Enter passphrase: ", GetLoggedOutput(logger, "stderr"));
Assert.Empty(interaction.DisplayedRawText);
}
[Fact]
public async Task RunProcess_CapturedSuccessDisplaysStderrWithoutDisplayingParsedStdout()
{
var interaction = new TestInteractionService();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), interaction, _consoleEnvironment,
_loggerFactory.CreateLogger<GitCommandRunner>());
var startInfo = CreateShellStartInfo("printf 'refs\\000blob'; printf 'Git warning' >&2",
"[Console]::Out.Write(\"refs`0blob\"); [Console]::Error.Write('Git warning')");
var output = await runner.RunProcessAsync(startInfo, captureCancellationOutput: false,
GitCommandMode.Captured, TestContext.Current.CancellationToken);
Assert.Equal("refs\0blob", output);
Assert.Equal(("Git warning", (ConsoleOutput?)ConsoleOutput.Error), Assert.Single(interaction.DisplayedRawText));
}
[Theory]
[InlineData(nameof(GitCommandMode.Captured), 0)]
[InlineData(nameof(GitCommandMode.Captured), 128)]
[InlineData(nameof(GitCommandMode.Interactive), 0)]
[InlineData(nameof(GitCommandMode.Interactive), 128)]
[InlineData(nameof(GitCommandMode.Unattended), 0)]
[InlineData(nameof(GitCommandMode.Unattended), 128)]
public async Task StandardErrorHandler_IsOperationLocalAndPreservesParsedStdout(string mode, int exitCode)
{
var interaction = new TestInteractionService();
var logger = new FakeLogger<GitCommandRunner>();
var runner = new GitCommandRunner(TestHelpers.CreateNonInteractiveHostEnvironment(), interaction, _consoleEnvironment, logger);
var diagnostics = new List<string>();
var capturedRunner = Assert.IsType<GitCommandRunner>(runner.WithStandardErrorHandler(diagnostics.Add));
async Task RunAsync(GitCommandRunner commands)
{
var startInfo = CreateShellStartInfo(
$"printf 'refs\\000blob'; printf 'Git diagnostic' >&2; exit {exitCode}",
$"[Console]::Out.Write(\"refs`0blob\"); [Console]::Error.Write('Git diagnostic'); exit {exitCode}");
var operation = commands.RunProcessAsync(startInfo, captureCancellationOutput: false,
Enum.Parse<GitCommandMode>(mode), TestContext.Current.CancellationToken);
if (exitCode == 0)
{
Assert.Equal("refs\0blob", await operation);
}
else
{
var exception = await Assert.ThrowsAsync<GitCommandException>(() => operation);
Assert.Equal(GitFailure.CommandFailed, exception.Failure);
Assert.Equal(exitCode, exception.ExitCode);
Assert.Equal(ErrorStrings.GitCommandFailed, exception.Message);
}
}
await Task.WhenAll(RunAsync(capturedRunner), RunAsync(runner));
Assert.Equal(["Git diagnostic"], diagnostics);
Assert.Equal(("Git diagnostic", (ConsoleOutput?)ConsoleOutput.Error), Assert.Single(interaction.DisplayedRawText));
Assert.Equal("Git diagnosticGit diagnostic", GetLoggedOutput(logger, "stderr"));
}
[Fact]
public async Task RunProcess_CapturedCommandsReceiveStandardInputEof()
{
using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
var runner = CreateRunner();
var startInfo = runner.CreateStartInfo(workspace.Path, ["fetch"], GitCommandMode.Captured);
var shell = CreateShellStartInfo(
"""input=$(cat); if [ -n "$input" ]; then exit 1; fi; printf EOF""",
"""$inputText = [Console]::In.ReadToEnd(); if ($inputText.Length -ne 0) { exit 1 }; [Console]::Out.Write('EOF')""");
startInfo.FileName = shell.FileName;
startInfo.ArgumentList.Clear();
foreach (var argument in shell.ArgumentList)
{
startInfo.ArgumentList.Add(argument);
}
using var timeoutSource = AsyncTestHelpers.CreateDefaultTimeoutTokenSource(milliseconds: 10_000);
using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken, timeoutSource.Token);
var output = await runner.RunProcessAsync(startInfo, captureCancellationOutput: false, GitCommandMode.Captured, cancellation.Token);
Assert.True(startInfo.RedirectStandardInput);
Assert.Equal("EOF", output);
}
private static string GetLoggedOutput(FakeLogger<GitCommandRunner> logger, string stream)
{
var prefix = $"Git {stream}: ";
return string.Concat(logger.Collector.GetSnapshot()
.Where(entry => entry.Message.StartsWith(prefix, StringComparison.Ordinal))
.Select(entry => entry.Message[prefix.Length..]));
}
private static ProcessStartInfo CreateShellStartInfo(string unixCommand, string windowsCommand)
{
var startInfo = new ProcessStartInfo(OperatingSystem.IsWindows() ? "powershell.exe" : "/bin/sh")
{
RedirectStandardOutput = true,
RedirectStandardError = true,
StandardOutputEncoding = Encoding.UTF8,
StandardErrorEncoding = Encoding.UTF8,
CreateNoWindow = true
};
if (OperatingSystem.IsWindows())
{
startInfo.ArgumentList.Add("-NoProfile");
startInfo.ArgumentList.Add("-NonInteractive");
startInfo.ArgumentList.Add("-Command");
startInfo.ArgumentList.Add(windowsCommand);
}
else
{
startInfo.ArgumentList.Add("-c");
startInfo.ArgumentList.Add(unixCommand);
}
return startInfo;
}
}