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