public void List_CannotParseUnknownColumns(string command) { 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); Assert.NotEmpty(parseResult.Errors); Assert.Contains("Argument 'c1' not recognized. Must be one of:", parseResult.Errors.First().Message); }
public void Install_CanParseInteractiveOption() { 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($"new install source --interactive"); InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult); Assert.True(args.Interactive); Assert.Single(args.TemplatePackages); Assert.Contains("source", args.TemplatePackages); parseResult = myCommand.Parse($"new install source"); args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult); Assert.False(args.Interactive); Assert.Single(args.TemplatePackages); Assert.Contains("source", args.TemplatePackages); }
public void List_Legacy_CannotParseArgsAtBothLevels() { 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("new smth --list smth-else"); Assert.NotEmpty(parseResult.Errors); Assert.Equal("Unrecognized command or argument(s): 'smth'.", parseResult.Errors.First().Message); }
public void List_CannotParseOptionsAtNewLevel(string command, string expectedFilter) { 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); Assert.NotEmpty(parseResult.Errors); Assert.Equal($"Unrecognized command or argument(s): '{expectedFilter}','filter-value'.", parseResult.Errors.First().Message); }
public void Uninstall_NoArguments(string commandName) { 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($"new {commandName}"); UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult); Assert.Empty(parseResult.Errors); Assert.Empty(args.TemplatePackages); }
public void Search_CanParseColumnsAll(string command) { 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); SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult); Assert.True(args.DisplayAllColumns); }
public void Instantiate_CanParseTemplateWithOptions() { 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("new console --framework net5.0"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); Assert.Equal("console", args.ShortName); Assert.Contains("--framework", args.RemainingArguments); Assert.Contains("net5.0", args.RemainingArguments); }
public void Update_CanParseAddSourceOption_MultipleEntries(string testCase) { 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(testCase); UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult); Assert.Equal(2, args.AdditionalSources?.Count); Assert.Contains("my-custom-source1", args.AdditionalSources); Assert.Contains("my-custom-source2", args.AdditionalSources); }
public void Install_Legacy_CanParseMultipleArgs(string testCase) { 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(testCase); InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult); Assert.Equal(2, args.TemplatePackages.Count); Assert.Contains("source1", args.TemplatePackages); Assert.Contains("source2", args.TemplatePackages); }
public void Install_Legacy_Error_NoArguments() { 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($"new --install --interactive"); Assert.True(parseResult.Errors.Any()); Assert.Contains(parseResult.Errors, error => error.Message.Contains("Required argument missing")); Assert.Throws <ArgumentException>(() => new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult)); }
public void Search_CanParseFilterOptionWithoutMainCriteria(string command, string expectedFilter) { FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter]; 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); SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult); Assert.Single(args.AppliedFilters); Assert.Contains("filter-value", args.GetFilterValue(expectedDef)); Assert.Null(args.SearchNameCriteria); }
public Task CannotCreateCommandForInvalidParameter() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithParameters("have:colon", "n1", "n2"); var paramSymbolInfo = new Dictionary <string, string>() { { "longName", "name" }, { "shortName", "n" } }; var symbolInfo = new Dictionary <string, IReadOnlyDictionary <string, string> > { { "n1", paramSymbolInfo }, { "n2", paramSymbolInfo } }; var hostDataLoader = A.Fake <IHostSpecificDataLoader>(); A.CallTo(() => hostDataLoader.ReadHostSpecificTemplateData(template)).Returns(new HostSpecificTemplateData(symbolInfo)); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, hostDataLoader)) .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 foo"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); try { _ = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); } catch (InvalidTemplateParametersException e) { Assert.Equal(2, e.ParameterErrors.Count); Assert.Equal(templateGroup.Templates.Single(), e.Template); return(Verifier.Verify(e.Message, _verifySettings.Settings)); } Assert.True(false, "should not land here"); return(Task.FromResult(1)); }
public void ManuallyAddedOptionIsPreservedOnTemplateSubcommandLevel() { ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false)); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var customOption = new Option <string>("--newOption"); myCommand.AddGlobalOption(customOption); var parseResult = myCommand.Parse("new console --newOption val"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); Assert.NotNull(args.ParseResult); Assert.Equal("console", args.ShortName); Assert.Empty(args.RemainingArguments); Assert.Equal("val", args.ParseResult.GetValueForOption(customOption)); }
// invalid params: // [0] name / value - Kind // [1] canonical // [2] input format // [3] param value // [4] error message internal void CanEvaluateInvalidParameters(string command, MockTemplateInfo[] templates, string?[][] expectedInvalidParams) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(templates, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager templatePackageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new {command}"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Empty(templateCommands); var templateMatchInfos = InstantiateCommand.CollectTemplateMatchInfo(args, settings, templatePackageManager, templateGroup); var invalidOptions = InstantiateCommand.GetInvalidOptions(templateMatchInfos); Assert.Equal(expectedInvalidParams.Length, invalidOptions.Count); foreach (var invalidParam in expectedInvalidParams) { InvalidTemplateOptionResult.Kind expectedErrorKind = invalidParam[0] == "name" ? InvalidTemplateOptionResult.Kind.InvalidName : InvalidTemplateOptionResult.Kind.InvalidValue; string?expectedCanonicalName = invalidParam[1]; string expectedInputFormat = invalidParam[2] ?? throw new Exception("Input Format cannot be null"); string?expectedSpecifiedValue = invalidParam[3]; string?expectedErrorMessage = null; if (invalidParam.Length == 5) { expectedErrorMessage = invalidParam[4]; } var actualParam = invalidOptions.Single(param => param.InputFormat == expectedInputFormat); Assert.Equal(expectedErrorKind, actualParam.ErrorKind); Assert.Equal(expectedCanonicalName, actualParam.TemplateOption?.TemplateParameter.Name); Assert.Equal(expectedInputFormat, actualParam.InputFormat); Assert.Equal(expectedSpecifiedValue, actualParam.SpecifiedValue); Assert.Equal(expectedErrorMessage, actualParam.ErrorMessage); } }
public void Update_CanReturnParseError(string command, string expectedInvalidTokens) { 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); var errorMessages = parseResult.Errors.Select(error => error.Message); var expectedInvalidTokenSets = expectedInvalidTokens.Split("|"); Assert.NotEmpty(parseResult.Errors); Assert.Equal(expectedInvalidTokenSets.Length, parseResult.Errors.Count); foreach (var tokenSet in expectedInvalidTokenSets) { Assert.True(errorMessages.Contains($"Unrecognized command or argument(s): {tokenSet}.") || errorMessages.Contains($"Unrecognized command or argument {tokenSet}.")); } }
//[InlineData("new --search --columns author,type", new[] { "author", "type" })] public void Search_CanParseColumns(string command, string[] expectedColumns) { 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); SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult); Assert.False(args.DisplayAllColumns); Assert.NotEmpty(args.ColumnsToDisplay); Assert.Equal(expectedColumns.Length, args.ColumnsToDisplay?.Count); foreach (var column in expectedColumns) { Assert.Contains(column, args.ColumnsToDisplay); } }
public async Task CacheSearchTagFilterTest(string commandTemplate, string commandTag, 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} --tag {commandTag}"); 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.Sum(res => res.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)); }
/// <summary> /// This method checks if the command line has a valid length and a valid editor command in the first place. /// </summary> /// <param name="commandLine">The command line the user has written.</param> /// <returns> /// A full instanced command if the command line is valid or null if the command line is not valid. /// </returns> /// <exception cref="ArgumentNullException"> /// If commandLine is null or whitespace. /// </exception> public IEditorCommand Parse(string commandLine) { if (string.IsNullOrWhiteSpace(commandLine)) { throw new ArgumentNullException(); } string[] possibleCommands = commandLine.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); string editorCommand = possibleCommands[0].ToLower(); if (possibleCommands.Length > 4) { return(null); } else { switch (editorCommand) { case "add": return(AddCommand.Parse(commandLine)); case "clear": return(ClearCommand.Parse(commandLine)); case "insert": return(InsertCommand.Parse(commandLine)); case "remove": return(RemoveCommand.Parse(commandLine)); case "new": return(NewCommand.Parse(commandLine)); case "run": return(RunCommand.Parse(commandLine)); default: return(null); } } }
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); }
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)); }
#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); }
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); }
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()); }
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()); }
[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); }
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); }