internal void GetHighestPrecedenceInvokableTemplatesTest(MockNewCommandInput command, MockTemplateInfo[] templates, string defaultLanguage, string[] expectedTemplates)
{
TemplateResolutionResult matchedTemplates = TemplateResolver.GetTemplateResolutionResult(templates, new MockHostSpecificDataLoader(), command, defaultLanguage);
TemplateGroup templateGroup = matchedTemplates.UnambiguousTemplateGroup;
bool useDefaultLanguage = string.IsNullOrWhiteSpace(command.Language) && !string.IsNullOrWhiteSpace(defaultLanguage);
IEnumerable <ITemplateMatchInfo> selectedTemplates = templateGroup.GetHighestPrecedenceInvokableTemplates(useDefaultLanguage);
var identitiesToCheck = selectedTemplates.Select(t => t.Info.Identity);
Assert.Equal(expectedTemplates.Length, selectedTemplates.Count());
foreach (string exp in expectedTemplates)
{
Assert.Single(selectedTemplates.Where(t => t.Info.Identity == exp));
}
bool success = templateGroup.TryGetHighestPrecedenceInvokableTemplate(out ITemplateMatchInfo selectedTemplate, useDefaultLanguage);
if (expectedTemplates.Length == 1)
{
Assert.Equal(expectedTemplates[0], selectedTemplate.Info.Identity);
Assert.True(success);
}
else
{
Assert.Null(selectedTemplate);
Assert.False(success);
}
}
public void GetAllMatchedParametersList_PreservesValueIfGiven()
{
var templateMatchInfo = A.Fake <ITemplateMatchInfo>();
A.CallTo(() => templateMatchInfo.MatchDisposition).Returns(
new[]
{
new ParameterMatchInfo("param", "paramValue", MatchKind.Mismatch, ParameterMatchInfo.MismatchKind.InvalidValue, "--param")
});
var templateMatchInfo2 = A.Fake <ITemplateMatchInfo>();
A.CallTo(() => templateMatchInfo2.MatchDisposition).Returns(
new[]
{
new ParameterMatchInfo("param", null, MatchKind.Mismatch, ParameterMatchInfo.MismatchKind.InvalidValue, "--param")
});
var parameters = TemplateResolutionResult.GetAllMatchedParametersList(new[] { templateMatchInfo, templateMatchInfo2 });
Assert.Equal(1, parameters.Count);
Assert.Equal("paramValue", parameters["--param"]);
parameters = TemplateResolutionResult.GetAllMatchedParametersList(new[] { templateMatchInfo2, templateMatchInfo });
Assert.Equal(1, parameters.Count);
Assert.Equal("paramValue", parameters["--param"]);
}
private void EnsureTemplateResolutionResult()
{
if (_resolutionResultInitialized)
{
return;
}
_templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
_singleMatchStatus = Status.NotEvaluated;
// If any template in the group has any ambiguous params, it's not invokable.
// The check for HasAmbiguousParameterValueMatch is for an example like:
// "dotnet new mvc -f netcore"
// - '-f netcore' is ambiguous in the 1.x version (2 begins-with matches)
// - '-f netcore' is not ambiguous in the 2.x version (1 begins-with match)
if (!_templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroup) ||
!_templateResolutionResult.TryGetSingularInvokableMatch(out _templateToInvoke, out _singleMatchStatus) ||
unambiguousTemplateGroup.Any(x => x.HasParameterMismatch()) ||
unambiguousTemplateGroup.Any(x => x.HasAmbiguousParameterValueMatch()))
{
_templateToInvoke = null;
if (_singleMatchStatus == Status.AmbiguousChoice)
{
_environment.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousChoiceParameterValue, "Authoring");
}
else if (_singleMatchStatus == Status.AmbiguousPrecedence)
{
_environment.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousBestPrecedence, "Authoring");
}
}
_resolutionResultInitialized = true;
}
public async Task TestGetTemplateResolutionResult_MatchByTagsAndMismatchByOtherFilter()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithClassifications("Common", "Test")
.WithBaselineInfo("app", "standard"));
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor("new list --language L2 --type item --tag Common"),
defaultLanguage : null,
default).ConfigureAwait(false);
Assert.False(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.Equal(0, matchResult.TemplateGroupsWithMatchingTemplateInfo.Count());
Assert.True(matchResult.HasTemplateGroupMatches);
Assert.Equal(1, matchResult.TemplateGroups.Count());
Assert.Equal(1, matchResult.TemplateGroups.Single().Templates.Count);
Assert.True(matchResult.HasLanguageMismatch);
Assert.True(matchResult.HasTypeMismatch);
Assert.False(matchResult.HasBaselineMismatch);
}
public void MultipleTemplatesInGroupHavingSingularStartMatchesOnDifferentParams_HighPrecedenceIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("MyChoice", "value_1", "other_value")
.WithTag("OtherChoice", "foo_"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_2", groupIdentity: "foo.test.template", precedence: 200)
.WithTag("MyChoice", "value_")
.WithTag("OtherChoice", "foo_", "bar_1"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("MyChoice", "value_").WithTemplateOption("OtherChoice", "foo_");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.SingleMatch, resultStatus);
Assert.Equal("foo.test_2", singularInvokableMatch.Info.Identity);
}
public void AllTemplatesInGroupUseAllShortNamesForResolution()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
string defaultLanguage = "C#";
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, defaultLanguage);
Assert.Equal(TemplateResolutionResult.UnambiguousTemplateGroupStatus.SingleMatch, matchResult.GroupResolutionStatus);
Assert.Equal(3, matchResult.UnambiguousTemplateGroup.Templates.Count);
Assert.True(matchResult.UnambiguousTemplateGroup.Templates.All(t => WellKnownSearchFilters.MatchesAllCriteria(t)));
foreach (ITemplateMatchInfo templateMatchInfo in matchResult.UnambiguousTemplateGroup.Templates)
{
Assert.Equal("MultiName.Test", templateMatchInfo.Info.GroupIdentity);
if (templateMatchInfo.Info.GetLanguage().Equals(defaultLanguage, StringComparison.OrdinalIgnoreCase))
{
//default language match is part of MatchDisposition collection
Assert.Equal(2, templateMatchInfo.MatchDisposition.Count);
}
else
{
Assert.Equal(1, templateMatchInfo.MatchDisposition.Count);
}
Assert.True(templateMatchInfo.MatchDisposition[0].Name == MatchInfo.BuiltIn.ShortName && templateMatchInfo.MatchDisposition[0].Kind == MatchKind.Exact);
}
}
}
[InlineData("eee", "Y", "Multiname.Test.Only.FSharp")] // uses a short name from a different template in the group
public void ChoiceValueDisambiguatesMatchesWithMultipleShortNames(string name, string fooChoice, string expectedIdentity)
{
INewCommandInput commandInput = new MockNewCommandInput(name).WithTemplateOption("foo", fooChoice);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), commandInput, "C#");
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, matchResult.ResolutionStatus);
Assert.Equal(expectedIdentity, matchResult.TemplateToInvoke.Info.Identity);
}
[InlineData("eee", "OnlyF", "someValue", "Multiname.Test.Only.FSharp")] // uses a short name from a different template in the group
public void ParameterExistenceDisambiguatesMatchesWithMultipleShortNames(string name, string paramName, string paramValue, string expectedIdentity)
{
INewCommandInput commandInput = new MockNewCommandInput(name).WithTemplateOption(paramName, paramValue);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), commandInput, "C#");
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo invokableTemplate, out TemplateResolutionResult.Status resultStatus));
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, resultStatus);
Assert.Equal(expectedIdentity, invokableTemplate.Info.Identity);
}
internal void GetAmbiguousSingleStartsWithParametersTest(MockNewCommandInput command, MockTemplateInfo[] templates, MockInvalidParameterInfo[] expectedInvalidParams)
{
TemplateResolutionResult matchedTemplates = TemplateResolver.GetTemplateResolutionResult(templates, new MockHostSpecificDataLoader(), command, null);
TemplateGroup templateGroup = matchedTemplates.UnambiguousTemplateGroup;
IEnumerable <InvalidParameterInfo> invalidParameters = templateGroup.GetAmbiguousSingleStartsWithParameters();
Assert.Equal(expectedInvalidParams.Length, invalidParameters.Count());
foreach (MockInvalidParameterInfo exp in expectedInvalidParams)
{
Assert.Single(invalidParameters.Where(param => param.ErrorKind == exp.Kind && param.InputFormat == exp.InputFormat && param.SpecifiedValue == exp.SpecifiedValue));
}
}
private async Task <CreationResultStatus> EnterTemplateManipulationFlowAsync()
{
if (_commandInput.IsListFlagSpecified || _commandInput.IsHelpFlagSpecified)
{
TemplateListResolutionResult listingTemplateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateResolutionResult, EnvironmentSettings, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, showUsageHelp: _commandInput.IsHelpFlagSpecified));
}
TemplateResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
TemplateInvocationAndAcquisitionCoordinator invocationCoordinator = new TemplateInvocationAndAcquisitionCoordinator(_settingsLoader, _commandInput, _templateCreator, _hostDataLoader, _telemetryLogger, _defaultLanguage, CommandName, _inputGetter, _callbacks);
return(await invocationCoordinator.CoordinateInvocationOrAcquisitionAsync());
}
internal void TemplateResolution_TemplateToInvoke_Test(MockNewCommandInput command, MockTemplateInfo[] templateSet, string defaultLanguage, int expectedStatus, string expectedIdentity)
{
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templateSet, new MockHostSpecificDataLoader(), command, defaultLanguage);
Assert.Equal(expectedStatus, (int)matchResult.ResolutionStatus);
if (expectedStatus == (int)TemplateResolutionResult.Status.SingleMatch)
{
Assert.Equal(expectedIdentity, matchResult.TemplateToInvoke.Info.Identity);
}
else
{
Assert.Null(matchResult.TemplateToInvoke);
}
}
public void TestPerformCoreTemplateQuery_ParameterValueDisambiguates()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template old", identity: "foo.test.old", groupIdentity: "foo.test.template", precedence: 100).WithTag("framework", "netcoreapp1.0", "netcoreapp1.1"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template new", identity: "foo.test.new", groupIdentity: "foo.test.template", precedence: 200).WithTag("framework", "netcoreapp2.0"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("framework", "netcoreapp1.0");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("foo.test.old", unambiguousGroup[0].Info.Identity);
}
public void GetAllMatchedParametersList_FallbackToName()
{
var templateMatchInfo = A.Fake <ITemplateMatchInfo>();
A.CallTo(() => templateMatchInfo.MatchDisposition).Returns(
new[]
{
new ParameterMatchInfo("param", "paramValue", MatchKind.Mismatch, ParameterMatchInfo.MismatchKind.InvalidValue, null)
});
var parameters = TemplateResolutionResult.GetAllMatchedParametersList(new[] { templateMatchInfo });
Assert.Equal(1, parameters.Count);
Assert.Equal("paramValue", parameters["param"]);
}
public void GetAllMatchedParametersList_IgnoresNonParameterMatches()
{
var templateMatchInfo = A.Fake <ITemplateMatchInfo>();
A.CallTo(() => templateMatchInfo.MatchDisposition).Returns(
new[]
{
new MatchInfo("language", "C#", MatchKind.Exact),
new ParameterMatchInfo("param", "paramValue", MatchKind.Mismatch, ParameterMatchInfo.MismatchKind.InvalidValue, "--param")
});
var parameters = TemplateResolutionResult.GetAllMatchedParametersList(new[] { templateMatchInfo });
Assert.Equal(1, parameters.Count);
Assert.Equal("paramValue", parameters["--param"]);
}
public void ExplicitLanguageChoiceIsHonoredWithMultipleShortNames()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName, "F#");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, matchResult.ResolutionStatus);
Assert.Equal("Multiname.Test.Only.FSharp", matchResult.TemplateToInvoke.Info.Identity);
}
}
public void HighestPrecedenceWinsWithMultipleShortNames()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo invokableTemplate, out TemplateResolutionResult.Status resultStatus));
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, resultStatus);
Assert.Equal("MultiName.Test.High.CSharp", invokableTemplate.Info.Identity);
}
}
public void TestPerformCoreTemplateQuery_UniqueNameMatchesCorrectly()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("Template1", name: "Long name of Template1", identity: "Template1"));
templatesToSearch.Add(new MockTemplateInfo("Template2", name: "Long name of Template2", identity: "Template2"));
INewCommandInput userInputs = new MockNewCommandInput("Template2");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.Equal("Template2", matchResult.GetBestTemplateMatchList()[0].Info.Identity);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("Template2", unambiguousGroup[0].Info.Identity);
}
public void TestPerformCoreTemplateQuery_InputLanguageIsPreferredOverDefault()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Description of foo Perl template", identity: "foo.test.Perl", groupIdentity: "foo.test.template")
.WithTag("language", "Perl"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Description of foo LISP template", identity: "foo.test.Lisp", groupIdentity: "foo.test.template")
.WithTag("language", "LISP"));
INewCommandInput userInputs = new MockNewCommandInput("foo", "LISP");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, "Perl");
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("foo.test.Lisp", unambiguousGroup[0].Info.Identity);
}
public void TestPerformCoreTemplateQuery_GroupIsFound()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template old", identity: "foo.test.old", groupIdentity: "foo.test.template", precedence: 100));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template new", identity: "foo.test.new", groupIdentity: "foo.test.template", precedence: 200));
templatesToSearch.Add(new MockTemplateInfo("bar", name: "Bar template", identity: "bar.test", groupIdentity: "bar.test.template", precedence: 100));
INewCommandInput userInputs = new MockNewCommandInput("foo");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Contains(unambiguousGroup, x => string.Equals(x.Info.Identity, "foo.test.old"));
Assert.Contains(unambiguousGroup, x => string.Equals(x.Info.Identity, "foo.test.new"));
}
public async Task TestGetTemplateResolutionResult_InputLanguageIsPreferredOverDefault()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1"));
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2"));
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor("new list console --language L2"),
defaultLanguage : null,
default).ConfigureAwait(false);
Assert.True(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.NotNull(matchResult.UnambiguousTemplateGroup);
Assert.Equal(2, matchResult.TemplateGroupsWithMatchingTemplateInfo?.Single().Templates.Count);
Assert.Equal(2, matchResult.UnambiguousTemplateGroup?.Templates.Count);
}
public void TestPerformCoreTemplateQuery_UnknownParameterNameInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test", groupIdentity: "foo.test.template", precedence: 100).WithParameters("bar"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("baz");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.False(TemplateResolver.ValidateRemainingParameters(unambiguousGroup[0], out IReadOnlyList <string> invalidParams));
Assert.Equal(1, invalidParams.Count);
Assert.Equal("baz", invalidParams[0]);
}
public async Task TestGetTemplateResolutionResult_TagsMatch(string templateTags, string commandTag, bool matchExpected)
{
const string separator = "||";
string[] templateTagsArray = templateTags.Split(separator);
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test", author: "TemplateAuthor")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithClassifications(templateTagsArray)
.WithBaselineInfo("app", "standard"));
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor($"new list console --tag {commandTag}"),
defaultLanguage : null,
default).ConfigureAwait(false);
if (matchExpected)
{
Assert.True(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.Equal(1, matchResult.TemplateGroupsWithMatchingTemplateInfo.Count());
Assert.Equal(1, matchResult.TemplateGroupsWithMatchingTemplateInfo.Single().Templates.Count);
Assert.False(matchResult.HasClassificationMismatch);
}
else
{
Assert.False(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.Equal(0, matchResult.TemplateGroupsWithMatchingTemplateInfo.Count());
Assert.True(matchResult.HasTemplateGroupMatches);
Assert.Equal(1, matchResult.TemplateGroups.Count());
Assert.Equal(1, matchResult.TemplateGroups.Single().Templates.Count);
Assert.True(matchResult.HasClassificationMismatch);
}
Assert.False(matchResult.HasLanguageMismatch);
Assert.False(matchResult.HasTypeMismatch);
Assert.False(matchResult.HasBaselineMismatch);
Assert.False(matchResult.HasAuthorMismatch);
}
public void GetAllMatchedParametersList_DoesNotDependOnMatchKind()
{
var templateMatchInfo = A.Fake <ITemplateMatchInfo>();
A.CallTo(() => templateMatchInfo.MatchDisposition).Returns(
new[]
{
new ParameterMatchInfo("param", "paramValue", MatchKind.Exact, ParameterMatchInfo.MismatchKind.NoMismatch, "--param"),
new ParameterMatchInfo("param2", "paramValue2", MatchKind.Mismatch, ParameterMatchInfo.MismatchKind.InvalidValue, "--param2"),
new ParameterMatchInfo("param3", "paramValue3", MatchKind.Partial, ParameterMatchInfo.MismatchKind.NoMismatch, "--param3")
});
var parameters = TemplateResolutionResult.GetAllMatchedParametersList(new[] { templateMatchInfo });
Assert.Equal(3, parameters.Count);
Assert.Equal("paramValue", parameters["--param"]);
Assert.Equal("paramValue2", parameters["--param2"]);
Assert.Equal("paramValue3", parameters["--param3"]);
}
public async Task TestGetTemplateResolutionResult_ExactMatchOnShortNameMatchesCorrectly()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App"));
templatesToSearch.Add(new MockTemplateInfo("console2", name: "Long name for Console App #2", identity: "Console.App2"));
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor("new list console"),
defaultLanguage : null,
default).ConfigureAwait(false);
Assert.True(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.Null(matchResult.UnambiguousTemplateGroup);
Assert.Equal(2, matchResult.TemplateGroupsWithMatchingTemplateInfo.Count());
Assert.NotNull(matchResult.TemplateGroupsWithMatchingTemplateInfo.SelectMany(group => group.Templates).Single(t => t.Identity == "Console.App"));
Assert.NotNull(matchResult.TemplateGroupsWithMatchingTemplateInfo.SelectMany(group => group.Templates).Single(t => t.Identity == "Console.App2"));
}
/// <summary>
/// Displays the help in case it is not possible to resolve template to use based on user input on template instantiation.
/// </summary>
/// <param name="resolutionResult">template resolution result</param>
/// <param name="environmentSettings"></param>
/// <param name="commandInput">command input used in CLI</param>
/// <param name="defaultLanguage">default language for the host</param>
/// <param name="installUnitDescriptors">the collection of install unit descriptors</param>
/// <returns></returns>
internal static CreationResultStatus CoordinateAmbiguousTemplateResolutionDisplay(
TemplateResolutionResult resolutionResult,
IEngineEnvironmentSettings environmentSettings,
INewCommandInput commandInput,
string defaultLanguage,
IEnumerable <IInstallUnitDescriptor> installUnitDescriptors)
{
switch (resolutionResult.ResolutionStatus)
{
case TemplateResolutionResult.Status.NoMatch:
Reporter.Error.WriteLine(
string.Format(LocalizableStrings.NoTemplatesMatchingInputParameters, GetInputParametersString(commandInput)).Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.ListTemplatesCommand, commandInput.CommandName).Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.SearchTemplatesCommand, commandInput.CommandName, commandInput.TemplateName).Bold().Red());
return(CreationResultStatus.NotFound);
case TemplateResolutionResult.Status.AmbiguousLanguageChoice:
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHeader.Bold().Red());
DisplayTemplateList(resolutionResult.TemplateGroups, environmentSettings, commandInput, defaultLanguage, useErrorOutput: true);
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousLanguageHint.Bold().Red());
return(CreationResultStatus.NotFound);
case TemplateResolutionResult.Status.AmbiguousTemplateGroupChoice:
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHeader.Bold().Red());
DisplayTemplateList(resolutionResult.TemplateGroups, environmentSettings, commandInput, defaultLanguage, useErrorOutput: true);
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHint.Bold().Red());
return(CreationResultStatus.NotFound);
case TemplateResolutionResult.Status.AmbiguousParameterValueChoice:
environmentSettings.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousChoiceParameterValue, "Authoring");
return(DisplayInvalidParameterError(resolutionResult.UnambiguousTemplateGroup, commandInput));
case TemplateResolutionResult.Status.AmbiguousTemplateChoice:
environmentSettings.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousBestPrecedence, "Authoring");
return(DisplayAmbiguousPrecedenceError(resolutionResult.UnambiguousTemplateGroup, environmentSettings, commandInput, installUnitDescriptors));
case TemplateResolutionResult.Status.InvalidParameter:
return(DisplayInvalidParameterError(resolutionResult.UnambiguousTemplateGroup, commandInput));
}
return(CreationResultStatus.CreateFailed);
}
public void TestPerformCoreTemplateQuery_InvalidChoiceValueInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.1x", groupIdentity: "foo.test.template", precedence: 100).WithTag("framework", "netcoreapp1.0", "netcoreapp1.1"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.2x", groupIdentity: "foo.test.template", precedence: 200).WithTag("framework", "netcoreapp2.0"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("framework", "netcoreapp3.0");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.Contains(unambiguousGroup[0].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
Assert.Contains(unambiguousGroup[1].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
}
private Task <CreationResultStatus> EnterTemplateManipulationFlowAsync()
{
if (_commandInput.IsListFlagSpecified || _commandInput.IsHelpFlagSpecified)
{
TemplateListResolutionResult listingTemplateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(Task.FromResult(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateResolutionResult, EnvironmentSettings, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, showUsageHelp: _commandInput.IsHelpFlagSpecified)));
}
TemplateResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
if (templateResolutionResult.ResolutionStatus == TemplateResolutionResult.Status.SingleMatch)
{
TemplateInvocationCoordinator invocationCoordinator = new TemplateInvocationCoordinator(_settingsLoader, _commandInput, _telemetryLogger, CommandName, _inputGetter, _callbacks);
return(invocationCoordinator.CoordinateInvocationOrAcquisitionAsync(templateResolutionResult.TemplateToInvoke));
}
else
{
return(Task.FromResult(HelpForTemplateResolution.CoordinateAmbiguousTemplateResolutionDisplay(templateResolutionResult, EnvironmentSettings, _commandInput, _defaultLanguage, _settingsLoader.InstallUnitDescriptorCache.Descriptors.Values)));
}
}
public async Task TestGetTemplateResolutionResult_UniqueNameMatchesCorrectly()
{
IReadOnlyList <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>()
{
new MockTemplateInfo("console1", name: "Long name for Console App", identity: "Console.App"),
new MockTemplateInfo("console2", name: "Long name for Console App #2", identity: "Console.App2")
};
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor("new list console2"),
defaultLanguage : null,
default).ConfigureAwait(false);
Assert.True(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.NotNull(matchResult.UnambiguousTemplateGroup);
Assert.Equal("console2", matchResult.UnambiguousTemplateGroup?.Templates.Single().ShortNameList.Single());
Assert.Equal("Console.App2", matchResult.UnambiguousTemplateGroup?.Templates.Single().Identity);
Assert.Equal(1, matchResult.UnambiguousTemplateGroup?.Templates.Count);
}
public async Task TestGetTemplateResolutionResult_MultipleGroupsAreFound()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1"));
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2"));
templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L3", groupIdentity: "Console.App.Test").WithTag("language", "L3"));
templatesToSearch.Add(new MockTemplateInfo("classlib", name: "Long name for Class Library App", identity: "Class.Library.L1", groupIdentity: "Class.Library.Test").WithTag("language", "L1"));
templatesToSearch.Add(new MockTemplateInfo("classlib", name: "Long name for Class Library App", identity: "Class.Library.L2", groupIdentity: "Class.Library.Test").WithTag("language", "L2"));
ListTemplateResolver resolver = new ListTemplateResolver(templatesToSearch, new MockHostSpecificDataLoader());
TemplateResolutionResult matchResult = await resolver.ResolveTemplatesAsync(
GetListCommandArgsFor("new list c"),
defaultLanguage : null,
default).ConfigureAwait(false);
Assert.True(matchResult.HasTemplateGroupWithTemplateInfoMatches);
Assert.Equal(2, matchResult.TemplateGroupsWithMatchingTemplateInfo.Count());
Assert.Equal(5, matchResult.TemplateGroupsWithMatchingTemplateInfo.SelectMany(group => group.Templates).Count());
Assert.Null(matchResult.UnambiguousTemplateGroup);
}
public void GivenOneInvokableTemplateWithNonDefaultLanguage_ItIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("language", "F#"));
INewCommandInput userInputs = new MockNewCommandInput("foo");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.SingleMatch, resultStatus);
Assert.Equal("foo.test_1", singularInvokableMatch.Info.Identity);
}
