public async Task CacheSearchPackageFilterTest(string commandTemplate, string commandPackage, int packMatchCount, int templateMatchCount) { string cacheLocation = TestUtils.CreateTemporaryFolder(); string v1FileLocation = SetupDiscoveryMetadata(cacheLocation, false); string v2FileLocation = SetupTemplateCache(cacheLocation, false); var environment = A.Fake <IEnvironment>(); var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment( virtualize: true, environment: environment, additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false)); var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings); engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory()); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new search {commandTemplate} --package {commandPackage}"); SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult); var templatePackages = await templatePackageManager.GetManagedTemplatePackagesAsync(false, default).ConfigureAwait(false); TemplateSearchCoordinator searchCoordinator = CliTemplateSearchCoordinatorFactory.CreateCliTemplateSearchCoordinator(engineEnvironmentSettings); CliSearchFiltersFactory factory = new CliSearchFiltersFactory(templatePackages); foreach (var location in new[] { v1FileLocation, v2FileLocation }) { A.CallTo(() => environment.GetEnvironmentVariable("DOTNET_NEW_SEARCH_FILE_OVERRIDE")).Returns(location); var searchResults = await searchCoordinator.SearchAsync( factory.GetPackFilter(args), CliSearchFiltersFactory.GetMatchingTemplatesFilter(args), default).ConfigureAwait(false); Assert.Equal(1, searchResults.Count); Assert.Single(searchResults, result => result.Provider.Factory.DisplayName == "NuGet.org"); var nugetSearchResults = searchResults.Single(result => result.Provider.Factory.DisplayName == "NuGet.org"); Assert.Equal(packMatchCount, nugetSearchResults.SearchHits.Count); if (packMatchCount != 0) { Assert.Equal(templateMatchCount, nugetSearchResults.SearchHits.Single(res => res.PackageInfo.Name == _packThreeInfo.Name).MatchedTemplates.Count); } } }
public void DebugFlagCanBeParsedOnTemplateSubcommandLevel(string command, string option) { Dictionary <string, Func <GlobalArgs, bool> > optionsMap = new Dictionary <string, Func <GlobalArgs, bool> >() { { "--debug:attach", args => args.DebugAttach }, { "--debug:ephemeral-hive", args => args.DebugVirtualizeSettings }, { "--debug:reinit", args => args.DebugReinit }, { "--debug:rebuild-cache", args => args.DebugRebuildCache }, { "--debug:show-config", args => args.DebugShowConfig } }; ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false)); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse(command); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); Assert.True(optionsMap[option](args)); Assert.Equal("console", args.ShortName); Assert.Equal(new[] { "--framework", "net5.0", "--flag" }, args.RemainingArguments); }
public Task CanShowHintsForOtherTemplates() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("language", "Lang1").WithTag("type", "project"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group").WithTag("language", "Lang2").WithTag("type", "item"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); ParseResult parseResult = myCommand.Parse("new -h"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); StringWriter sw = new StringWriter(); InstantiateCommand.ShowHintForOtherTemplates(templateGroup, templateGroup.Templates[0], args, sw); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public Task CanShowCommandOptions_Basic() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowCommandOptions(new[] { templateCommand }, templateCommand, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public void CanShowCommandOptions_NoOptions() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("type", "MyType"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); Assert.Equal($"Template options:{Environment.NewLine} (No options){Environment.NewLine}", sw.ToString()); }
internal void Create_CanEvaluateTemplateWithSubcommandShortName(string command, string?expectedIdentitiesStr) { MockTemplateInfo template = new MockTemplateInfo(command, identity: $"{command}Template"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); string[] expectedIdentities = expectedIdentitiesStr?.Split("|") ?? Array.Empty <string>(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(expectedIdentities.Count(), templateCommands.Count); Assert.Equal(expectedIdentities.OrderBy(s => s), templateCommands.Select(templateCommand => templateCommand.Template.Identity).OrderBy(s => s)); }
public void AllTemplatesInGroupUseAllShortNamesForResolution(string shortName) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets["MultiShortNameGroup"], A.Fake <IHostSpecificDataLoader>())) .Single(); var defaultParams = new Dictionary <string, string>() { { "prefs:language", "C#" } }; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new {shortName}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, templateCommands.Count); Assert.Equal("MultiName.Test.High.CSharp", templateCommands.Single().Template.Identity); }
#pragma warning restore xUnit1004 // Test methods should not be skipped public void CanCompleteParameters_StartsWith_AfterOption() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("testChoice", "val1") .WithParameters("foo", "bar"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group") .WithChoiceParameter("testChoice", "val2", "val3") .WithParameters("test"); var templateGroups = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new foo --foo val1 --bar val2 --t"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var completionContext = parseResult.GetCompletionContext() as TextCompletionContext; Assert.NotNull(completionContext); var result = InstantiateCommand.GetTemplateCompletions(args, templateGroups, settings, packageManager, completionContext !).Select(l => l.Label); Assert.DoesNotContain("--test", result); Assert.Contains("--testChoice", result); Assert.DoesNotContain("--foo", result); Assert.DoesNotContain("--bar", result); Assert.DoesNotContain("-p", result); Assert.DoesNotContain("-t", result); Assert.DoesNotContain("-f", result); Assert.DoesNotContain("-b", result); Assert.DoesNotContain("--language", result); Assert.DoesNotContain("--type", result); Assert.DoesNotContain("--baseline", result); }
public void HasMultipleMismatches() { 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") .WithBaselineInfo("app", "standard")); TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new console --language L2 --type item --baseline core"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(0, matchingTemplates.Count()); }
public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("choice", new[] { "val1", "val2", "val3", "val4", "val5", "val6" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance, maxWidth: 50), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public void CanShowTemplateOptions_RequiredIsNotShownWhenDefaultValueIsGiven() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg", isRequired: true); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); Assert.DoesNotContain("(REQUIRED)", sw.ToString()); }
internal void CanParseNameOption(string command, string?expectedValue) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new {command}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); Parser parser = ParserFactory.CreateParser(templateCommand); ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>()); var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult); Assert.Equal(expectedValue, templateArgs.Name); }
internal void Create_CanParseTemplateOptions(string command, string parameterName, string parameterType, string?defaultValue, string?defaultIfNoOptionValue, string?expectedValue) { //unique case for dotnet new create if (command == "foo -in 30") { command = "foo -i 30"; //for dotnet new create "-i" is not occupied, so we can use it. } var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithParameter(parameterName, parameterType, defaultValue: defaultValue, defaultIfNoOptionValue: defaultIfNoOptionValue); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); Parser parser = ParserFactory.CreateParser(templateCommand); ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>()); var templateArgs = new TemplateCommandArgs(templateCommand, instantiateCommand, templateParseResult); if (string.IsNullOrWhiteSpace(expectedValue)) { Assert.False(templateArgs.TemplateParameters.ContainsKey(parameterName)); } else { Assert.True(templateArgs.TemplateParameters.ContainsKey(parameterName)); Assert.Equal(expectedValue, templateArgs.TemplateParameters[parameterName]); } }
public void UniqueNameMatchesCorrectly() { IReadOnlyList <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>() { new MockTemplateInfo("console2", name: "Long name for Console App #2", identity: "Console.App2") }; TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console2"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.True(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out _)); Assert.Empty(output.ToString()); }
public void CanCompleteChoice_FromSingleTemplate_StartsWith() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("testChoice", "val1", "val2", "boo"); var templateGroups = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new foo --testChoice v"); var completionContext = parseResult.GetCompletionContext() as TextCompletionContext; Assert.NotNull(completionContext); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var result = InstantiateCommand.GetTemplateCompletions(args, templateGroups, settings, packageManager, completionContext !).Select(l => l.Label); Assert.Equal(new[] { "val1", "val2" }, result); }
[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) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets["MultiShortNameGroup"], A.Fake <IHostSpecificDataLoader>())) .Single(); var defaultParams = new Dictionary <string, string>() { { "prefs:language", "C#" } }; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); string command = $"new {name} --{paramName} {paramValue}"; var parseResult = myCommand.Parse($" new {command}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, templateCommands.Count); Assert.Equal(expectedIdentity, templateCommands.Single().Template.Identity); }