internal void CanParseAllowScriptsOption(string command, AllowRunScripts?result) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithPostActions(ProcessStartPostActionProcessor.ActionProcessorId); 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(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>()); TemplateCommandArgs templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult); Assert.Equal(result, templateArgs.AllowScripts); }
public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group", precedence: 0) .WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val-not-shown", defaultIfNoOptionValue: "def-val-not-shown") .WithParameter("bool", paramType: "boolean", description: "my bool", defaultValue: "false", defaultIfNoOptionValue: "false"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group", precedence: 2) .WithChoiceParameter("choice", new[] { "val1", "val3" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg") .WithParameter("int", paramType: "integer", description: "my int", defaultValue: "0", defaultIfNoOptionValue: "10"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, 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 templateCommand1 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]); TemplateCommand templateCommand2 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand2, templateCommand1 }, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
internal void WriteCommand(TemplateCommand cmd) { lines = 0; switch (cmd.Type) { case TemplateCommandType.Code: WriteCode(cmd.Body); break; case TemplateCommandType.Literal: WriteLiteral(cmd.Body); break; case TemplateCommandType.Expression: WriteExpression(cmd.Body); break; case TemplateCommandType.Include: WriteInclude(cmd.Body); break; case TemplateCommandType.SetParentTemplate: WriteSetParentTemplate(cmd.Body); break; case TemplateCommandType.OutputToSection: cmd.Body = cmd.Body.Trim(); WriteOutputToSection(string.IsNullOrEmpty(cmd.Body) ? null : cmd.Body); break; case TemplateCommandType.WriteChildSection: cmd.Body = cmd.Body.Trim(); WriteWriteChildSection(string.IsNullOrEmpty(cmd.Body) ? null : cmd.Body); break; } cmd.ExecutableLines = lines; }
internal void Create_CanDetectParseErrorsChoiceTemplateOptions( string command, string parameterName, string parameterValues, bool isRequired, string?defaultValue, string?defaultIfNoOptionValue, string expectedError) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter(parameterName, parameterValues.Split("|"), isRequired, defaultValue, 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>()); Assert.True(templateParseResult.Errors.Any()); Assert.Equal(expectedError, templateParseResult.Errors.Single().Message); }
internal void CanParseMultiChoiceTemplateOptions(string command, string parameterName, string parameterValues, string?defaultIfNoOptionValue, string?expectedValue) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter(parameterName, parameterValues.Split("|"), defaultIfNoOptionValue: defaultIfNoOptionValue, allowMultipleValues: 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()); 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); if (string.IsNullOrWhiteSpace(expectedValue)) { Assert.False(templateArgs.TemplateParameters.ContainsKey(parameterName)); } else { Assert.True(templateArgs.TemplateParameters.ContainsKey(parameterName)); Assert.Equal(expectedValue, templateArgs.TemplateParameters[parameterName]); } }
public TemplateCommand ReadCommand() { if (reader.EndOfStream) return null; var cmd = new TemplateCommand(); string command = ReadUntilToken(directive ? "%>" : "<%"); cmd.TemplateLines = command.GetNumLines(); if (directive) if (EatTokenFromStart("#", ref command) || EatTokenFromStart("include", ref command)) cmd.Type = TemplateCommandType.Include; else if (EatTokenFromStart("=", ref command)) cmd.Type = TemplateCommandType.Expression; else if (EatTokenFromStart(":", ref command) || EatTokenFromStart("set-section", ref command)) cmd.Type = TemplateCommandType.OutputToSection; else if (EatTokenFromStart("!", ref command) || EatTokenFromStart("get-section", ref command)) cmd.Type = TemplateCommandType.WriteChildSection; else if (EatTokenFromStart("@", ref command) || EatTokenFromStart("set-parent", ref command)) cmd.Type = TemplateCommandType.SetParentTemplate; else cmd.Type = TemplateCommandType.Code; else cmd.Type = TemplateCommandType.Literal; cmd.Body = command; // the main logic is read literal, read directive, rinse, lather, repeat. directive = !directive; // don't return empty literals return (cmd.Type == TemplateCommandType.Literal && cmd.Body == "") ? ReadCommand() : cmd; }
public void WhenExecuteCommandWithValidTemplateConfig_CommandManager_ShouldExecuteReplaces() { var myAbsolutePath = @"c:\absolute\my\Path"; var myPath = @"my\Path"; var myTemplateName = "My template name"; var myNewPathName = "MySecondApp"; var myOldValue = "myOldValue"; var myNewVale = "myNewValue"; var fileService = new FileServiceMock() { DDTemplateConfigReturn = new DDTemplateConfig() { TemplateName = myTemplateName, IgnorePathPatterns = new List <string>(), ReplacePairs = new List <ReplacePair>() { new ReplacePair() { ApplyForDirectories = true, ApplyForFileContents = true, ApplyForFileNames = true, ApplyForFilePattern = "*.*", OldValue = myOldValue, ReplaceDescription = "My replace description" } } }, ExistsTemplateConfigFileReturn = true, ExistsDirectoryReturn = true, AbsoluteCurrentPathReturn = myAbsolutePath }; var consoleInputs = new List <string>() { myNewPathName, myNewVale }; var commandDefinition = new TemplateCommand(fileService, _storedDataService); var instance = new CommandManager(_loggerServiceMock, _storedDataService, _cryptoServiceMock); instance.RegisterCommand(commandDefinition); var inputRequest = new InputRequest( commandDefinition.GetInvocationCommandName(), commandDefinition.CommandPathParameter.GetInvokeName(), myPath); instance.ExecuteInputRequest(inputRequest, consoleInputs); //Assert.Equal(fileService.CreatedDirectory, myAbsolutePath); Assert.Equal(fileService.ClonedDirectorySource, myPath); Assert.Equal(fileService.ClonedDirectoryDestination, myAbsolutePath); Assert.Equal(fileService.ReplacedStringInPathsNewValue, myNewVale); Assert.Equal(fileService.ReplacedStringInPathsOldValue, myOldValue); Assert.Equal(fileService.ReplacedFilesContentsPath, myAbsolutePath); Assert.Equal(fileService.ReplacedFilesNamesPath, myAbsolutePath); Assert.Equal(fileService.ReplacedSubDirectoriesPath, myAbsolutePath); }
public TemplateCommandViewModel(TemplateCommand templateCommand, IEnumerable<TemplateParameterViewModel> templateParameterViewModels) { m_templateCommand = templateCommand; m_templateCommand.CheckCommand(); foreach (TemplateParameterViewModel templateParameterViewModel in m_templateCommand.UsedParameters.Select(n => templateParameterViewModels.FirstOrDefault(m => m.Name == n.Name))) { templateParameterViewModel.PropertyChanged += TemplateParameterViewModelOnPropertyChanged; } m_commandString = m_templateCommand.ToString(); foreach (string error in m_templateCommand.Errors) Errors.Add(error); UpdateStatusBrush(); }
public SelectValuteViewModel() { ApplicationView.PreferredLaunchViewSize = new Size(500, 250); ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize; var view = ApplicationView.GetForCurrentView(); view.SetPreferredMinSize(new Size(500, 250)); view.Title = "Выбор валюты"; // Установка команд. Selected = new TemplateCommand(OnSelected); }
public MainViewModel() { ApplicationView.PreferredLaunchViewSize = new Size(500, 150); ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize; var view = ApplicationView.GetForCurrentView(); view.SetPreferredMinSize(new Size(500, 150)); view.Title = "Конвертер валюты"; // Установка команд SelectFirst = new TemplateCommand(OnSelectFirst); SelectSecond = new TemplateCommand(OnSelectSecond); }
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 WhenExecuteCommandWithoutPathParameter_CommandManager_ShouldThrowException() { var fileService = new FileServiceMock(); var commandDefinition = new TemplateCommand(fileService, _storedDataService); var instance = new CommandManager(_loggerServiceMock, _storedDataService, _cryptoServiceMock); instance.RegisterCommand(commandDefinition); var inputRequest = new InputRequest( commandDefinition.GetInvocationCommandName()); Assert.Throws <InvalidParamsException>(() => { instance.ExecuteInputRequest(inputRequest); }); }
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()); }
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()); }
private void ComboBoxTemplate_SelectionChanged(object sender, SelectionChangedEventArgs e) { ComboBox comboBox = sender as ComboBox; if (comboBox.SelectedItem is Template template) { TextBoxProjectName.Text = template.Name; TextBoxProjectLocation.Text = template.ProjectLocation; TextBoxCacheLocation.Text = template.CacheLocation; Templates.Remove(template); Templates.Insert(0, template); ButtonTemplate.Content = "Delete template"; _templateCommand = TemplateCommand.Delete; } else { ButtonTemplate.Content = "Save template"; _templateCommand = TemplateCommand.Save; } }
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)); }
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]); } }
internal void Create_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 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); Assert.Equal(expectedValue, templateArgs.Name); }
public void WhenExecuteCommandWithNonExistingTemplateConfigFile_CommandManager_ShouldThrowException() { var myPath = @"my\Path"; var fileService = new FileServiceMock() { ExistsTemplateConfigFileReturn = false, ExistsDirectoryReturn = true }; var commandDefinition = new TemplateCommand(fileService, _storedDataService); var instance = new CommandManager(_loggerServiceMock, _storedDataService, _cryptoServiceMock); instance.RegisterCommand(commandDefinition); var inputRequest = new InputRequest( commandDefinition.GetInvocationCommandName(), commandDefinition.CommandPathParameter.GetInvokeName(), myPath); Assert.Throws <TemplateConfigFileNotFoundException>(() => { instance.ExecuteInputRequest(inputRequest); }); }
// ReSharper restore UnusedAutoPropertyAccessor.Global // ReSharper restore MemberCanBePrivate.Global public static void Initialize(Package package) { Instance = new TemplateCommand(package); }