public void InitialisationProcess_ShouldForceVsTestIfIsTestProjectSetFalseAndFullFramework()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkString = "net4.5",
ProjectFilePath = testProjectPath,
Properties = new ReadOnlyDictionary <string, string>(new Dictionary <string, string> {
{ "IsTestProject", "false" }
}),
References = new string[0]
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var options = new StrykerOptions(fileSystem: fileSystem, basePath: _basePath);
target.ResolveInput(options);
options.TestRunner.ShouldBe(TestRunner.VsTest);
}
public void InputFileResolver_InitializeShouldCrawlFiles()
{
string projectFile = @"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""..\ExampleProject\ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(_sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "TestProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") }
});
var target = new InputFileResolver(fileSystem);
var result = target.ResolveInput(Path.Combine(_filesystemRoot, "TestProject"), "", new List <string>());
result.TestProjectPath.ShouldBe(Path.Combine(_filesystemRoot, "TestProject"));
}
public void ShouldSetToVsTestOnIsTestProjectAndNetClassic()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFramework = Framework.NetClassic,
ProjectFilePath = testProjectPath,
Properties = new Dictionary <string, string> {
{ "IsTestProject", "false" }
},
References = new string[] { "" }
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var options = new StrykerOptions(fileSystem: fileSystem, basePath: _basePath, testRunner: "dotnettest");
target.ResolveInput(options);
options.TestRunner.ShouldBe(TestRunner.VsTest);
}
public void InputFileResolver_ShouldThrowStrykerInputExceptionOnTwoProjectFiles_AndNoTestProjectFileSpecified()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject2.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkString = "netcore2.1",
ProjectFilePath = testProjectPath
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var errorMessage =
$@"Expected exactly one .csproj file, found more than one:
{Path.GetFullPath("/ExampleProject/ExampleProject.csproj")}
{Path.GetFullPath("/ExampleProject/ExampleProject2.csproj")}
Please specify a test project name filter that results in one project.
";
var exception = Assert.Throws <StrykerInputException>(() => target.FindProjectFile(Path.Combine(_filesystemRoot, "ExampleProject"), "*.csproj"));
exception.Message.ShouldBe(errorMessage);
}
public void InputFileResolver_InitializeShouldIgnoreBinFolder(string folderName)
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "TestProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", folderName, "somecsharpfile.cs"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", folderName, "subfolder", "somecsharpfile.cs"), new MockFileData("Bytecode") },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
result.ProjectContents.Children.Count.ShouldBe(1);
}
public void InputFileResolver_ShouldThrowStrykerInputExceptionOnTwoProjectFiles()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject2.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFramework = "netcore2.1",
ProjectFilePath = testProjectPath
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
Assert.Throws <StrykerInputException>(() => target.ScanProjectFile(Path.Combine(_filesystemRoot, "ExampleProject")));
}
public void InitialisationProcess_ShouldThrowOnMsTestV1Detected()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "Microsoft.VisualStudio.QualityTools.UnitTestFramework" }
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
Assert.Throws <StrykerInputException>(() => target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath)));
}
public void ShouldThrowOnMsTestV1Detected()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "Microsoft.VisualStudio.QualityTools.UnitTestFramework" }
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var ex = Assert.Throws <StrykerInputException>(() => target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath)));
ex.Message.ShouldBe("Please upgrade to MsTest V2. Stryker.NET uses VSTest which does not support MsTest V1.");
ex.Details.ShouldBe(@"See https://devblogs.microsoft.com/devops/upgrade-to-mstest-v2/ for upgrade instructions.");
}
public void InputFileResolver_ShouldThrowStrykerInputExceptionOnTwoProjectFiles()
{
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""..\ExampleProject\ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject2.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem);
var exception = Assert.Throws <StrykerInputException>(() => target.ScanProjectFile(Path.Combine(_filesystemRoot, "ExampleProject")));
}
public void InitializeShouldThrowIfImportPropertyCannotBeResolved()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/TestResources/ExampleSourceFile.cs");
string sharedFile = "<Project />";
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../$(SharedDir)/Example.projitems"" Label=""Shared"" />
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject", "Example.projitems"), new MockFileData(sharedFile) },
{ Path.Combine(_filesystemRoot, "SharedProject", "Shared.cs"), new MockFileData(sourceFile) },
{ projectUnderTestPath, new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
Properties = new Dictionary <string, string>(),
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var exception = Assert.Throws <StrykerInputException>(() => target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath)));
exception.Message.ShouldBe($"Missing MSBuild property (SharedDir) in project reference (..{FilePathUtils.NormalizePathSeparators("/$(SharedDir)/Example.projitems")}). Please check your project file ({projectUnderTestPath}) and try again.");
}
public void InputFileResolver_InitializeShouldNotResolveImportedPropsFile()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/TestResources/ExampleSourceFile.cs");
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../NonSharedProject/Example.props"" Label=""Shared"" />
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "NonSharedProject", "Example.props"), new MockFileData("") },
{ Path.Combine(_filesystemRoot, "NonSharedProject", "NonSharedSource.cs"), new MockFileData(sourceFile) },
{ projectUnderTestPath, new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
Properties = new Dictionary <string, string>(),
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
Properties = new Dictionary <string, string>()
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
result.ProjectContents.GetAllFiles().Count().ShouldBe(2);
}
public void InputFileResolver_InitializeShouldThrowOnMissingSharedProject()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/TestResources/ExampleSourceFile.cs");
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../SharedProject/Example.projitems"" Label=""Shared"" />
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject", "Shared.cs"), new MockFileData(sourceFile) },
{ projectUnderTestPath, new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFramework = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
Properties = new Dictionary <string, string>(),
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFramework = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
Properties = new Dictionary <string, string>(),
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
Assert.Throws <FileNotFoundException>(() => target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath)));
}
public void InputFileResolver_InitializeShouldThrowOnMissingSharedProject()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/Initialisation/TestResources/ExampleSourceFile.cs");
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../SharedProject/Example.projitems"" Label=""Shared"" />
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
string testProjectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject", "Shared.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "TestProject.csproj"), new MockFileData(testProjectFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var target = new InputFileResolver(fileSystem);
Assert.Throws <FileNotFoundException>(() =>
target.ResolveInput(Path.Combine(_filesystemRoot, "TestProject"), ""));
}
public void InputFileResolver_ShouldThrowExceptionOnNoProjectFile()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem);
var exception = Assert.Throws <StrykerInputException>(() => target.ScanProjectFile(Path.Combine(_filesystemRoot, "ExampleProject")));
}
public void InputFileResolver_ShouldThrowExceptionOnNoProjectFile()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ @"c:\ExampleProject\Recursive.cs", new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem);
var exception = Assert.Throws <FileNotFoundException>(() => target.ScanProjectFile(@"c:\ExampleProject"));
}
public void InputFileResolver_ShouldThrowExceptionIfGivenTestFileDoesNotExist()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "AlternateProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem, null);
var exception = Assert.Throws <StrykerInputException>(() => target.FindProjectFile(Path.Combine(_filesystemRoot, "ExampleProject"), "GivenTestProject.csproj"));
exception.Message.ShouldStartWith("No .csproj file found, please check your project directory at");
}
public void ShouldChooseGivenTestProjectFileIfPossible()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "TestProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem, null);
var actual = target.FindProjectFile(Path.Combine(_filesystemRoot, "ExampleProject"), "TestProject.csproj");
actual.ShouldBe(Path.Combine(_filesystemRoot, "ExampleProject", "TestProject.csproj"));
}
public void InputFileResolver_ShouldChooseGivenTestProjectFileIfPossible_AtRelativeLocation()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "SubFolder", "TestProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem, null);
var actual = target.FindProjectFile(Path.Combine(_filesystemRoot, "ExampleProject"), FilePathUtils.NormalizePathSeparators("SubFolder/TestProject.csproj"));
actual.ShouldBe(Path.Combine(_filesystemRoot, "ExampleProject", "SubFolder", "TestProject.csproj"));
}
public void InputFileResolver_InitializeShouldFindSpecifiedTestProjectFile()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ alternateTestProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(alternateTestProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = alternateTestProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath, testProjectNameFilter: "AlternateTestProject.csproj"));
result.ProjectContents.GetAllFiles().Count().ShouldBe(2);
}
public void InputFileResolver_ShouldNotThrowExceptionOnTwoProjectFilesInDifferentLocations()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject\\ExampleProject2", "ExampleProject2.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData("content") }
});
var target = new InputFileResolver(fileSystem, null);
var actual = target.FindProjectFile(Path.Combine(_filesystemRoot, "ExampleProject"), "*.csproj");
actual.ShouldBe(Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"));
}
public void ShouldFindAllTestProjects()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "myFile.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject1", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject2", "ExampleProject.csproj"), new MockFileData(defaultTestProjectFileContents) },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkVersionString = "netcore2.1",
ProjectFilePath = Path.Combine(_filesystemRoot, "TestProject1", "ExampleProject.csproj"),
References = new string[0]
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
""
},
TargetFrameworkVersionString = "netcore2.1",
ProjectFilePath = Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"),
References = new string[0]
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var options = new StrykerOptions(fileSystem: fileSystem, basePath: Path.Combine(_filesystemRoot, "ExampleProject"), testProjects: new List <string>
{
Path.Combine(_filesystemRoot, "TestProject1", "ExampleProject.csproj"),
Path.Combine(_filesystemRoot, "TestProject2", "ExampleProject.csproj")
});
var result = target.ResolveInput(options);
result.ProjectContents.GetAllFiles().Count().ShouldBe(1);
}
public void InitializeShouldUseBuildAlyzerResult()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Plain.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "bin", "Debug", "netcoreapp2.1"), new MockFileData("Bytecode") }, // bin should be excluded
{ Path.Combine(_filesystemRoot, "ExampleProject", "obj", "Debug", "netcoreapp2.1", "ExampleProject.AssemblyInfo.cs"), new MockFileData("Bytecode") }, // obj should be excluded
{ Path.Combine(_filesystemRoot, "ExampleProject", "obj", "Release", "netcoreapp2.1"), new MockFileData("Bytecode") }, // obj should be excluded
{ Path.Combine(_filesystemRoot, "ExampleProject", "node_modules", "Some package"), new MockFileData("bla") }, // node_modules should be excluded
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
SourceFiles = fileSystem.AllFiles.Where(s => s.EndsWith(".cs"))
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
result.ProjectContents.GetAllFiles().Count().ShouldBe(3);
}
public void Stryker_FsharpShouldRetrieveSourcefiles()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ _projectUnderTestPath, new MockFileData(_defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.fs"), new MockFileData(_sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.fs"), new MockFileData(_sourceFile) },
{ _testProjectPath, new MockFileData(_defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") }, // bin should be excluded
{ Path.Combine(_filesystemRoot, "ExampleProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") }, // obj should be excluded
{ Path.Combine(_filesystemRoot, "ExampleProject", "node_modules", "Some package"), new MockFileData("bla") }, // node_modules should be excluded
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(_testProjectPath, null, "fsharp"))
.Returns(TestHelper.SetupProjectAnalyzerResult(
projectReferences: new List <string>()
{
_projectUnderTestPath
},
targetFramework: "netcoreapp2.1",
projectFilePath: _testProjectPath,
references: new string[] { "" }).Object);
projectFileReaderMock.Setup(x => x.AnalyzeProject(_projectUnderTestPath, null, "fsharp"))
.Returns(TestHelper.SetupProjectAnalyzerResult(
projectReferences: new List <string>()
{
_projectUnderTestPath
},
targetFramework: "netcoreapp2.1",
projectFilePath: _projectUnderTestPath,
properties: new Dictionary <string, string>()
{
{ "Language", "F#" }
}).Object);
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object, loggerMock.Object);
var result = target.ResolveInput(new StrykerOptions());
result.ProjectContents.GetAllFiles().Count().ShouldBe(2);
}
public void InputFileResolver_InitializeShouldCrawlFilesRecursively()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/Initialisation/TestResources/ExampleSourceFile.cs");
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""..\ExampleProject\ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ @"c:\ExampleProject\ExampleProject.csproj", new MockFileData(projectFile) },
{ @"c:\ExampleProject\Recursive.cs", new MockFileData(sourceFile) },
{ @"c:\ExampleProject\OneFolderDeeper\Recursive.cs", new MockFileData(sourceFile) },
{ @"c:\TestProject\TestProject.csproj", new MockFileData(projectFile) },
{ @"c:\TestProject\bin\Debug\netcoreapp2.0\ExampleProject.dll", new MockFileData("Bytecode") },
{ @"c:\TestProject\obj\Release\netcoreapp2.0\ExampleProject.dll", new MockFileData("Bytecode") },
});
var target = new InputFileResolver(fileSystem);
var result = target.ResolveInput(@"c:\TestProject\", "");
result.TestProjectPath.ShouldBe(@"c:\TestProject\");
result.ProjectContents.Children.Count.ShouldBe(2);
}
public void InputFileResolver_InitializeShouldIgnoreBinFolder(string folderName)
{
// the bin, obj and node_modules folders should be skipped
string sourceFile = File.ReadAllText(_currentDirectory + "/Initialisation/TestResources/ExampleSourceFile.cs");
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""..\ExampleProject\ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "TestProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "TestProject", folderName, "somecsharpfile.cs"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", folderName, "subfolder", "somecsharpfile.cs"), new MockFileData("Bytecode") },
});
var target = new InputFileResolver(fileSystem);
var result = target.ResolveInput(Path.Combine(_filesystemRoot, "TestProject"), "");
result.TestProjectPath.ShouldBe(Path.Combine(_filesystemRoot, "TestProject"));
result.ProjectContents.Children.Count.ShouldBe(1);
}
public void InputFileResolver_InitializeShouldMarkFilesAsExcluded()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive2.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive3.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", "Debug", "somecsharpfile.cs"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "Release", "subfolder", "somecsharpfile.cs"), new MockFileData("Bytecode") }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFramework = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFramework = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath, filesToExclude: new[] { Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs") }));
result.ProjectContents.GetAllFiles().Count(c => c.IsExcluded).ShouldBe(1);
}
public void ShouldSkipXamlFiles()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ projectUnderTestPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "app.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "app.xaml"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "app.xaml.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
result.ProjectContents.GetAllFiles().Count().ShouldBe(2);
}
public void InputFileResolver_InitializeShouldResolveMultipleImportedProjects()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/Initialisation/TestResources/ExampleSourceFile.cs");
string sharedItems = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
<HasSharedItems>true</HasSharedItems>
<SharedGUID>0425a660-ca7d-43f6-93ab-f72c95d506e3</SharedGUID>
</PropertyGroup>
<ItemGroup>
<Compile Include=""$(MSBuildThisFileDirectory)shared.cs"" />
</ItemGroup>
</Project>";
string sharedItems2 = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
<HasSharedItems>true</HasSharedItems>
<SharedGUID>0425a660-ca7d-43f6-93ab-f72c95d506e3</SharedGUID>
</PropertyGroup>
<ItemGroup>
<Compile Include=""$(MSBuildThisFileDirectory)shared.cs"" />
</ItemGroup>
</Project>";
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../SharedProject1/Example.projitems"" Label=""Shared"" />
<Import Project=""../SharedProject2/Example.projitems"" Label=""Shared"" />
</Project>";
string testProjectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=""Microsoft.NET.Test.Sdk"" Version = ""15.5.0"" />
<PackageReference Include=""xunit"" Version=""2.3.1"" />
<PackageReference Include=""xunit.runner.visualstudio"" Version=""2.3.1"" />
<DotNetCliToolReference Include=""dotnet-xunit"" Version=""2.3.1"" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject1", "Example.projitems"), new MockFileData(sharedItems) },
{ Path.Combine(_filesystemRoot, "SharedProject1", "Shared.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "SharedProject2", "Example.projitems"), new MockFileData(sharedItems2) },
{ Path.Combine(_filesystemRoot, "SharedProject2", "Shared.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "ExampleProject.csproj"), new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "TestProject.csproj"), new MockFileData(testProjectFile) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var target = new InputFileResolver(fileSystem);
var result = target.ResolveInput(Path.Combine(_filesystemRoot, "TestProject"), "");
result.TestProjectPath.ShouldBe(Path.Combine(_filesystemRoot, "TestProject"));
result.ProjectContents.GetAllFiles().Count().ShouldBe(4);
}
public void InitializeShouldResolvePropertiesInSharedProjectImports()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/TestResources/ExampleSourceFile.cs");
string sharedFile = "<Project />";
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
<SharedDir>SharedProject</SharedDir>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../$(SharedDir)/Example.projitems"" Label=""Shared"" />
<ItemGroup>
<ProjectReference Include=""../ExampleProject/ExampleProject.csproj"" />
</ItemGroup>
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject", "Example.projitems"), new MockFileData(sharedFile) },
{ Path.Combine(_filesystemRoot, "SharedProject", "Shared.cs"), new MockFileData(sourceFile) },
{ projectUnderTestPath, new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) }
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(testProjectPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkVersionString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
Properties = new Dictionary <string, string>()
{
{ "SharedDir", "SharedProject" },
},
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
var allFiles = result.ProjectContents.GetAllFiles();
allFiles.Count().ShouldBe(3);
allFiles.ShouldContain(f => f.Name == "Shared.cs");
}
public void InputFileResolver_InitializeShouldResolveMultipleImportedProjects()
{
string sourceFile = File.ReadAllText(_currentDirectory + "/TestResources/ExampleSourceFile.cs");
string sharedItems = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
<HasSharedItems>true</HasSharedItems>
<SharedGUID>0425a660-ca7d-43f6-93ab-f72c95d506e3</SharedGUID>
</PropertyGroup>
<ItemGroup>
<Compile Include=""$(MSBuildThisFileDirectory)shared.cs"" />
</ItemGroup>
</Project>";
string sharedItems2 = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
<HasSharedItems>true</HasSharedItems>
<SharedGUID>0425a660-ca7d-43f6-93ab-f72c95d506e3</SharedGUID>
</PropertyGroup>
<ItemGroup>
<Compile Include=""$(MSBuildThisFileDirectory)shared.cs"" />
</ItemGroup>
</Project>";
string projectFile = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
</ItemGroup>
<Import Project=""../SharedProject1/Example.projitems"" Label=""Shared"" />
<Import Project=""../SharedProject2/Example.projitems"" Label=""Shared"" />
</Project>";
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ Path.Combine(_filesystemRoot, "SharedProject1", "Example.projitems"), new MockFileData(sharedItems) },
{ Path.Combine(_filesystemRoot, "SharedProject1", "Shared.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "SharedProject2", "Example.projitems"), new MockFileData(sharedItems2) },
{ Path.Combine(_filesystemRoot, "SharedProject2", "Shared.cs"), new MockFileData(sourceFile) },
{ projectUnderTestPath, new MockFileData(projectFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "Recursive.cs"), new MockFileData(sourceFile) },
{ Path.Combine(_filesystemRoot, "ExampleProject", "OneFolderDeeper", "Recursive.cs"), new MockFileData(sourceFile) },
{ testProjectPath, new MockFileData(defaultTestProjectFileContents) },
{ Path.Combine(_filesystemRoot, "TestProject", "bin", "Debug", "netcoreapp2.0"), new MockFileData("Bytecode") },
{ Path.Combine(_filesystemRoot, "TestProject", "obj", "Release", "netcoreapp2.0"), new MockFileData("Bytecode") },
});
var projectFileReaderMock = new Mock <IProjectFileReader>(MockBehavior.Strict);
projectFileReaderMock.Setup(x => x.AnalyzeProject(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>()
{
projectUnderTestPath
},
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = testProjectPath,
Properties = new Dictionary <string, string>(),
References = new string[] { "" }
});
projectFileReaderMock.Setup(x => x.AnalyzeProject(projectUnderTestPath, null))
.Returns(new ProjectAnalyzerResult(null, null)
{
ProjectReferences = new List <string>(),
TargetFrameworkString = "netcoreapp2.1",
ProjectFilePath = projectUnderTestPath,
Properties = new Dictionary <string, string>(),
});
var target = new InputFileResolver(fileSystem, projectFileReaderMock.Object);
var result = target.ResolveInput(new StrykerOptions(fileSystem: fileSystem, basePath: _basePath));
result.ProjectContents.GetAllFiles().Count().ShouldBe(4);
}
