File: Commands\NewCommandLocalTemplateTests.SourceList.cs
Web Access
Project: src\tests\Aspire.Cli.Tests\Aspire.Cli.Tests.csproj (Aspire.Cli.Tests)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Globalization;
using System.Text.Json.Nodes;
using Aspire.Cli.Configuration;
using Aspire.Cli.Git;
using Aspire.Cli.Interaction;
using Aspire.Cli.Resources;
using Aspire.Cli.Tests.TestServices;
using Aspire.Cli.Tests.Utils;
using Aspire.Shared.Telemetry;
using Microsoft.AspNetCore.InternalTesting;
using Microsoft.Extensions.DependencyInjection;
using Spectre.Console;
using RootCommand = Aspire.Cli.Commands.RootCommand;
 
namespace Aspire.Cli.Tests.Commands;
 
public partial class NewCommandLocalTemplateTests
{
    private const string SourceListSettings = """
        {
          // Management listing preserves the configured fields, including unfinished sources.
          "unrelated": "not listed",
          "templateSources": {
            "z-git": { "repository": "https://example.test/templates", "path": "templates/api", "ref": "release/17.0" },
            "Local [red]": { "path": "/templates/with [brackets]" },
            "empty": {},
            "git-head": { "repository": "https://example.test/head" },
            "unfinished": { "ref": "main" }
          }
        }
        """;
 
    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public async Task TemplateSourceList_DisplaysGlobalConfigurationWithoutDiscovery(bool json)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        var git = new TestGitCommandRunner();
        var services = CreateServices(workspace, interaction, interactive: true);
        services.AddSingleton<IGitCommandRunner>(git);
        using var provider = services.BuildServiceProvider();
        var settings = provider.GetRequiredService<IConfigurationService>();
        await File.WriteAllTextAsync(settings.GetSettingsFilePath(true), SourceListSettings);
        var localPath = settings.GetSettingsFilePath(false);
        Directory.CreateDirectory(Path.GetDirectoryName(localPath)!);
        const string localSettings = """{"templateSources":{"project-only":{"repository":"https://example.test/project"}}}""";
        await File.WriteAllTextAsync(localPath, localSettings);
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse(json ? "template source list --format json" : "template source list").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.Success, result);
        Assert.Empty(GetGitResolutions(git));
        Assert.Empty(GetGitFetches(git));
        Assert.Empty(interaction.ShownStatuses);
        Assert.Empty(interaction.DisplayedErrors);
        Assert.Empty(interaction.DisplayedMessages);
        Assert.Empty(interaction.DisplayedSuccess);
        Assert.Equal(SourceListSettings, await File.ReadAllTextAsync(settings.GetSettingsFilePath(true)));
        Assert.Equal(localSettings, await File.ReadAllTextAsync(localPath));
        if (json)
        {
            var output = Assert.Single(interaction.DisplayedRawText);
            Assert.Equal(ConsoleOutput.Standard, output.ConsoleOverride);
            Assert.Equal(ConsoleOutput.Error, interaction.Console);
            Assert.Empty(interaction.DisplayedRenderables);
            await Verify(output.Text, "json").UseParameters(json);
        }
        else
        {
            Assert.Empty(interaction.DisplayedRawText);
            using var writer = new StringWriter(CultureInfo.InvariantCulture);
            var console = AnsiConsole.Create(new AnsiConsoleSettings { Out = new AnsiConsoleOutput(writer), Ansi = AnsiSupport.No });
            console.Profile.Capabilities.Ansi = false;
            console.Profile.Width = 160;
            console.Write(Assert.Single(interaction.DisplayedRenderables));
            await Verify(writer.ToString()).UseParameters(json);
        }
    }
 
    [Theory]
    [InlineData(null)]
    [InlineData("{}")]
    [InlineData("""{"templateSources":{}}""")]
    [InlineData("""{"unrelated":true}""")]
    public async Task TemplateSourceList_EmptyJsonIsAnObjectWithoutCreatingOrChangingConfiguration(string? original)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        using var provider = CreateServices(workspace, interaction, interactive: false).BuildServiceProvider();
        var path = provider.GetRequiredService<IConfigurationService>().GetSettingsFilePath(true);
        if (original is not null)
        {
            await File.WriteAllTextAsync(path, original);
        }
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse("template source list --format json").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.Success, result);
        Assert.Equal(("{}", (ConsoleOutput?)ConsoleOutput.Standard), Assert.Single(interaction.DisplayedRawText));
        Assert.Empty(interaction.DisplayedMessages);
        Assert.Empty(interaction.DisplayedRenderables);
        Assert.Empty(interaction.DisplayedErrors);
        Assert.Equal(original, File.Exists(path) ? await File.ReadAllTextAsync(path) : null);
    }
 
    [Theory]
    [InlineData("")]
    [InlineData(" --format table")]
    public async Task TemplateSourceList_EmptyHumanReadableOutputHasGuidance(string options)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        using var provider = CreateServices(workspace, interaction, interactive: false).BuildServiceProvider();
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse($"template source list{options}").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.Success, result);
        Assert.Equal(NewCommandStrings.TemplateSourceListEmpty, Assert.Single(interaction.DisplayedMessages).Message);
        Assert.Empty(interaction.DisplayedRawText);
        Assert.Empty(interaction.DisplayedRenderables);
    }
 
    [Theory]
    [InlineData("{")]
    [InlineData("[]")]
    [InlineData("""{"templateSources":null}""")]
    [InlineData("""{"templateSources":42}""")]
    public async Task TemplateSourceList_JsonReadFailureDoesNotReturnEmptySuccess(string original)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        using var provider = CreateServices(workspace, interaction, interactive: false).BuildServiceProvider();
        var path = provider.GetRequiredService<IConfigurationService>().GetSettingsFilePath(true);
        await File.WriteAllTextAsync(path, original);
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse("template source list --format json").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.InvalidCommand, result);
        Assert.Single(interaction.DisplayedErrors);
        Assert.Equal(ConsoleOutput.Error, interaction.Console);
        Assert.Empty(interaction.DisplayedRawText);
        Assert.Equal(original, await File.ReadAllTextAsync(path));
    }
 
    [Fact]
    public async Task TemplateSourceList_UnreadableConfigurationFailsWithoutJson()
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        using var provider = CreateServices(workspace, interaction, interactive: false).BuildServiceProvider();
        Directory.CreateDirectory(provider.GetRequiredService<IConfigurationService>().GetSettingsFilePath(true));
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse("template source list --format json").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.InvalidCommand, result);
        Assert.Equal(NewCommandStrings.TemplateSourceReadFailed, Assert.Single(interaction.DisplayedErrors));
        Assert.Equal(ConsoleOutput.Error, interaction.Console);
        Assert.Empty(interaction.DisplayedRawText);
    }
 
    [Fact]
    public async Task TemplateSourceList_InvalidFormatIsRejected()
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        using var provider = CreateServices(workspace, interaction, interactive: false).BuildServiceProvider();
        var parseResult = provider.GetRequiredService<RootCommand>().Parse("template source list --format yaml");
 
        Assert.NotEmpty(parseResult.Errors);
        Assert.NotEqual(CliExitCodes.Success, await parseResult.InvokeAsync().DefaultTimeout());
        Assert.Empty(interaction.DisplayedRawText);
    }
 
    [Theory]
    [InlineData(false, true, null, true)]
    [InlineData(false, true, null, false)]
    [InlineData(false, true, true, false)]
    [InlineData(false, true, false, true)]
    [InlineData(false, false, null, true)]
    [InlineData(false, false, true, false)]
    [InlineData(false, false, false, true)]
    [InlineData(true, true, null, true)]
    [InlineData(true, true, true, false)]
    [InlineData(true, true, false, true)]
    [InlineData(true, false, null, true)]
    [InlineData(true, false, true, false)]
    [InlineData(true, false, false, true)]
    public async Task TemplateSourceList_ConsentControlsInitConfiguration(bool json, bool interactive, bool? useSource, bool accept)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var prompts = 0;
        var interaction = new TestInteractionService
        {
            ConfirmCallback = (prompt, defaultValue) =>
            {
                prompts++;
                Assert.Equal(ConfigSourceStrings.TemplateSourceListUseSourcePrompt, prompt);
                Assert.True(defaultValue);
                return accept;
            }
        };
        var git = new TestConfigSourceRepository
        {
            ReadConfiguration = (source, _) =>
            {
                Assert.Equal("https://git.example/configuration", source.Repository);
                Assert.Equal("config-preview", source.Ref);
                return Task.FromResult(("version-1", JsonNode.Parse("""
                    {
                      "features": { "must-not-be-materialized": true },
                      "templateSources": {
                        "enterprise": { "repository": "https://git.example/templates", "ref": "template-preview", "path": "templates" },
                        "personal": { "repository": "https://git.example/overridden", "ref": "must-not-leak" }
                      }
                    }
                    """)!.AsObject()));
            }
        };
        using var provider = CreateInheritedTemplateServices(workspace, interaction, git, interactive).BuildServiceProvider();
        var settings = provider.GetRequiredService<IConfigurationService>();
        var globalPath = settings.GetSettingsFilePath(true);
        const string globalSettings = """{"unrelated":true,"templateSources":{"Personal":{"path":"./personal"}}}""";
        await File.WriteAllTextAsync(globalPath, globalSettings);
        var localPath = settings.GetSettingsFilePath(false);
        Directory.CreateDirectory(Path.GetDirectoryName(localPath)!);
        const string localSettings = """{"templateSources":{"project-only":{"repository":"https://git.example/project"}}}""";
        await File.WriteAllTextAsync(localPath, localSettings);
        var options = json ? " --format json" : "";
        if (useSource is not null)
        {
            options += useSource.Value ? " --use-config-source" : " --use-config-source false";
        }
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse($"template source list{options}").InvokeAsync().DefaultTimeout();
 
        var shouldPrompt = !json && interactive && useSource is null;
        var consentRequired = !json && !interactive && useSource is null;
        var includeInherited = useSource is true || (shouldPrompt && accept);
        Assert.Equal(shouldPrompt ? 1 : 0, prompts);
        Assert.Equal(includeInherited ? 1 : 0, git.Calls);
        Assert.Equal(includeInherited ? [json ? GitCommandMode.Unattended : GitCommandMode.Interactive] : [], git.FetchModes);
        Assert.Equal(git.FetchModes, git.ResolutionModes);
        Assert.Empty(interaction.StringPromptCalls);
        Assert.Equal(prompts, interaction.BooleanPromptCalls.Count);
        Assert.Equal(globalSettings, await File.ReadAllTextAsync(globalPath));
        Assert.Equal(localSettings, await File.ReadAllTextAsync(localPath));
        Assert.Equal(consentRequired ? CliExitCodes.InvalidCommand : CliExitCodes.Success, result);
        if (consentRequired)
        {
            Assert.Equal(ConfigSourceStrings.ConsentRequired, Assert.Single(interaction.DisplayedErrors));
            Assert.Empty(interaction.DisplayedRawText);
            Assert.IsType<Padder>(Assert.Single(interaction.DisplayedRenderables));
            return;
        }
 
        Assert.Empty(interaction.DisplayedErrors);
        if (json)
        {
            var raw = Assert.Single(interaction.DisplayedRawText);
            Assert.Equal(ConsoleOutput.Standard, raw.ConsoleOverride);
            Assert.Equal(ConsoleOutput.Error, interaction.Console);
            Assert.Equal(useSource is true ? 1 : 0, interaction.DisplayedRenderables.Count);
            await Verify(raw.Text, "json").UseParameters(json, interactive, useSource, accept);
        }
        else
        {
            Assert.Empty(interaction.DisplayedRawText);
            using var writer = new StringWriter(CultureInfo.InvariantCulture);
            var console = AnsiConsole.Create(new AnsiConsoleSettings { Out = new AnsiConsoleOutput(writer), Ansi = AnsiSupport.No });
            console.Profile.Capabilities.Ansi = false;
            console.Profile.Width = 160;
            Assert.Collection(interaction.DisplayedRenderables,
                details => Assert.IsType<Padder>(details),
                sources => Assert.IsType<Table>(sources));
            console.Write(interaction.DisplayedRenderables[^1]);
            await Verify(writer.ToString()).UseParameters(json, interactive, useSource, accept);
        }
    }
 
    [Theory]
    [InlineData(null)]
    [InlineData(false)]
    public async Task TemplateSourceList_JsonWithoutOptInDoesNotResolveInvalidSource(bool? useSource)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService
        {
            ConfirmCallback = (_, _) => throw new InvalidOperationException("JSON must not prompt.")
        };
        var git = new TestConfigSourceRepository
        {
            ReadConfiguration = (_, _) => throw new InvalidOperationException("JSON without opt-in must not acquire configuration.")
        };
        var services = CreateInheritedTemplateServices(workspace, interaction, git, interactive: true);
        services.AddSingleton<IEnvironment>(new TestEnvironment(new Dictionary<string, string?>
        {
            [CliConfigNames.InitSourceUrl] = "--invalid",
            [CliConfigNames.InitSourceRef] = "--invalid"
        }));
        using var provider = services.BuildServiceProvider();
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse($"template source list --format json{(useSource is false ? " --use-config-source false" : "")}")
            .InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.Success, result);
        Assert.Empty(git.FetchModes);
        Assert.Empty(git.ResolutionModes);
        Assert.Empty(interaction.DisplayedErrors);
        Assert.Empty(interaction.DisplayedMessages);
        Assert.Equal(("{}", (ConsoleOutput?)ConsoleOutput.Standard), Assert.Single(interaction.DisplayedRawText));
    }
 
    [Theory]
    [InlineData(false, null)]
    [InlineData(false, false)]
    [InlineData(false, true)]
    [InlineData(true, null)]
    [InlineData(true, false)]
    [InlineData(true, true)]
    public async Task TemplateSourceList_WithoutCandidateDoesNotPromptOrFetch(bool json, bool? useSource)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService
        {
            ConfirmCallback = (_, _) => throw new InvalidOperationException("No candidate must not prompt.")
        };
        var git = new TestConfigSourceRepository();
        var detector = new TestConfigSourceDetector();
        var services = CreateServices(workspace, interaction, interactive: true);
        services.AddSingleton<IGitClient>(git);
        services.AddSingleton<IEnvironment>(new TestEnvironment());
        services.AddSingleton<IInternalMicrosoftDetector>(detector);
        using var provider = services.BuildServiceProvider();
        var options = json ? " --format json" : "";
        if (useSource is not null)
        {
            options += useSource.Value ? " --use-config-source" : " --use-config-source false";
        }
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse($"template source list{options}").InvokeAsync().DefaultTimeout();
 
        Assert.Empty(git.FetchModes);
        Assert.Empty(git.ResolutionModes);
        Assert.Equal(!json || useSource is true ? 1 : 0, detector.Calls);
        Assert.Equal(useSource is true ? CliExitCodes.InvalidCommand : CliExitCodes.Success, result);
        if (useSource is true)
        {
            Assert.Equal(string.Format(CultureInfo.CurrentCulture, ConfigSourceStrings.NoCandidate, CliConfigNames.InitSourceUrl),
                Assert.Single(interaction.DisplayedErrors));
            Assert.Empty(interaction.DisplayedRawText);
        }
        else if (json)
        {
            Assert.Empty(interaction.DisplayedErrors);
            Assert.Equal(("{}", (ConsoleOutput?)ConsoleOutput.Standard), Assert.Single(interaction.DisplayedRawText));
        }
        else
        {
            Assert.Empty(interaction.DisplayedErrors);
            Assert.Equal(NewCommandStrings.TemplateSourceListEmpty, Assert.Single(interaction.DisplayedMessages).Message);
        }
    }
 
    [Theory]
    [InlineData(false, null)]
    [InlineData(false, false)]
    [InlineData(false, true)]
    [InlineData(true, null)]
    [InlineData(true, false)]
    [InlineData(true, true)]
    public async Task TemplateSourceList_DetectedCandidateRequiresConsentLikeNew(bool json, bool? useSource)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var prompts = 0;
        var interaction = new TestInteractionService
        {
            ConfirmCallback = (_, _) =>
            {
                prompts++;
                return true;
            }
        };
        var git = new TestConfigSourceRepository
        {
            ReadConfigurationWhenUnattended = true,
            ReadConfiguration = (source, _) =>
            {
                Assert.Equal(ConfigSourceService.MicrosoftRepository, source.Repository);
                Assert.Equal(AspireConfigFile.FileName, source.Path);
                Assert.Null(source.Ref);
                return Task.FromResult(("version-1", new JsonObject()));
            }
        };
        var detector = new TestConfigSourceDetector { IsInternal = true };
        var services = CreateServices(workspace, interaction, interactive: true);
        services.AddSingleton<IGitClient>(git);
        services.AddSingleton<IEnvironment>(new TestEnvironment());
        services.AddSingleton<IInternalMicrosoftDetector>(detector);
        using var provider = services.BuildServiceProvider();
        var options = json ? " --format json" : "";
        if (useSource is not null)
        {
            options += useSource.Value ? " --use-config-source" : " --use-config-source false";
        }
 
        var result = await provider.GetRequiredService<RootCommand>()
            .Parse($"template source list{options}").InvokeAsync().DefaultTimeout();
 
        Assert.Equal(CliExitCodes.Success, result);
        Assert.Equal(!json && useSource is null ? 1 : 0, prompts);
        Assert.Equal(!json || useSource is true ? 1 : 0, detector.Calls);
        Assert.Equal(useSource is true || (!json && useSource is null) ? 1 : 0, git.Calls);
        Assert.Empty(interaction.DisplayedErrors);
        Assert.Empty(interaction.StringPromptCalls);
        Assert.Equal(prompts, interaction.BooleanPromptCalls.Count);
        if (json)
        {
            Assert.Equal(("{}", (ConsoleOutput?)ConsoleOutput.Standard), Assert.Single(interaction.DisplayedRawText));
        }
        Assert.False(File.Exists(provider.GetRequiredService<IConfigurationService>().GetSettingsFilePath(true)));
        Assert.False(File.Exists(Path.Combine(workspace.Path, AspireConfigFile.FileName)));
    }
 
    [Theory]
    [InlineData("new")]
    [InlineData("init")]
    [InlineData("template source list")]
    public void TemplateSourceList_ConfigSourceOptionPreservesNullableConsentAndAcceptsBareFlag(string command)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        var git = new TestConfigSourceRepository();
        using var provider = CreateInheritedTemplateServices(workspace, interaction, git, interactive: true).BuildServiceProvider();
        var root = provider.GetRequiredService<RootCommand>();
        var omitted = root.Parse(command);
        Assert.Empty(omitted.Errors);
        Assert.Null(omitted.GetValue(ConfigSourceService.s_useSourceOption));
        foreach (var value in new[] { true, false })
        {
            var explicitValue = root.Parse($"{command} --use-config-source {value.ToString().ToLowerInvariant()}");
            Assert.Empty(explicitValue.Errors);
            Assert.Equal(value, explicitValue.GetValue(ConfigSourceService.s_useSourceOption));
        }
        var bareFlag = root.Parse($"{command} --use-config-source");
 
        Assert.Empty(bareFlag.Errors);
        Assert.True(bareFlag.GetValue(ConfigSourceService.s_useSourceOption));
        Assert.Empty(git.FetchModes);
        Assert.Empty(git.ResolutionModes);
        Assert.Empty(interaction.DisplayedRawText);
    }
 
    [Theory]
    [InlineData("new", "--name Demo")]
    [InlineData("init", "--language csharp")]
    [InlineData("template source list", "--format json")]
    public void TemplateSourceList_ConfigSourceOptionDoesNotConsumeFollowingOptions(string command, string followingOption)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        using var provider = CreateServices(workspace, new TestInteractionService(), interactive: true).BuildServiceProvider();
        var root = provider.GetRequiredService<RootCommand>();
        foreach (var (option, expected) in new (string, bool)[]
        {
            ("--use-config-source", true),
            ("--use-config-source true", true),
            ("--use-config-source false", false),
            ("--use-config-source=true", true),
            ("--use-config-source=false", false)
        })
        {
            var parsed = root.Parse($"{command} {option} {followingOption} --non-interactive");
            Assert.Empty(parsed.Errors);
            Assert.Equal(expected, parsed.GetValue(ConfigSourceService.s_useSourceOption));
            Assert.True(parsed.GetValue(RootCommand.NonInteractiveOption));
        }
    }
 
    [Theory]
    [InlineData("new")]
    [InlineData("init")]
    [InlineData("template source list")]
    public async Task TemplateSourceList_ConfigSourceOptionRejectsInvalidValuesBeforeAcquisition(string command)
    {
        using var workspace = TemporaryWorkspace.CreateForCli(outputHelper);
        var interaction = new TestInteractionService();
        var git = new TestConfigSourceRepository();
        using var provider = CreateInheritedTemplateServices(workspace, interaction, git, interactive: true).BuildServiceProvider();
        var root = provider.GetRequiredService<RootCommand>();
        foreach (var value in new[] { "invalid", "0", "true false" })
        {
            var parsed = root.Parse($"{command} --use-config-source {value} --non-interactive");
            Assert.NotEmpty(parsed.Errors);
            Assert.NotEqual(CliExitCodes.Success, await parsed.InvokeAsync().DefaultTimeout());
        }
        Assert.Empty(git.FetchModes);
        Assert.Empty(git.ResolutionModes);
        Assert.Empty(interaction.StringPromptCalls);
        Assert.Empty(interaction.BooleanPromptCalls);
        Assert.Empty(interaction.DisplayedRawText);
    }
}