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 RunnerServiceTests(ITestOutputHelper output)
{
_frameworkServiceProviderMock.Setup(m => m.GetFrameworkService(ProjectFramework.Dotnet))
.Returns(_dotnetServiceMock.Object);
_frameworkServiceProviderMock.Setup(m => m.GetFrameworkService(ProjectFramework.Node))
.Returns(_nodeServiceMock.Object);
_console = new TestConsole(output);
_queueService = new TestQueueService(_console);
_runnerService = new RunnerService(
new ProjectManager(_console, new Mock <ICleanupService>().Object, new ProjectFilter()),
_frameworkServiceProviderMock.Object,
_queueService,
_networkingServiceMock.Object,
_platformServiceMock.Object,
_fileSystem,
_console);
}
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 Install_will_not_install_a_dependency_if_it_is_also_a_top_level_filtered_project()
{
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 projects = SampleProjects.ConfigurationDefault.Projects;
ProjectManager.LinkProjectRequirements(projects, TestOptions.Create(), SampleProjects.ConfigurationDefault);
var outputProjects = await _runnerService.InstallAsync(projects, TestOptions.Create(), CancellationToken.None);
var allAppsAndTests = SampleProjects.ConfigurationDefault.Projects;
Assert.Equal(allAppsAndTests.Count, outputProjects.Count);
foreach (var project in outputProjects)
{
if (project.RequiredProjects.Any())
{
foreach (var requiredProject in project.RequiredProjects)
{
Assert.Empty(requiredProject.Processes);
}
}
}
_frameworkServiceProviderMock.Verify();
_dotnetServiceMock.Verify();
_nodeServiceMock.Verify();
}
