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))); }