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