public void before_all()
{
// setup
_command = new NewCommand();
_fileSystem = new FileSystem();
_zipService = new ZipFileService(_fileSystem);
_commandInput = new NewCommandInput();
tmpDir = FileSystem.Combine("Templating", Guid.NewGuid().ToString());
repoZip = FileSystem.Combine("Templating", "repo.zip");
_zipService.ExtractTo(repoZip, tmpDir, ExplodeOptions.DeleteDestination);
solutionFile = FileSystem.Combine("Templating", "sample", "myproject.txt");
oldContents = _fileSystem.ReadStringFromFile(solutionFile);
solutionDir = _fileSystem.GetDirectory(solutionFile);
_commandInput.GitFlag = "file:///{0}".ToFormat(_fileSystem.GetFullPath(tmpDir).Replace("\\", "/"));
_commandInput.ProjectName = "MyProject";
_commandInput.SolutionFlag = solutionFile;
_commandInput.OutputFlag = solutionDir;
_commandInput.RakeFlag = "init.rb";
_commandResult = _command.Execute(_commandInput);
newSolutionContents = _fileSystem.ReadStringFromFile(solutionFile);
}
public vm_AdmissionTypeEdit()
: base()
{
ActionCommand = new NewCommand(this);
ActionMenuService.SetAction(null, ActionCommand, null, null, null);
Load();
}
public vm_PriorityObjectEdit()
: base()
{
ActionCommand = new NewCommand(this);
ActionMenuService.SetAction(null, ActionCommand, null, null, null);
Load();
}
public void before_each()
{
_command = new NewCommand();
_fileSystem = new FileSystem();
_zipService = new ZipFileService(_fileSystem);
_commandInput = new NewCommandInput();
}
public vm_FacultyEdit()
: base()
{
ActionCommand = new NewCommand(this);
ActionMenuService.SetAction(null, ActionCommand, null, null, null);
Load();
}
public void CreateNewInterfaceImplementation()
{
var implementations = For<ImplementationList>();
var classifiers = new ClassifierDictionary();
var messageSystem = For<MessageSystem>();
var implementation = For<Implementation>();
implementations.CreateNew(classifiers).Returns(implementation);
var newCommand = new NewCommand<Implementation>(implementations, classifiers, messageSystem);
newCommand.CreateNew();
messageSystem.Received().PublishCreated(implementations, implementation);
}
public void no_tests_if_no_tests_flag()
{
var input = new NewCommandInput
{
SolutionName = "NewThing",
AppFlag = true,
TestsFlag = false
};
var request = NewCommand.BuildTemplateRequest(input);
request.TestingProjects.Any().ShouldBeFalse();
}
public void CommandExampleCanShowParentCommandsBeyondNew()
{
ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
Command rootCommand = new Command("dotnet")
{
myCommand
};
var parseResult = rootCommand.Parse("dotnet new uninstall source");
Assert.Equal("dotnet new uninstall my-source", Example.For <NewCommand>(parseResult).WithSubcommand <UninstallCommand>().WithArgument(UninstallCommand.NameArgument, "my-source"));
}
public void supports_the_shortname_flag()
{
var input = new NewCommandInput
{
SolutionName = "FubuMVC.Scenarios",
AppFlag = true,
ShortNameFlag = "Foo"
};
var request = NewCommand.BuildTemplateRequest(input);
request.Projects.Single().Substitutions.ValueFor(ProjectPlan.SHORT_NAME).ShouldEqual("Foo");
}
protected override void RaiseCanExecuteCommands()
{
OpenCommand.RaiseCanExecuteChanged();
CloseCommand.RaiseCanExecuteChanged();
//NextPageCommand.RaiseCanExecuteChanged();
//PreviousPageCommand.RaiseCanExecuteChanged();
//FirstPageCommand.RaiseCanExecuteChanged();
//LastPageCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
NewCommand.RaiseCanExecuteChanged();
DeleteCommand.RaiseCanExecuteChanged();
ReloadCommand.RaiseCanExecuteChanged();
}
public void default_ripple_is_public_only()
{
var input = new NewCommandInput
{
SolutionName = "NewThing",
};
var request = NewCommand.BuildTemplateRequest(input);
request.Templates.ShouldContain("public-ripple");
request.Templates.ShouldNotContain("edge-ripple");
request.Templates.ShouldNotContain("floating-ripple");
}
public void Install_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);
InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.Equal(2, args.AdditionalSources?.Count);
Assert.Contains("my-custom-source1", args.AdditionalSources);
Assert.Contains("my-custom-source2", args.AdditionalSources);
Assert.Single(args.TemplatePackages);
Assert.Contains("source", args.TemplatePackages);
}
public void Uninstall_WithMultipleArgument(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);
UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.Empty(parseResult.Errors);
Assert.Equal(2, args.TemplatePackages.Count);
Assert.Contains("source1", args.TemplatePackages);
Assert.Contains("source2", args.TemplatePackages);
}
public void add_spark_but_not_no_views_if_spark_option_is_requested()
{
var input = new NewCommandInput
{
SolutionName = "FubuMVC.Scenarios",
AppFlag = true,
OptionsFlag = new string[] { "spark" }
};
var request = NewCommand.BuildTemplateRequest(input);
request.Projects.Single().Alterations.ShouldNotContain("no-views");
request.Projects.Single().Alterations.ShouldContain("spark");
}
public void should_add_a_bundler_step_if_there_are_any_gem_references()
{
var request = new TemplateRequest
{
SolutionName = "Foo",
RootDirectory = "Foo"
};
request.AddTemplate("baseline");
NewCommand.BuildTemplatePlan(request)
.Steps.OfType <BundlerStep>()
.Count().ShouldEqual(1);
}
public void no_project_if_app_flag_is_false()
{
var input = new NewCommandInput
{
SolutionName = "NewThing",
RippleFlag = FeedChoice.Edge
};
input.AppFlag.ShouldBeFalse();
var request = NewCommand.BuildTemplateRequest(input);
request.Projects.Any().ShouldBeFalse();
}
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);
}
void DeleteTourCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
{
if (e.Error == null)
{
Tours.Remove(SelectedTour);
NewCommand.Execute(null);
}
else
{
ErrorProvider.ShowError(e.Error, Navigator);
}
dataClient.DeleteTourCompleted -= DeleteTourCompleted;
Busy = false;
}
public void choose_the_float_ripple()
{
var input = new NewCommandInput
{
SolutionName = "NewThing",
RippleFlag = FeedChoice.FloatingEdge
};
var request = NewCommand.BuildTemplateRequest(input);
request.Templates.ShouldNotContain("public-ripple");
request.Templates.ShouldNotContain("edge-ripple");
request.Templates.ShouldContain("floating-ripple");
}
public static CommandLineApplication Create(ref string[] args)
{
var app = new CommandLineApplication
{
Name = "RESTier",
FullName = "RESTier CLI Commands"
};
app.VersionOption("-v|--version", "1.0.0");
app.HelpOption("-h|--help");
app.Option("-c|--connectionstring",
"A connection string to a database. Used to reverse engineer a RESTier API.",
CommandOptionType.SingleValue);
app.Option("-db|--database", "The database type for the new RESTier project, currently support SQLServer and MySQL",
CommandOptionType.SingleValue);
app.Option("-a|--all", "Execute the new, build, run commands together", CommandOptionType.NoValue);
app.Command("new", c => NewCommand.Configure(c));
app.Command("build", c => BuildCommand.Configure(c));
app.Command("run", c => RunCommand.Configure(c));
app.OnExecute(
() =>
{
var connectionString = app.GetOptionValue("connectionstring");
var dbOption = app.GetOptionValue("database");
if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrEmpty(dbOption))
{
WriteLogo();
app.ShowHelp();
return(0);
}
var ret = app.Commands.First(c => c.Name == "new").Execute();
// execute the build and run command for the -a option
if (ret == 0 && app.Options.First(c => (c.LongName == "all" || c.ShortName == "a")).HasValue())
{
string projectName = app.Commands.First(c => c.Name == "new").GetOptionValue("name");
string[] argsForBuild = { "-p", projectName + "\\" + projectName + ".sln" };
app.Commands.First(c => c.Name == "build").Execute(argsForBuild);
app.Commands.First(c => c.Name == "run").Execute(argsForBuild);
}
return(0);
});
return(app);
}
public void Update_Legacy_CanParseCheckOnlyOption()
{
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 --update-check");
UpdateCommandArgs args = new UpdateCommandArgs((LegacyUpdateCheckCommand)parseResult.CommandResult.Command, parseResult);
Assert.True(args.CheckOnly);
parseResult = myCommand.Parse($"new --update-apply");
args = new UpdateCommandArgs((LegacyUpdateApplyCommand)parseResult.CommandResult.Command, parseResult);
Assert.False(args.CheckOnly);
}
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 FileCommand(NewCommand newCommand, OpenCommand openCommand, SaveCommand saveCommand, SaveAsCommand saveAsCommand,
PrintCommand printCommand, PrintPreviewCommand printPreviewCommand, ExitCommand exitCommand) : base(MenuStrings.fileToolStripMenuItem_Text)
{
ChildrenCommands = new List <IToolbarCommand>
{
newCommand,
openCommand,
null,
saveCommand,
saveAsCommand,
null,
printCommand,
printPreviewCommand,
null,
exitCommand
};
}
// 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}."));
}
}
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));
}
//[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 void DebugFlagCanBeParsedOnSubcommandLevel(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 = ParserFactory.CreateParser(myCommand).Parse(command);
InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.True(optionsMap[option](args));
}
public void Install_CanParseForceOption()
{
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 --force");
InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
Assert.True(args.Force);
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.Force);
Assert.Single(args.TemplatePackages);
Assert.Contains("source", args.TemplatePackages);
}
private void OnInitWorkArea()
{
_isWorkAreaIniting = true;
NewCommand.RaiseCanExecuteChanged();
OpenCommand.RaiseCanExecuteChanged();
SaveAllCommand.RaiseCanExecuteChanged();
//Work Area
var selectedTab = XamlTabs.FirstOrDefault(tab => tab.IsSelected);
selectedTab?.InitWorkArea();
_isWorkAreaIniting = false;
NewCommand.RaiseCanExecuteChanged();
OpenCommand.RaiseCanExecuteChanged();
SaveAllCommand.RaiseCanExecuteChanged();
}
public void adds_in_the_testing_request_if_app_and_tests_are_selected()
{
var input = new NewCommandInput
{
SolutionName = "NewThing",
AppFlag = true,
TestsFlag = true
};
var request = NewCommand.BuildTemplateRequest(input);
var testingRequest = request.TestingProjects.Single();
testingRequest.ShouldNotBeNull();
testingRequest.OriginalProject.ShouldEqual("NewThing");
testingRequest.Name.ShouldEqual("NewThing.Testing");
testingRequest.Template.ShouldEqual("baseline");
testingRequest.Alterations.Single().ShouldEqual("unit-testing");
}
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 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 void When_dotnet_new_is_invoked_mupliple_times_it_should_fail()
{
var rootPath = TestAssets.CreateTestDirectory().FullName;
new NewCommand()
.WithWorkingDirectory(rootPath)
.Execute($"console --debug:ephemeral-hive --no-restore");
DateTime expectedState = Directory.GetLastWriteTime(rootPath);
var result = new NewCommand()
.WithWorkingDirectory(rootPath)
.ExecuteWithCapturedOutput($"console --debug:ephemeral-hive --no-restore");
DateTime actualState = Directory.GetLastWriteTime(rootPath);
Assert.Equal(expectedState, actualState);
result.Should().Fail();
}
/// <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);
}
}
}
private void OnToolbarClick(object sender, ToolbarButtonClickEventArgs e)
{
switch (e.ClickedButton)
{
case ToolbarButton.New:
NewCommand?.TryExecute();
break;
case ToolbarButton.Delete:
DeleteCommand?.TryExecute();
break;
case ToolbarButton.Select:
StartSelectionCommand?.TryExecute();
break;
case ToolbarButton.Refresh:
RefreshCommand?.TryExecute();
break;
case ToolbarButton.Cancel:
CancelSelectionCommand?.TryExecute();
break;
}
}
public vm_PutBag()
: base()
{
ActionCommand = new NewCommand(this);
Load();
}
public vm_RoomList()
: base()
{
ActionCommand = new NewCommand(this);
}
public vm_RemarkingEdit()
: base()
{
ActionMenuService.SetAction(null, null, null, ActionCommand, ActionCommand);
PageNavigationService.GoBacked += PageNavigationService_GoBacked;
ActionCommand = new NewCommand(this);
Load();
}
