public void FilterByOption_filters_by_roles_if_specified(params ProjectRole[] roles)
{
var projects = new[]
{
SampleProjects.Backend,
SampleProjects.XunitTests
};
var expectedFilteredProjects = Array.Empty <Project>();
_projectFilterMock.Setup(m => m.FilterByRoles(projects, roles))
.Returns(expectedFilteredProjects);
_projectFilterMock.Setup(m => m.FilterByOptional(expectedFilteredProjects))
.Returns(expectedFilteredProjects);
var projectManager = CreateProjectManager();
var options = TestOptions.Create();
options.Roles = roles;
var filteredProjects = projectManager.FilterByOptions(projects, options);
Assert.Empty(filteredProjects);
_projectFilterMock.VerifyAll();
}
public void FilterByOptions_filters_by_exclusions_if_specified()
{
var projects = new[]
{
SampleProjects.Backend
};
var exclusions = new List <string> {
"Backend"
};
var options = TestOptions.Create();
options.Exclude = exclusions;
var expectedFilteredProjects = Array.Empty <Project>();
_projectFilterMock.Setup(m => m.FilterByExclusions(projects, exclusions))
.Returns(expectedFilteredProjects);
_projectFilterMock.Setup(m => m.FilterByOptional(expectedFilteredProjects))
.Returns(expectedFilteredProjects);
var projectManager = CreateProjectManager();
var filteredProjects = projectManager.FilterByOptions(projects, options);
Assert.Empty(filteredProjects);
_projectFilterMock.VerifyAll();
}
public async Task Start_creates_an_AppProcess_for_every_path_in_Project(int pathCount)
{
var appCollection = SampleProjects.AppCollection;
appCollection.Paths = appCollection.Paths.Take(pathCount).ToList();
var config = new RegiConfig
{
Projects = new List <Project> {
appCollection
}
};
_dotnetServiceMock.Setup(m => m.Start(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Project p, string s, CommandOptions o, CancellationToken c) => new AppProcess(new Process(), AppTask.Start, AppStatus.Success, p?.Port))
//.Returns<Project, string, RegiOptions>((p, path, o) => new AppProcess(new Process(), AppTask.Start, AppStatus.Success, p?.Port))
.Verifiable();
_nodeServiceMock.Setup(m => m.Start(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.Throws(new System.Exception("Should not be called"));
var projects = await _runnerService.StartAsync(config.Projects, TestOptions.Create(), CancellationToken.None);
Assert.Equal(pathCount, _queueService.AsyncActions.Count);
_dotnetServiceMock.Verify(m => m.Start(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()), Times.Exactly(pathCount));
var project = Assert.Single(projects);
Assert.Equal(pathCount, project.Processes.Count);
}
public void FilterByOptions_filters_by_name_if_specified()
{
var projects = new[]
{
SampleProjects.Backend
};
var options = TestOptions.Create();
options.Name = "foo";
var expectedFilteredProjects = Array.Empty <Project>();
_projectFilterMock.Setup(m => m.FilterByName(projects, "foo"))
.Returns(expectedFilteredProjects);
_projectFilterMock.Setup(m => m.FilterByOptional(expectedFilteredProjects))
.Returns(expectedFilteredProjects);
var projectManager = CreateProjectManager();
var filteredProjects = projectManager.FilterByOptions(projects, options);
Assert.Empty(filteredProjects);
_projectFilterMock.VerifyAll();
}
public static void Construct_Throws_ArgumentNullException_WhenGivenNullTemplateNameSource()
{
// Arrange
var options = new TemplateProviderOptions();
var iOptions = TestOptions.Create(options);
var templates = Mock.Of <IEnumerable <ITemplateRegistration> >(MockBehavior.Strict);
var paramName = "templateNameSource";
var tests = new Action[]
{
() => new TemplateProvider(null, templates, options),
() => new TemplateProvider(null, templates, iOptions.Object)
};
// Act
// Assert
using (new AssertionScope())
{
foreach (var test in tests)
{
test.Should().Throw <ArgumentNullException>()
.Which.ParamName.Should().Be(paramName);
}
}
}
public async Task Build_will_build_every_project_for_given_framework()
{
var backend = SampleProjects.Backend;
var frontend = SampleProjects.Frontend;
var projects = new[] { backend, frontend };
var options = TestOptions.Create();
var backendDirectoryPaths = backend.GetAppDirectoryPaths(_fileSystem);
var backendBuildProccess = new AppProcess(new Process(), AppTask.Build, AppStatus.Success);
_dotnetServiceMock.Setup(m => m.Build(backend, backendDirectoryPaths[0], options, It.IsAny <CancellationToken>()))
.ReturnsAsync(backendBuildProccess)
.Verifiable();
var frontendDirectoryPaths = frontend.GetAppDirectoryPaths(_fileSystem);
var frontendBuildProcess = new AppProcess(new Process(), AppTask.Build, AppStatus.Success);
_nodeServiceMock.Setup(m => m.Build(frontend, frontendDirectoryPaths[0], options, It.IsAny <CancellationToken>()))
.ReturnsAsync(frontendBuildProcess)
.Verifiable();
var output = await _runnerService.BuildAsync(projects, options, CancellationToken.None);
Assert.Same(backend, output[0]);
Assert.Same(backendBuildProccess, output[0].Processes.First());
Assert.Same(frontend, output[1]);
Assert.Same(frontendBuildProcess, output[1].Processes.First());
_dotnetServiceMock.Verify();
_nodeServiceMock.Verify();
}
public async Task TestProject_will_return_test_for_path_pattern_and_expected_status(string pathPattern, AppStatus expectedStatus)
{
AppProcess test = await _service.Test(_application, _application.GetAppDirectoryPaths(_fileSystem)
[0], TestOptions.Create(null, pathPattern), CancellationToken.None);
Assert.Equal(AppTask.Test, test.Task);
Assert.Equal(expectedStatus, test.Status);
}
public void CreateProcess_handles_error_data_regardless_of_verbosity(bool isVerbose)
{
var service = new WumboService(_console);
var options = TestOptions.Create();
options.Verbose = isVerbose;
var process = service.CreateProcess(FrameworkCommands.DotnetCore.Run, SampleProjects.Backend, SampleProjects.Backend.GetAppDirectoryPaths(_fileSystem)[0], options, "dotnet");
Assert.True(process.ErrorDataHandled);
}
public async Task Install_will_not_install_a_dependency_if_it_has_already_been_installed_as_another_project_dependency()
{
var app = SampleProjects.Backend;
var test1 = SampleProjects.XunitTests;
test1.Name = "Test1";
test1.Requires = new List <string> {
app.Name
};
var test2 = SampleProjects.XunitTests;
test2.Name = "Test2";
test2.Requires = new List <string> {
app.Name
};
var options = TestOptions.Create();
options.NoParallel = true;
options.Roles = test1.Roles;
var config = new RegiConfig
{
Projects = new List <Project> {
app, test1, test2
},
};
ProjectManager.LinkProjectRequirements(config.Projects, options, config);
_frameworkServiceProviderMock.Setup(m => m.CreateScopedQueueService())
.Returns(() => new TestQueueService(_console))
.Verifiable();
_dotnetServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
var outputProjects = await _runnerService.InstallAsync(config.Projects, options, CancellationToken.None);
Assert.Equal(3, outputProjects.Count); // app, test1, test2
var appProcess = outputProjects[0].Processes.ElementAt(0);
var test1RequiredProcess = outputProjects[1].RequiredProjects.ElementAt(0).Processes.ElementAt(0);
var test2RequiredProcess = outputProjects[2].RequiredProjects.ElementAt(0).Processes.ElementAt(0);
Assert.Same(appProcess, test1RequiredProcess);
Assert.Same(appProcess, test2RequiredProcess);
_frameworkServiceProviderMock.Verify();
_dotnetServiceMock.Verify(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()), Times.Exactly(3));
}
public async Task Test_also_starts_every_requirement_for_each_test()
{
TestQueueService dependencyQueueService = new TestQueueService(_console);
var tests = SampleProjects.ConfigurationDefault.Projects;
ProjectManager.LinkProjectRequirements(tests, TestOptions.Create(), SampleProjects.ConfigurationDefault);
_frameworkServiceProviderMock.Setup(m => m.CreateScopedQueueService())
.Returns(dependencyQueueService)
.Verifiable();
_nodeServiceMock.Setup(m => m.Test(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Test, AppStatus.Success))
.Verifiable();
_nodeServiceMock.Setup(m => m.Start(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Start, AppStatus.Success))
.Verifiable();
_dotnetServiceMock.Setup(m => m.Test(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Test, AppStatus.Success))
.Verifiable();
_dotnetServiceMock.Setup(m => m.Start(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Start, AppStatus.Success))
.Verifiable();
var projects = await _runnerService.TestAsync(tests, TestOptions.Create(), CancellationToken.None);
Assert.Equal(tests.Count, projects.Count);
foreach (var project in projects)
{
var process = Assert.Single(project.Processes);
Assert.Equal(AppTask.Test, process.Task);
if (project.Requires?.Count > 0)
{
Assert.Equal(project.Requires.Count, project.RequiredProjects.Count);
foreach (var requirement in project.Requires)
{
var requiredApp = Assert.Single(project.RequiredProjects, p => p.Name == requirement);
var requiredAppProcess = Assert.Single(requiredApp.Processes);
Assert.Equal(AppTask.Start, requiredAppProcess.Task);
Assert.Contains(requiredApp.Port.Value, _queueService.ActivePorts); // Waited on during InternalStart
Assert.Contains(requiredApp.Port.Value, dependencyQueueService.ActivePorts); // Waited on after starting Test dependencies
}
}
}
_frameworkServiceProviderMock.Verify();
_dotnetServiceMock.VerifyAll();
_nodeServiceMock.VerifyAll();
}
public async Task Test_adds_serial_projects_to_serial_queue_and_all_others_to_async_queue()
{
_dotnetServiceMock.Setup(m => m.Test(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Project p, string d, CommandOptions o, CancellationToken c) => new AppProcess(new Process(), AppTask.Start, AppStatus.Success, p?.Port))
.Verifiable();
var testsProjects = SampleProjects.ConfigurationGood.Projects.WhereTest().ToList();
var processes = await _runnerService.TestAsync(testsProjects, TestOptions.Create(), CancellationToken.None);
Assert.Single(_queueService.AsyncActions);
Assert.Single(_queueService.SerialActions);
}
public async Task Test_returns_a_project_for_every_test_in_startup_config()
{
_dotnetServiceMock.Setup(m => m.Test(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Project p, string d, CommandOptions o, CancellationToken c) => new AppProcess(new Process(), AppTask.Start, AppStatus.Success, p?.Port))
.Verifiable();
var testsProjects = SampleProjects.ConfigurationGood.Projects.WhereTest().ToList();
var processes = await _runnerService.TestAsync(testsProjects, TestOptions.Create(), CancellationToken.None);
Assert.Equal(testsProjects.Count, processes.Count);
_dotnetServiceMock.VerifyAll();
}
public async Task RunProject_changes_status_from_running_to_success_on_exit()
{
var options = TestOptions.Create();
AppProcess process = await _service.Start(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], options, CancellationToken.None);
Assert.Equal(AppStatus.Running, process.Status);
await process.WaitForExitAsync(CancellationToken.None);
Assert.Equal(AppStatus.Success, process.Status);
CleanupApp(process);
}
public async Task ShutdownBuildServer_shuts_down_all_build_servers()
{
_fileSystem.WorkingDirectory = PathHelper.RegiTestRootPath;
var process = await _service.ShutdownBuildServer(TestOptions.Create(), CancellationToken.None);
Assert.Equal(AppStatus.Success, process.Status);
Assert.Equal(AppTask.Cleanup, process.Task);
var startInfo = process.Process.StartInfo;
Assert.Contains("dotnet", startInfo.FileName, StringComparison.InvariantCulture);
Assert.Equal(FrameworkCommands.DotnetCore.ShutdownBuildServer, startInfo.Arguments);
}
public async Task KillProcesses_kills_all_dotnet_processes(bool isWindows, string expectedFileName, string expectedArguments)
{
_runtimeInfoMock.Setup(m => m.IsWindows).Returns(isWindows).Verifiable();
AppProcess process = await _service.Kill(TestOptions.Create(), CancellationToken.None);
Assert.Equal(AppStatus.Success, process.Status);
Assert.Equal(AppTask.Kill, process.Task);
var startInfo = process.Process.StartInfo;
Assert.Equal(expectedFileName, startInfo.FileName);
Assert.Equal(expectedArguments, startInfo.Arguments);
_runtimeInfoMock.Verify();
}
public void CreateProcess_does_not_handle_output_data_if_project_is_not_in_show_output()
{
var service = new WumboService(_console);
var options = TestOptions.Create();
options.Verbose = false;
options.ShowOutput = new List <string> {
"Wumbo"
};
var process = service.CreateProcess(FrameworkCommands.DotnetCore.Run, SampleProjects.Backend, SampleProjects.Backend.GetAppDirectoryPaths(_fileSystem)[0], options, "dotnet");
Assert.False(process.OutputDataHandled);
}
public async Task Kill_calls_service_to_kill_for_each_ProjectFramework()
{
_nodeServiceMock.Setup(m => m.Kill(It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(null, AppTask.Kill, AppStatus.Success))
.Verifiable();
_dotnetServiceMock.Setup(m => m.Kill(It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(null, AppTask.Kill, AppStatus.Success))
.Verifiable();
var projects = SampleProjects.ConfigurationGood.Projects.Concat(SampleProjects.ConfigurationGood.Projects).ToList();
var options = TestOptions.Create();
await _runnerService.KillAsync(projects, options, CancellationToken.None);
_nodeServiceMock.Verify(m => m.Kill(options, CancellationToken.None), Times.Once);
_dotnetServiceMock.Verify(m => m.Kill(options, CancellationToken.None), Times.Once);
}
public async Task Build_will_build_async_by_default()
{
var projects = new[] { SampleProjects.Backend, SampleProjects.Backend };
var options = TestOptions.Create();
_dotnetServiceMock.Setup(m => m.Build(It.IsAny <Project>(), It.IsAny <string>(), options, It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Build, AppStatus.Success))
.Verifiable();
await _runnerService.BuildAsync(projects, options, CancellationToken.None);
Assert.Equal(projects.Length, _queueService.AsyncActions.Count);
Assert.Empty(_queueService.SerialActions);
_dotnetServiceMock.Verify();
}
public async Task ShutdownBuildServers_shuts_down_dotnet_build_servers()
{
var options = TestOptions.Create();
var dotnetShutdownBuildServer = new AppProcess(new Process(), AppTask.Cleanup, AppStatus.Success);
_dotnetServiceMock.Setup(m => m.ShutdownBuildServer(options, It.IsAny <CancellationToken>()))
.ReturnsAsync(dotnetShutdownBuildServer)
.Verifiable();
var service = CreateService();
var processes = await service.ShutdownBuildServers(options, CancellationToken.None);
Assert.Equal(1, processes.Count);
Assert.Same(dotnetShutdownBuildServer, processes[0]);
}
public async Task Start_runs_simple_script_before_starting_if_they_are_specified()
{
var configuration = SampleProjects.ConfigurationGood;
configuration.Projects[0].Scripts = new CommandDictionary <object>
{
{ "start", new List <object> {
"foo bar -v"
} }
};
_platformServiceMock.Setup(m => m.RunAnonymousScript("foo bar -v", It.IsAny <CommandOptions>(), null))
.Verifiable();
var processes = await _runnerService.StartAsync(configuration.Projects, TestOptions.Create(), CancellationToken.None);
_platformServiceMock.Verify();
}
public void PrintDomainSummary_prints_optional_projects_even_if_include_optional_is_not_specified()
{
var service = CreateService();
var config = SampleProjects.ConfigurationGood;
foreach (var app in config.Projects)
{
app.Optional = true;
}
var output = service.PrintDomainSummary(config, TestOptions.Create());
Assert.Equal(SampleProjects.ConfigurationGood.Projects.Count, output.Projects.Count);
Assert.Contains("Projects:", _console.LogOutput, StringComparison.InvariantCulture);
Assert.Equal(config.Projects.Count, new Regex("(Optional)").Matches(_console.LogOutput).Count);
}
public async Task Start_does_not_run_script_if_it_is_not_string_or_app_script()
{
var configuration = SampleProjects.ConfigurationGood;
configuration.Projects[0].Scripts = new CommandDictionary <object>
{
{ "start", new List <object> {
new { Foo = "Bar" }
} }
};
_platformServiceMock.Setup(m => m.RunAnonymousScript(It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <string>()))
.Throws(new Exception("This should not be called"));
var processes = await _runnerService.StartAsync(configuration.Projects, TestOptions.Create(), CancellationToken.None);
_platformServiceMock.Verify();
}
public void CreateProcess_handles_output_data_only_in_verbose_mode(bool isVerbose)
{
var service = new WumboService(_console);
var options = TestOptions.Create();
options.Verbose = isVerbose;
var process = service.CreateProcess(FrameworkCommands.DotnetCore.Run, SampleProjects.Backend, SampleProjects.Backend.GetAppDirectoryPaths(_fileSystem)[0], options, "dotnet");
if (isVerbose)
{
Assert.True(process.OutputDataHandled);
}
else
{
Assert.False(process.OutputDataHandled);
}
}
public async Task Install_will_also_install_for_any_required_dependencies()
{
TestQueueService dependencyQueueService = new TestQueueService(_console);
_frameworkServiceProviderMock.Setup(m => m.CreateScopedQueueService())
.Returns(dependencyQueueService)
.Verifiable();
_dotnetServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
_nodeServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
var options = TestOptions.Create();
var projects = new List <Project> {
SampleProjects.IntegrationTests
};
ProjectManager.LinkProjectRequirements(projects, options, SampleProjects.ConfigurationDefault);
var outputProjects = await _runnerService.InstallAsync(projects, options, CancellationToken.None);
var integrationTestProject = Assert.Single(outputProjects);
Assert.Equal(2, integrationTestProject.RequiredProjects.Count);
var dotnetApp = Assert.Single(integrationTestProject.RequiredProjects, p => p.Framework == ProjectFramework.Dotnet);
Assert.Equal(AppTask.Install, dotnetApp.Processes.First().Task);
Assert.Equal(AppStatus.Success, dotnetApp.OutputStatus);
var nodeApp = Assert.Single(integrationTestProject.RequiredProjects, p => p.Framework == ProjectFramework.Node);
Assert.Equal(AppTask.Install, nodeApp.Processes.First().Task);
Assert.Equal(AppStatus.Success, nodeApp.OutputStatus);
_frameworkServiceProviderMock.Verify();
_dotnetServiceMock.Verify();
_nodeServiceMock.Verify();
}
public async Task Test_requirements_with_multiple_paths_will_start_every_path()
{
var dependencyQueue = new TestQueueService(_console);
var appCollection = SampleProjects.AppCollection;
var testProject = SampleProjects.XunitTests;
testProject.Requires = new List <string> {
appCollection.Name
};
testProject.RequiredProjects.Add(appCollection);
_dotnetServiceMock.Setup(m => m.Test(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Test, AppStatus.Success))
.Verifiable();
_frameworkServiceProviderMock.Setup(m => m.CreateScopedQueueService())
.Returns(dependencyQueue)
.Verifiable();
foreach (var path in SampleProjects.AppCollection.Paths)
{
_dotnetServiceMock.Setup(m => m.Start(appCollection, It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Start, AppStatus.Running))
.Verifiable();
}
var projects = await _runnerService.TestAsync(new List <Project> {
testProject
}, TestOptions.Create(), CancellationToken.None);
var actualTestProject = Assert.Single(projects);
Assert.Same(testProject, actualTestProject);
Assert.Single(testProject.Processes);
var requiredProject = Assert.Single(testProject.RequiredProjects);
Assert.Same(appCollection, requiredProject);
Assert.Equal(3, requiredProject.Processes.Count);
Assert.Equal(3, dependencyQueue.AsyncActions.Count);
_dotnetServiceMock.Verify();
_frameworkServiceProviderMock.Verify();
}
public async Task Start_runs_app_script_in_working_directory_before_starting_if_they_are_specified()
{
string workingDirectory = PathHelper.GetSampleProjectPath("ConfigurationGood");
var configuration = SampleProjects.ConfigurationGood;
configuration.Projects[0].Scripts = new CommandDictionary <object>
{
{ "start", new List <object> {
new AppScript("foo bar -v", workingDirectory)
} }
};
_platformServiceMock.Setup(m => m.RunAnonymousScript("foo bar -v", It.IsAny <CommandOptions>(), workingDirectory))
.Verifiable();
var processes = await _runnerService.StartAsync(configuration.Projects, TestOptions.Create(), CancellationToken.None);
_platformServiceMock.Verify();
}
public async Task Install_returns_a_process_for_every_app_and_test_project()
{
_dotnetServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
_nodeServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
var projects = SampleProjects.ConfigurationGood.Projects
.ToList();
var processes = await _runnerService.InstallAsync(projects, TestOptions.Create(), CancellationToken.None);
int appsCount = SampleProjects.ConfigurationGood.Projects.Count;
Assert.Equal(appsCount, processes.Count);
_dotnetServiceMock.VerifyAll();
}
public void FilterByOptions_does_not_exclude_optional_projects_if_include_optional_is_specified()
{
var optionalProject = new Project
{
Optional = true
};
var options = TestOptions.Create();
options.IncludeOptional = true;
var projectManager = CreateProjectManager();
var filteredProjects = projectManager.FilterByOptions(new List <Project> {
optionalProject
}, options);
Assert.NotEmpty(filteredProjects);
_projectFilterMock.Verify(m => m.FilterByOptional(It.IsAny <IEnumerable <Project> >()), Times.Never);
_projectFilterMock.VerifyAll();
}
public async Task CreateStartupConfig_sorts_projects_into_categories(int appCount, int testCount)
{
var projects = new List <Project>();
for (int i = 0; i < appCount; i++)
{
projects.Add(SampleProjects.Backend);
}
for (int i = 0; i < testCount; i++)
{
projects.Add(SampleProjects.XunitTests);
}
var service = CreateService();
var config = await service.CreateConfigurationAsync(projects, TestOptions.Create());
Assert.Equal(appCount + testCount, config.Projects.Count);
Assert.Equal(appCount, config.Projects.Count(p => p.Name == SampleProjects.Backend.Name));
Assert.Equal(testCount, config.Projects.Count(p => p.Name == SampleProjects.XunitTests.Name));
}
public async Task Install_sets_package_repo_to_value_configured_startup_file()
{
var projects = SampleProjects.ConfigurationGood.Projects;
ProjectManager.LinkProjectRequirements(projects, TestOptions.Create(), SampleProjects.ConfigurationGood);
_dotnetServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
_nodeServiceMock.Setup(m => m.Install(It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AppProcess(new Process(), AppTask.Install, AppStatus.Success))
.Verifiable();
var processes = await _runnerService.InstallAsync(projects, TestOptions.Create(), CancellationToken.None);
var dotnetApp = Assert.Single(processes, p => p.Framework == ProjectFramework.Dotnet && p.Roles.Contains(ProjectRole.App) && p.Port.HasValue);
var nodeApp = Assert.Single(processes, p => p.Framework == ProjectFramework.Node && p.Roles.Contains(ProjectRole.App) && p.Port.HasValue);
Assert.Equal("http://nuget.org/api", dotnetApp.Source);
Assert.Equal("http://npmjs.org", nodeApp.Source);
}
