public void MultipleTemplatesInGroupParamPartiaMatch_TheOneHavingSingleStartsWithIsTheSingularInvokableMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test_1",
GroupIdentity = "foo.test.template",
Precedence = 100,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "MyChoice", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"value_1"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>(),
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test_2",
GroupIdentity = "foo.test.template",
Precedence = 200,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "MyChoice", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"value_2", "value_3"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>(),
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "MyChoice", "value_" }
}
)
{
TemplateName = "foo"
};
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateListResolutionResult matchResult = TemplateListResolver.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 SingularInvokableMatchCheckStatus resultStatus));
Assert.Equal(SingularInvokableMatchCheckStatus.SingleMatch, resultStatus);
Assert.Equal("foo.test_1", singularInvokableMatch.Info.Identity);
}
public void GivenTwoInvokableTemplatesNonDefaultLanguage_HighPrecedenceIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test_1.FSharp",
GroupIdentity = "foo.test.template",
Precedence = 100,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"F#"
}) },
},
CacheParameters = new Dictionary <string, ICacheParameter>(),
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test_1.VB",
GroupIdentity = "foo.test.template",
Precedence = 200,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"VB"
}) },
},
CacheParameters = new Dictionary <string, ICacheParameter>(),
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
}
)
{
TemplateName = "foo"
};
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateListResolutionResult matchResult = TemplateListResolver.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 SingularInvokableMatchCheckStatus resultStatus));
Assert.Equal(SingularInvokableMatchCheckStatus.SingleMatch, resultStatus);
Assert.Equal("foo.test_1.VB", singularInvokableMatch.Info.Identity);
}
public void TestPerformCoreTemplateQuery_InvalidChoiceValueInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test.1x",
GroupIdentity = "foo.test.template",
Precedence = 100,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", CreateTestCacheTag(new List <string>()
{
"netcoreapp1.0", "netcoreapp1.1"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>()
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test.2x",
GroupIdentity = "foo.test.template",
Precedence = 200,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", CreateTestCacheTag(new List <string>()
{
"netcoreapp2.0"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>()
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", "netcoreapp3.0" }
}
)
{
TemplateName = "foo"
};
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateListResolutionResult matchResult = TemplateListResolver.PerformCoreTemplateQuery(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.Equal(2, matchResult.MatchedTemplatesWithSecondaryMatchInfo.Count);
Assert.Equal(2, matchResult.UnambiguousTemplateGroupToUse.Count);
Assert.Equal(2, matchResult.CoreMatchedTemplates.Count);
Assert.True(matchResult.UnambiguousTemplateGroupToUse[0].MatchDisposition.Any(x => x.Kind == MatchKind.InvalidParameterValue));
Assert.True(matchResult.UnambiguousTemplateGroupToUse[1].MatchDisposition.Any(x => x.Kind == MatchKind.InvalidParameterValue));
}
[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);
}
public void TestGetTemplateResolutionResult_UnambiguousGroupIsFound()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.L1",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L1") }
}
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.L2",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L2") }
}
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.L3",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L3") }
}
});
INewCommandInput userInputs = new MockNewCommandInput()
{
TemplateName = "console",
IsListFlagSpecified = true
};
ListOrHelpTemplateListResolutionResult matchResult = TemplateListResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.HasExactMatches);
Assert.Equal(1, matchResult.ExactMatchedTemplatesGrouped.Count);
Assert.Equal(3, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal(3, matchResult.UnambiguousTemplateGroup.Count);
}
public void TestPerformCoreTemplateQuery_ParameterValueDisambiguates()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template old",
Identity = "foo.test.old",
GroupIdentity = "foo.test.template",
Precedence = 100,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"netcoreapp1.0", "netcoreapp1.1"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>()
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template new",
Identity = "foo.test.new",
GroupIdentity = "foo.test.template",
Precedence = 200,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", ResolutionTestHelper.CreateTestCacheTag(new List <string>()
{
"netcoreapp2.0"
}) }
},
CacheParameters = new Dictionary <string, ICacheParameter>()
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "framework", "netcoreapp1.0" }
}
)
{
TemplateName = "foo"
};
TemplateListResolutionResult matchResult = TemplateListResolver.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);
}
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));
}
}
public void CanShowUserSelectedColumns()
{
ITemplateEngineHost host = new TestHost
{
HostIdentifier = "TestRunner",
Version = "1.0.0.0",
Locale = "en-US"
};
IEngineEnvironmentSettings environmentSettings = new MockEngineEnvironmentSettings()
{
Host = host,
Environment = new MockEnvironment()
{
ConsoleBufferWidth = 100
}
};
INewCommandInput command = new MockNewCommandInput()
{
Columns = new List <string>()
{
"column3"
}
};
IEnumerable <Tuple <string, string, string> > data = new List <Tuple <string, string, string> >()
{
new Tuple <string, string, string>("My test data", "My test data", "Column 3 data"),
new Tuple <string, string, string>("My test data", "My test data", "Column 3 data")
};
string expectedOutput = $"Column 1 Column 3 {Environment.NewLine}------------ -------------{Environment.NewLine}My test data Column 3 data{Environment.NewLine}My test data Column 3 data{Environment.NewLine}";
HelpFormatter <Tuple <string, string, string> > formatter =
HelpFormatter
.For(
environmentSettings,
command,
data,
columnPadding: 2,
headerSeparator: '-',
blankLineBetweenRows: false)
.DefineColumn(t => t.Item1, "Column 1", showAlways: true)
.DefineColumn(t => t.Item2, "Column 2", columnName: "column2") //defaultColumn: true by default
.DefineColumn(t => t.Item3, "Column 3", columnName: "column3", defaultColumn: false);
string result = formatter.Layout();
Assert.Equal(expectedOutput, result);
}
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 async Task CacheSearchLanguageMismatchFilterTest()
{
TemplateDiscoveryMetadata mockTemplateDiscoveryMetadata = SetupDiscoveryMetadata(false);
MockCliNuGetMetadataSearchSource.SetupMockData(mockTemplateDiscoveryMetadata);
_engineEnvironmentSettings.SettingsLoader.Components.Register(typeof(MockCliNuGetMetadataSearchSource));
MockNewCommandInput commandInput = new MockNewCommandInput("bar", "VB");
TemplateSearchCoordinator searchCoordinator = CliTemplateSearchCoordinatorFactory.CreateCliTemplateSearchCoordinator(_engineEnvironmentSettings, commandInput, DefaultLanguage);
SearchResults searchResults = await searchCoordinator.SearchAsync().ConfigureAwait(false);
Assert.True(searchResults.AnySources);
Assert.Equal(0, searchResults.MatchesBySource.Count);
}
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 TestPerformCoreTemplateQuery_GroupIsFound()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template old",
Identity = "foo.test.old",
GroupIdentity = "foo.test.template",
Precedence = 100,
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>()
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template new",
Identity = "foo.test.new",
GroupIdentity = "foo.test.template",
Precedence = 200,
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>()
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "bar",
Name = "Bar template",
Identity = "bar.test",
GroupIdentity = "bar.test.template",
Precedence = 100,
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>()
});
INewCommandInput userInputs = new MockNewCommandInput()
{
TemplateName = "foo"
};
TemplateListResolutionResult matchResult = TemplateListResolver.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 void TestPerformCoreTemplateQuery_UnknownParameterNameInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test",
GroupIdentity = "foo.test.template",
Precedence = 100,
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase),
CacheParameters = new Dictionary <string, ICacheParameter>()
{
{ "bar", new CacheParameter() },
}
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "baz", null }
}
)
{
TemplateName = "foo"
};
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateListResolutionResult matchResult = TemplateListResolver.PerformCoreTemplateQuery(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.Equal(null, matchResult.MatchedTemplatesWithSecondaryMatchInfo);
Assert.Equal(1, matchResult.UnambiguousTemplateGroupToUse.Count);
// TODO:
// These 2 lines are the analogues of what happens in New3Command.EnterSingularTemplateManipulationFlowAsync()
// as a final verification for the template.
// This is really a shortcoming of the resolver, this check should get factored into it.
// But we'll need to add a new match category so we know that the unambiguous template "matched", except the extra user parameters.
HostSpecificTemplateData hostTemplateData = hostSpecificDataLoader.ReadHostSpecificTemplateData(matchResult.UnambiguousTemplateGroupToUse[0].Info);
userInputs.ReparseForTemplate(matchResult.UnambiguousTemplateGroupToUse[0].Info, hostTemplateData);
Assert.False(TemplateListResolver.ValidateRemainingParameters(userInputs, out IReadOnlyList <string> invalidParams));
Assert.Equal(1, invalidParams.Count);
Assert.Equal("baz", invalidParams[0]);
}
public async Task CacheSearchCliSymbolNameMismatchFilterTest()
{
TemplateDiscoveryMetadata mockTemplateDiscoveryMetadata = SetupDiscoveryMetadata(true);
MockCliNuGetMetadataSearchSource.SetupMockData(mockTemplateDiscoveryMetadata);
_engineEnvironmentSettings.SettingsLoader.Components.Register(typeof(MockCliNuGetMetadataSearchSource));
// "tfm" is not a vaild symbol for the "foo" template. So it should not match.
INewCommandInput commandInput = new MockNewCommandInput("foo").WithTemplateOption("tfm", "netcoreapp2.0");
TemplateSearchCoordinator searchCoordinator = CliTemplateSearchCoordinatorFactory.CreateCliTemplateSearchCoordinator(_engineEnvironmentSettings, commandInput, DefaultLanguage);
SearchResults searchResults = await searchCoordinator.SearchAsync().ConfigureAwait(false);
Assert.True(searchResults.AnySources);
Assert.Equal(0, searchResults.MatchesBySource.Count);
}
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 TestGetTemplateResolutionResult_MatchByTagsAndMismatchByFilter()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.T1",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Classifications = new List <string> {
"Common", "Test"
},
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L1") },
{ "type", ResolutionTestHelper.CreateTestCacheTag("project") }
},
BaselineInfo = new Dictionary <string, IBaselineInfo>()
{
{ "app", new BaselineInfo() },
{ "standard", new BaselineInfo() }
}
});
INewCommandInput userInputs = new MockNewCommandInput()
{
TemplateName = "Common",
IsListFlagSpecified = true,
Language = "L2",
TypeFilter = "item",
};
ListOrHelpTemplateListResolutionResult matchResult = TemplateListResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.False(matchResult.HasExactMatches);
Assert.Equal(0, matchResult.ExactMatchedTemplatesGrouped.Count);
Assert.Equal(0, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasPartialMatches);
Assert.Equal(1, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(1, matchResult.PartiallyMatchedTemplatesGrouped.Count);
Assert.True(matchResult.HasLanguageMismatch);
Assert.True(matchResult.HasContextMismatch);
Assert.False(matchResult.HasBaselineMismatch);
}
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 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"));
INewCommandInput userInputs = new MockNewCommandInput("console").WithHelpOption();
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.HasExactMatches);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal("console", matchResult.UnambiguousTemplateGroup.Single().Info.ShortName);
Assert.Equal("Console.App", matchResult.UnambiguousTemplateGroup.Single().Info.Identity);
Assert.Equal(1, matchResult.UnambiguousTemplateGroup.Count);
}
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 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"));
MockNewCommandInput userInputs = new MockNewCommandInput("console").WithListOption().WithCommandOption("--tag", commandTag);
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
if (matchExpected)
{
Assert.True(matchResult.HasExactMatches);
Assert.Equal(1, matchResult.ExactMatchedTemplateGroups.Count);
Assert.Equal(1, matchResult.ExactMatchedTemplates.Count);
Assert.False(matchResult.HasPartialMatches);
Assert.Equal(0, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(0, matchResult.PartiallyMatchedTemplateGroups.Count);
Assert.False(matchResult.HasClassificationMismatch);
}
else
{
Assert.False(matchResult.HasExactMatches);
Assert.Equal(0, matchResult.ExactMatchedTemplateGroups.Count);
Assert.Equal(0, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasPartialMatches);
Assert.Equal(1, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(1, matchResult.PartiallyMatchedTemplateGroups.Count);
Assert.True(matchResult.HasClassificationMismatch);
}
Assert.False(matchResult.HasLanguageMismatch);
Assert.False(matchResult.HasTypeMismatch);
Assert.False(matchResult.HasBaselineMismatch);
Assert.False(matchResult.HasAuthorMismatch);
}
public void TestPerformCoreTemplateQuery_ParameterNameDisambiguates()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test.old",
GroupIdentity = "foo.test.template",
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase),
CacheParameters = new Dictionary <string, ICacheParameter>(StringComparer.OrdinalIgnoreCase)
{
{ "bar", new CacheParameter() },
}
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "foo",
Name = "Foo template",
Identity = "foo.test.new",
GroupIdentity = "foo.test.template",
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase),
CacheParameters = new Dictionary <string, ICacheParameter>(StringComparer.OrdinalIgnoreCase)
{
{ "baz", new CacheParameter() },
}
});
INewCommandInput userInputs = new MockNewCommandInput(
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "baz", "whatever" }
}
)
{
TemplateName = "foo"
};
TemplateListResolutionResult matchResult = TemplateListResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("foo.test.new", unambiguousGroup[0].Info.Identity);
}
public void TestGetTemplateResolutionResult_InputLanguageIsPreferredOverDefault()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.L1",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L1") }
}
});
templatesToSearch.Add(new TemplateInfo()
{
ShortName = "console",
Name = "Long name for Console App",
Identity = "Console.App.L2",
GroupIdentity = "Console.App.Test",
CacheParameters = new Dictionary <string, ICacheParameter>(),
Tags = new Dictionary <string, ICacheTag>(StringComparer.OrdinalIgnoreCase)
{
{ "language", ResolutionTestHelper.CreateTestCacheTag("L2") }
}
});
INewCommandInput userInputs = new MockNewCommandInput()
{
TemplateName = "console",
IsListFlagSpecified = true,
Language = "L2"
};
ListOrHelpTemplateListResolutionResult matchResult = TemplateListResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, "L1");
Assert.True(matchResult.HasExactMatches);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal("console", matchResult.UnambiguousTemplateGroup.Single().Info.ShortName);
Assert.Equal("Console.App.L2", matchResult.UnambiguousTemplateGroup.Single().Info.Identity);
Assert.Equal("L2", matchResult.UnambiguousTemplateGroup.Single().Info.Tags["language"].ChoicesAndDescriptions.Keys.FirstOrDefault());
Assert.Equal(1, matchResult.UnambiguousTemplateGroup.Count);
}
[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)
{
IReadOnlyDictionary <string, string> userParams = new Dictionary <string, string>()
{
{ "foo", fooChoice }
};
INewCommandInput commandInput = new MockNewCommandInput(userParams)
{
TemplateName = name
};
TemplateListResolutionResult matchResult = TemplateListResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), commandInput, "C#");
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo invokableTemplate, out TemplateListResolutionResult.SingularInvokableMatchCheckStatus resultStatus));
Assert.Equal(TemplateListResolutionResult.SingularInvokableMatchCheckStatus.SingleMatch, resultStatus);
Assert.Equal(expectedIdentity, invokableTemplate.Info.Identity);
}
public void TestGetTemplateResolutionResult_UnambiguousGroupIsFound()
{
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"));
INewCommandInput userInputs = new MockNewCommandInput("console").WithHelpOption();
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.HasExactMatches);
Assert.Equal(1, matchResult.ExactMatchedTemplateGroups.Count);
Assert.Equal(3, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal(3, matchResult.UnambiguousTemplateGroup.Count);
}
public void 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"));
INewCommandInput userInputs = new MockNewCommandInput("console", "L2").WithHelpOption();
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, "L1");
Assert.True(matchResult.HasExactMatches);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal("console", matchResult.UnambiguousTemplateGroup.Single().Info.ShortName);
Assert.Equal("Console.App.L2", matchResult.UnambiguousTemplateGroup.Single().Info.Identity);
Assert.Equal("L2", matchResult.UnambiguousTemplateGroup.Single().Info.Tags["language"].Choices.Keys.FirstOrDefault());
Assert.Equal(1, matchResult.UnambiguousTemplateGroup.Count);
}
public async Task CacheSearchLanguageFilterTest()
{
TemplateDiscoveryMetadata mockTemplateDiscoveryMetadata = SetupDiscoveryMetadata(false);
MockCliNuGetMetadataSearchSource.SetupMockData(mockTemplateDiscoveryMetadata);
EngineEnvironmentSettings.SettingsLoader.Components.Register(typeof(MockCliNuGetMetadataSearchSource));
Dictionary <string, string> rawCommandInputs = new Dictionary <string, string>();
MockNewCommandInput commandInput = new MockNewCommandInput("bar", "F#");
TemplateSearchCoordinator searchCoordinator = CliTemplateSearchCoordinatorFactory.CreateCliTemplateSearchCoordinator(EngineEnvironmentSettings, commandInput, DefaultLanguage);
SearchResults searchResults = await searchCoordinator.SearchAsync();
Assert.True(searchResults.AnySources);
Assert.Equal(1, searchResults.MatchesBySource.Count);
Assert.Equal(1, searchResults.MatchesBySource[0].PacksWithMatches.Count);
Assert.Single(searchResults.MatchesBySource[0].PacksWithMatches[_packThreeInfo].TemplateMatches.Where(t => string.Equals(t.Info.Name, _barFSharpTemplate.Name)));
}
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 CacheSearchNameMatchTest()
{
TemplateDiscoveryMetadata mockTemplateDiscoveryMetadata = SetupDiscoveryMetadata(false);
MockCliNuGetMetadataSearchSource.SetupMockData(mockTemplateDiscoveryMetadata);
_engineEnvironmentSettings.SettingsLoader.Components.Register(typeof(MockCliNuGetMetadataSearchSource));
INewCommandInput commandInput = new MockNewCommandInput("foo");
TemplateSearchCoordinator searchCoordinator = CliTemplateSearchCoordinatorFactory.CreateCliTemplateSearchCoordinator(_engineEnvironmentSettings, commandInput, DefaultLanguage);
SearchResults searchResults = await searchCoordinator.SearchAsync().ConfigureAwait(false);
Assert.True(searchResults.AnySources);
Assert.Equal(1, searchResults.MatchesBySource.Count);
Assert.Equal(2, searchResults.MatchesBySource[0].PacksWithMatches.Count);
Assert.Single(searchResults.MatchesBySource[0].PacksWithMatches[_packOneInfo].TemplateMatches.Where(t => string.Equals(t.Info.Name, _fooOneTemplate.Name)));
Assert.Single(searchResults.MatchesBySource[0].PacksWithMatches[_packTwoInfo].TemplateMatches.Where(t => string.Equals(t.Info.Name, _fooTwoTemplate.Name)));
}
