Skip to content

Add unit tests for reserved aliases and host specific template data #28748

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
merged 1 commit into from
Oct 27, 2022
Merged

Add unit tests for reserved aliases and host specific template data #28748

Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
274 changes: 274 additions & 0 deletions src/Tests/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,14 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//

using System.CommandLine;
using FakeItEasy;
using Microsoft.TemplateEngine.Abstractions;
using Microsoft.TemplateEngine.Cli.Commands;
using Microsoft.TemplateEngine.Edge;
using Microsoft.TemplateEngine.Edge.Settings;
using Microsoft.TemplateEngine.Mocks;
using Newtonsoft.Json.Linq;

namespace Microsoft.TemplateEngine.Cli.UnitTests
{
Expand Down Expand Up @@ -200,5 +207,272 @@ public void CheckAliasAssignmentsMvc20()
Assert.Contains("--no-restore", result["skipRestore"].Aliases);
Assert.DoesNotContain(result, r => r.Value.Errors.Any());
}

[Theory]
[InlineData("package", "--param:package")]
[InlineData("u", "-p:u")]
[InlineData("notreserved", "--notreserved")]
public void CanAssignAliasForParameterWithReservedAlias(string parameterName, string expectedContainedAlias)
{
string command = "foo";
MockTemplateInfo[] templates = new MockTemplateInfo[]
{
new MockTemplateInfo($"{command}", identity: "foo.1", groupIdentity: "foo.group").WithParameters(parameterName)
};
ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();

NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
ParseResult parseResult = myCommand.Parse($" new {command}");
var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
TemplateGroup templateGroup = TemplateGroup
.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templates, A.Fake<IHostSpecificDataLoader>()))
.Single();
var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
Assert.Single(templateCommands);
var templateOption = templateCommands.Single().TemplateOptions[parameterName];
Assert.Contains(expectedContainedAlias, templateOption.Aliases);
}

[Theory]
#pragma warning disable CA1825 // Avoid zero-length array allocations. https://github.com/dotnet/sdk/issues/28672
[MemberData(nameof(GetTemplateData))]
#pragma warning restore CA1825 // Avoid zero-length array allocations.
public void CanOverrideAliasesForParameterWithHostData(string hostJsonData, string expectedJsonResult)
{
var hostData = new HostSpecificTemplateData(string.IsNullOrEmpty(hostJsonData) ? null : JObject.Parse(hostJsonData));
var expectedResults = JObject.Parse(expectedJsonResult);
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group");
foreach (var expectedResult in expectedResults)
{
template.WithParameter(expectedResult.Key);
}
var hostDataLoader = A.Fake<IHostSpecificDataLoader>();
A.CallTo(() => hostDataLoader.ReadHostSpecificTemplateData(template)).Returns(hostData);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, hostDataLoader))
.Single();
ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
ParseResult parseResult = myCommand.Parse(" new foo");
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, templatePackageManager, templateGroup);
Assert.Single(templateCommands);
foreach (var expectedResult in expectedResults)
{
var expectedValues = expectedResult.Value!.Select(s => ((JValue)s).Value).ToArray();
var expectedLongAlias = expectedValues[0];
var expectedShortAlias = expectedValues[1];
var expectedIsHidden = expectedValues[2];
var templateOptions = templateCommands.Single().TemplateOptions;
Assert.NotNull(templateOptions);
Assert.Contains(expectedResult.Key, templateOptions.Keys);
var templateOption = templateOptions[expectedResult.Key];
Assert.NotNull(templateOption);
Assert.True(templateOption.Aliases.Count > 0);
var longAlias = templateOption.Aliases.ElementAt(0);
var shortAlias = templateOption.Aliases.Count > 1 ? templateOption.Aliases.ElementAt(1) : null;
var isHidden = templateOption.Option.IsHidden;
Assert.Equal(expectedLongAlias, longAlias);
Assert.Equal(expectedShortAlias, shortAlias);
Assert.Equal(expectedIsHidden, isHidden);
}
}

public static IEnumerable<object[]> GetTemplateData()
{
// host data and expected option with long alias, short alias and if it is hidden:
// [0] host data
// [1] expected option : 0 - long alias, 1 - short alias, 2 - isHidden
yield return new object[]
{
string.Empty,
@"{ ""Framework"": [""--Framework"", ""-F"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
}
}
}",
@"{ ""Framework"": [""--Framework"", ""-F"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""longName"": ""targetframework""
}
}
}",
@"{ ""Framework"": [""--targetframework"", ""-t"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""shortName"": ""fr""
}
}
}",
@"{ ""Framework"": [""--Framework"", ""-fr"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""longName"": ""targetframework"",
""shortName"": ""fr""
}
}
}",
@"{ ""Framework"": [""--targetframework"", ""-fr"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""longName"": ""targetframework"",
""shortName"": """"
}
}
}",
@"{ ""Framework"": [""--targetframework"", null, false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""isHidden"": ""true"",
""longName"": ""targetframework"",
""shortName"": ""fr""
}
}
}",
@"{ ""Framework"": [""--targetframework"", ""-fr"", true] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""Framework"": {
""isHidden"": ""false"",
""longName"": ""targetframework"",
""shortName"": ""fr""
}
}
}",
@"{ ""Framework"": [""--targetframework"", ""-fr"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""install"": {
""longName"": ""set""
}
}
}",
@"{ ""install"": [""--set"", ""-s"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""install"": {
""longName"": ""setup"",
""shortName"": ""set""
}
}
}",
@"{ ""install"": [""--setup"", ""-set"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""install"": {
""longName"": ""set"",
""shortName"": """"
}
}
}",
@"{ ""install"": [""--set"", null, false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""pack"": {
""longName"": ""package""
}
}
}",
@"{ ""pack"": [""--param:package"", ""-p"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""add"": {
""shortName"": ""i""
}
}
}",
@"{ ""add"": [""--add"", ""-p:i"", false] }"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""delete"": {
""longName"": ""remove""
}
}
}",
@"{
""delete"": [""--remove"", ""-r"", false],
""remove"": [""--param:remove"", ""-re"", false]
}"
};

yield return new object[]
{
@"{
""symbolInfo"": {
""delete"": {
""longName"": ""remove""
}
}
}",
@"{
""remove"": [""--param:remove"", ""-r"", false],
""delete"": [""--remove"", ""-re"", false]
}"
};
}
}
}