public ITestRunner Create(StrykerOptions options, OptimizationFlags flags, ProjectInfo projectInfo)
{
_logger.LogDebug("Factory is creating testrunner for asked type {0}", options.TestRunner);
ITestRunner testRunner;
switch (options.TestRunner)
{
case TestRunner.DotnetTest:
default:
testRunner = new DotnetTestRunner(projectInfo.TestProjectAnalyzerResult.ProjectFilePath, new ProcessExecutor(), flags);
break;
case TestRunner.VsTest:
testRunner = new VsTestRunnerPool(options, flags, projectInfo);
break;
}
_logger.LogInformation("Using testrunner {0}", options.TestRunner.ToString());
return(testRunner);
}
public void MutantFilterFactory_Creates_Standard_Mutant_Filters()
{
// Arrange
var options = new StrykerOptions()
{
Since = false
};
var diffProviderMock = new Mock <IDiffProvider>(MockBehavior.Loose);
var branchProviderMock = new Mock <IGitInfoProvider>(MockBehavior.Loose);
var baselineProvider = new Mock <IBaselineProvider>(MockBehavior.Loose);
// Act
var result = MutantFilterFactory.Create(options, null, diffProviderMock.Object, baselineProvider.Object, branchProviderMock.Object);
// Assert
var resultAsBroadcastFilter = result as BroadcastMutantFilter;
resultAsBroadcastFilter.MutantFilters.Count().ShouldBe(4);
}
public void ShouldNotMutateIfMutationLevelIsLow()
{
var originalNode = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8)));
// The mutator is of level Expert
var target = new ExampleMutator(MutationLevel.Complete);
// The options level is Beginner
var options = new StrykerOptions
{
MutationLevel = MutationLevel.Standard
};
target.Mutate(originalNode, options);
// ApplyMutations should not have been called
}
public void StrykerCLI_ExcludedMutationsNamesShouldMapToMutatorTypes(Mutator expectedType, params string[] argValues)
{
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
var options = new StrykerOptions();
var runResults = new StrykerRunResult(options, 0.3);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>(), It.IsAny <IEnumerable <LogMessage> >())).Returns(runResults);
var target = new StrykerCLI(mock.Object);
argValues.Count().ShouldBeGreaterThan(0);
foreach (var argValue in argValues)
{
target.Run(new string[] { "-em", $"['{argValue}']" });
mock.Verify(x => x.RunMutationTest(It.Is <StrykerOptions>(o => o.ExcludedMutations.Single() == expectedType), It.IsAny <IEnumerable <LogMessage> >()));
}
}
public void StrykerCLI_WithLogConsoleArgument_ShouldPassLogConsoleArgumentsToStryker(string argName)
{
StrykerOptions actualOptions = null;
var runResults = new StrykerRunResult(new StrykerOptions(), 0.3);
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>(), It.IsAny <IEnumerable <LogMessage> >()))
.Callback <StrykerOptions, IEnumerable <LogMessage> >((c, m) => actualOptions = c)
.Returns(runResults)
.Verifiable();
var target = new StrykerCLI(mock.Object);
target.Run(new[] { argName, "debug" });
mock.VerifyAll();
actualOptions.LogOptions.LogLevel.ShouldBe(LogEventLevel.Debug);
actualOptions.LogOptions.LogToFile.ShouldBeFalse();
}
public async Task ShouldLoadReportFromDiskAsync()
{
// Arrange
var fileSystemMock = new MockFileSystem();
var options = new StrykerOptions(basePath: @"C:/Users/JohnDoe/Project/TestFolder", fileSystem: fileSystemMock);
var report = JsonReport.Build(options, JsonReportTestHelper.CreateProjectWith().ToReadOnlyInputComponent());
fileSystemMock.AddFile("C:/Users/JohnDoe/Project/TestFolder/StrykerOutput/Baselines/version/stryker-report.json", report.ToJson());
var target = new DiskBaselineProvider(options, fileSystemMock);
// Act
var result = await target.Load("version");
// Assert
result.ShouldNotBeNull();
result.ToJson().ShouldBe(report.ToJson());
}
public MutationProcess(MutationTestInput mutationTestInput,
IMutantOrchestrator orchestrator = null,
IFileSystem fileSystem = null,
StrykerOptions options = null,
IMutantFilter mutantFilter = null,
IReporter reporter = null)
{
_input = mutationTestInput;
_projectInfo = (ProjectComponent <SyntaxTree>)mutationTestInput.ProjectInfo.ProjectContents;
_options = options;
_orchestrator = orchestrator ?? new MutantOrchestrator(options: _options);
_compilingProcess = new CompilingProcess(mutationTestInput, new RollbackProcess());
_fileSystem = fileSystem ?? new FileSystem();
_logger = ApplicationLogging.LoggerFactory.CreateLogger <MutationTestProcess>();
_mutantFilter = mutantFilter ?? MutantFilterFactory.Create(options);
_reporter = reporter;
}
/// <summary>
/// Finds the referencedProjects and looks for all files that should be mutated in those projects
/// </summary>
public ProjectInfo ResolveInput(StrykerOptions options)
{
var projectInfo = new ProjectInfo(_fileSystem);
// Determine test projects
var testProjectFiles = new List <string>();
if (options.TestProjects != null && options.TestProjects.Any())
{
testProjectFiles = options.TestProjects.Select(FindTestProject).ToList();
}
else
{
testProjectFiles.Add(FindTestProject(options.BasePath));
}
var testProjectAnalyzerResults = new List <IAnalyzerResult>();
foreach (var testProjectFile in testProjectFiles)
{
// Analyze the test project
testProjectAnalyzerResults.Add(_projectFileReader.AnalyzeProject(testProjectFile, options.SolutionPath, options.TargetFramework));
}
projectInfo.TestProjectAnalyzerResults = testProjectAnalyzerResults;
// Determine project under test
var projectUnderTest = FindProjectUnderTest(projectInfo.TestProjectAnalyzerResults, options.ProjectUnderTestName);
_logger.LogInformation("The project {0} will be mutated.", projectUnderTest);
// Analyze project under test
projectInfo.ProjectUnderTestAnalyzerResult = _projectFileReader.AnalyzeProject(projectUnderTest, options.SolutionPath, options.TargetFramework);
//to test Fsharp support you would need to create a FsharpProjectComponentsBuilder
var inputFiles = new CsharpProjectComponentsBuilder(projectInfo, options, _foldersToExclude, _logger, _fileSystem).Build();
projectInfo.ProjectContents = inputFiles;
ValidateTestProjectsCanBeExecuted(projectInfo);
_logger.LogInformation("Analysis complete.");
return(projectInfo);
}
public void ReturnsTip_When_Friendly_Name_Is_GitSource()
{
// Arrange
var options = new StrykerOptions(gitSource: "master");
var repositoryMock = new Mock <IRepository>(MockBehavior.Strict);
var branchCollectionMock = new Mock <BranchCollection>(MockBehavior.Strict);
var branchMock = new Mock <Branch>();
var commitMock = new Mock <Commit>();
branchMock
.SetupGet(x => x.FriendlyName)
.Returns("master");
branchMock
.SetupGet(x => x.CanonicalName)
.Returns("origin/master");
branchMock.SetupGet(x => x.Tip).Returns(commitMock.Object);
branchCollectionMock
.Setup(x => x.GetEnumerator())
.Returns(((IEnumerable <Branch>) new List <Branch>
{
branchMock.Object
}).GetEnumerator());
repositoryMock
.SetupGet(x => x.Branches)
.Returns(branchCollectionMock.Object);
var target = new GitInfoProvider(options, repositoryMock.Object);
// Act
var res = target.DetermineCommit();
// Assert
res.ShouldNotBeNull();
res.ShouldBe(commitMock.Object);
repositoryMock.Verify();
}
public void ReturnsCurrentBranch()
{
// Arrange
var options = new StrykerOptions();
var repositoryMock = new Mock <IRepository>(MockBehavior.Strict);
var branchCollectionMock = new Mock <BranchCollection>(MockBehavior.Strict);
var branchMock = new Mock <Branch>();
branchCollectionMock
.Setup(x => x.Add(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new Mock <Branch>(MockBehavior.Loose).Object);
branchMock
.SetupGet(x => x.IsCurrentRepositoryHead)
.Returns(true);
branchMock
.SetupGet(x => x.FriendlyName)
.Returns("master");
branchCollectionMock
.Setup(x => x.GetEnumerator())
.Returns(((IEnumerable <Branch>) new List <Branch>
{
branchMock.Object
}).GetEnumerator());
repositoryMock
.SetupGet(x => x.Branches)
.Returns(branchCollectionMock.Object);
var target = new GitInfoProvider(options, repositoryMock.Object);
// Act
var res = target.GetCurrentBranchName();
// Assert
res.ShouldBe("master");
repositoryMock.Verify();
}
public void Stryker_ShouldInvokeAllProcesses()
{
string basePath = @"c:\TestProject\";
var initialisationMock = new Mock <IInitialisationProcess>(MockBehavior.Strict);
var mutationTestProcessMock = new Mock <IMutationTestProcess>(MockBehavior.Strict);
initialisationMock.Setup(x => x.Initialize(It.IsAny <StrykerOptions>())).Returns(new MutationTestInput()
{
ProjectInfo = new ProjectInfo()
{
TestProjectPath = basePath,
ProjectContents = new FolderComposite()
{
Name = "ProjectRoot",
Children = new Collection <ProjectComponent>()
{
new FileLeaf()
{
Name = "SomeFile.cs"
}
}
},
ProjectUnderTestAssemblyName = "ExampleProject.dll",
ProjectUnderTestPath = @"c:\ExampleProject\",
TargetFramework = "netcoreapp2.0"
},
});
var options = new StrykerOptions();
mutationTestProcessMock.Setup(x => x.Mutate(options));
mutationTestProcessMock.Setup(x => x.Test(It.IsAny <StrykerOptions>()))
.Returns(new StrykerRunResult(It.IsAny <StrykerOptions>(), It.IsAny <decimal?>()));
var target = new StrykerRunner(initialisationMock.Object, mutationTestProcessMock.Object);
target.RunMutationTest(options);
initialisationMock.Verify(x => x.Initialize(It.IsAny <StrykerOptions>()), Times.Once);
mutationTestProcessMock.Verify(x => x.Mutate(options), Times.Once);
mutationTestProcessMock.Verify(x => x.Test(It.IsAny <StrykerOptions>()), Times.Once);
}
public void ShouldNotFilterMutantsWhereCoveringTestsContainsChangedTestFile()
{
// Arrange
string testProjectPath = "C:/MyTests";
var options = new StrykerOptions();
var diffProvider = new Mock <IDiffProvider>(MockBehavior.Loose);
// If a file inside the test project is changed, a test has been changed
string myTest = Path.Combine(testProjectPath, "myTest.cs");;
diffProvider.Setup(x => x.ScanDiff()).Returns(new DiffResult()
{
ChangedSourceFiles = new Collection <string>()
{
myTest
},
ChangedTestFiles = new Collection <string>()
{
myTest
}
});
var target = new DiffMutantFilter(diffProvider.Object);
// check the diff result for a file not inside the test project
var file = new CsharpFileLeaf {
FullPath = Path.Combine("C:/NotMyTests", "myfile.cs")
};
var mutant = new Mutant();
mutant.CoveringTests.Add(new TestDescription(Guid.NewGuid().ToString(), "name", myTest));
// Act
var filterResult = target.FilterMutants(new List <Mutant>()
{
mutant
}, file.ToReadOnly(), options);
// Assert
filterResult.ShouldContain(mutant);
}
public void RunTestsSimultaneouslyWhenPossible()
{
var options = new StrykerOptions();
var mutantFilter = new Mock <IMutantFilter>(MockBehavior.Loose);
using (var endProcess = new EventWaitHandle(false, EventResetMode.ManualReset))
{
var strykerOptions = new StrykerOptions(fileSystem: _fileSystem, abortTestOnFail: false);
var mockVsTest = BuildVsTestRunner(strykerOptions, endProcess, out var runner, strykerOptions.Optimizations);
// make sure we have 4 mutants
_projectContents.Add(new FileLeaf {
Mutants = new[] { new Mutant {
Id = 2
}, new Mutant {
Id = 3
} }
});
_testCases.Add(new TestCase("T2", _executorUri, _testAssemblyPath));
_testCases.Add(new TestCase("T3", _executorUri, _testAssemblyPath));
var input = new MutationTestInput {
ProjectInfo = _targetProject, TestRunner = runner, TimeoutMs = 100
};
foreach (var mutant in _targetProject.ProjectContents.Mutants)
{
mutant.CoveringTests = new TestListDescription(null);
}
var mockReporter = new Mock <IReporter>();
var tester = new MutationTestProcess(input, mockReporter.Object, new MutationTestExecutor(input.TestRunner), fileSystem: _fileSystem, options: strykerOptions, mutantFilter: mutantFilter.Object);
SetupMockCoverageRun(mockVsTest, new Dictionary <string, string> {
["T0"] = "0;", ["T1"] = "1;"
}, endProcess);
tester.GetCoverage();
SetupMockPartialTestRun(mockVsTest, new Dictionary <string, string> {
["1,0"] = "T0=S,T1=F"
}, endProcess);
tester.Test(_projectContents.Mutants.Where(x => x.ResultStatus == MutantStatus.NotRun));
_mutant.ResultStatus.ShouldBe(MutantStatus.Survived);
_otherMutant.ResultStatus.ShouldBe(MutantStatus.Killed);
}
}
public void Doesnt_Use_ProjectVersion_When_CurrentBranch_Is_Not_Null()
{
var gitInfoProvider = new Mock <IGitInfoProvider>();
var baselineProvider = new Mock <IBaselineProvider>();
var readOnlyInputComponent = new Mock <IReadOnlyProjectComponent>(MockBehavior.Loose);
readOnlyInputComponent.Setup(s => s.FullPath).Returns("/home/usr/dev/project");
var options = new StrykerOptions(projectVersion: "new-feature", gitDiffTarget: "master", compareToDashboard: true);
gitInfoProvider.Setup(x => x.GetCurrentBranchName()).Returns("new-feature");
var target = new GitBaselineReporter(options, baselineProvider.Object, gitInfoProvider.Object);
target.OnAllMutantsTested(readOnlyInputComponent.Object);
baselineProvider.Verify(x => x.Save(It.IsAny <JsonReport>(), It.Is <string>(x => x == "dashboard-compare/new-feature")), Times.Once);
baselineProvider.Verify(x => x.Save(It.IsAny <JsonReport>(), It.Is <string>(x => x == "new-feature")), Times.Never);
}
public void ShouldOverwriteDefaultDashboardUrlWhenPassed(string argName)
{
StrykerOptions options = null;
var runResults = new StrykerRunResult(new StrykerOptions(), 0.3);
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>(), It.IsAny <IEnumerable <LogMessage> >()))
.Callback <StrykerOptions, IEnumerable <LogMessage> >((c, m) => options = c)
.Returns(runResults)
.Verifiable();
var target = new StrykerCLI(mock.Object);
target.Run(new string[] { argName, "--reporters", "['dashboard']", "--dashboard-project", "test", "--dashboard-api-key", "test" });
mock.VerifyAll();
options.DashboardUrl.ShouldBe("https://www.example.com/");
}
public void MutantFilterFactory_Creates_DashboardMutantFilter_And_DiffMutantFilter_WithBaseline_Enabled()
{
var options = new StrykerOptions()
{
WithBaseline = true,
ProjectVersion = "foo"
};
var diffProviderMock = new Mock <IDiffProvider>(MockBehavior.Loose);
var gitInfoProviderMock = new Mock <IGitInfoProvider>(MockBehavior.Loose);
var baselineProviderMock = new Mock <IBaselineProvider>(MockBehavior.Loose);
var result = MutantFilterFactory.Create(options, null, diffProviderMock.Object, baselineProviderMock.Object, gitInfoProviderMock.Object);
var resultAsBroadcastFilter = result as BroadcastMutantFilter;
resultAsBroadcastFilter.MutantFilters.Count().ShouldBe(6);
resultAsBroadcastFilter.MutantFilters.Where(x => x.GetType() == typeof(BaselineMutantFilter)).Count().ShouldBe(1);
resultAsBroadcastFilter.MutantFilters.Where(x => x.GetType() == typeof(SinceMutantFilter)).Count().ShouldBe(1);
}
public void ShouldEnableDiffFeatureWhenDashboardComparePassed(params string[] argNames)
{
StrykerOptions options = null;
var runResults = new StrykerRunResult(new StrykerOptions(), 0.3);
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>(), It.IsAny <IEnumerable <LogMessage> >()))
.Callback <StrykerOptions, IEnumerable <LogMessage> >((c, m) => options = c)
.Returns(runResults)
.Verifiable();
var target = new StrykerCLI(mock.Object);
target.Run(argNames);
mock.VerifyAll();
options.DiffEnabled.ShouldBeTrue();
}
public async Task ShouldWriteToDiskAsync()
{
// Arrange
var fileSystemMock = new MockFileSystem();
var options = new StrykerOptions()
{
BasePath = @"C:/Users/JohnDoe/Project/TestFolder"
};
var sut = new DiskBaselineProvider(options, fileSystemMock);
// Act
await sut.Save(JsonReport.Build(options, JsonReportTestHelper.CreateProjectWith()), "baseline/version");
// Assert
var path = FilePathUtils.NormalizePathSeparators(@"C:/Users/JohnDoe/Project/TestFolder/StrykerOutput/baseline/version/stryker-report.json");
MockFileData file = fileSystemMock.GetFile(path);
file.ShouldNotBeNull();
}
private void HandleStrykerRunResult(StrykerOptions options, StrykerRunResult result)
{
var logger = ApplicationLogging.LoggerFactory.CreateLogger <StrykerCLI>();
logger.LogInformation("The final mutation score is {MutationScore:P2}", result.MutationScore);
if (result.ScoreIsLowerThanThresholdBreak())
{
var thresholdBreak = (double)options.Thresholds.Break / 100;
logger.LogWarning("Final mutation score is below threshold break. Crashing...");
new Chalk().Red(string.Format(@"
The mutation score is lower than the configured break threshold of {0:P0}.
If you're running in a CI environment, this means your pipeline will now fail.", thresholdBreak));
Console.WriteLine(Environment.NewLine);
new Chalk().Green(" Looks like you've got some work to do :)");
ExitCode = 1;
}
}
public void ShouldKeepDefaultDashboardUrlWhenArgumentNotProvided()
{
StrykerOptions options = null;
var runResults = new StrykerRunResult(new StrykerOptions(), 0.3);
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>(), It.IsAny <IEnumerable <LogMessage> >()))
.Callback <StrykerOptions, IEnumerable <LogMessage> >((c, m) => options = c)
.Returns(runResults)
.Verifiable();
var target = new StrykerCLI(mock.Object);
target.Run(new string[] { "--reporters", "['dashboard']", "--dashboard-project", "test", "--dashboard-api-key", "test" });
mock.VerifyAll();
options.DashboardUrl.ShouldBe("https://dashboard.stryker-mutator.io");
}
public void StrykerCLI_WithDevModeArgument_ShouldPassDevModeArgumentsToStryker(string argName)
{
StrykerOptions actualOptions = null;
var runResults = new StrykerRunResult(new StrykerOptions(), 0.3M);
var mock = new Mock <IStrykerRunner>(MockBehavior.Strict);
mock.Setup(x => x.RunMutationTest(It.IsAny <StrykerOptions>()))
.Callback <StrykerOptions>((c) => actualOptions = c)
.Returns(runResults)
.Verifiable();
var target = new StrykerCLI(mock.Object);
target.Run(new string[] { argName });
mock.VerifyAll();
actualOptions.DevMode.ShouldBeTrue();
}
public void ScoreIsLowerThanThresholdBreak_ShouldReturnTrueWhen(double mutationScore, int thresholdBreak)
{
// Arrange
var options = new StrykerOptions()
{
Thresholds = new Thresholds
{
High = 100,
Low = 100,
Break = thresholdBreak
}
};
var runResult = new StrykerRunResult(options, mutationScore);
// Act
var scoreIsLowerThanThresholdBreak = runResult.ScoreIsLowerThanThresholdBreak();
// Assert
scoreIsLowerThanThresholdBreak.ShouldBeTrue("because the mutation score is lower than the threshold break");
}
/// <summary>
/// Starts a mutation test run
/// </summary>
/// <exception cref="StrykerInputException">For managed exceptions</exception>
/// <param name="options">The user options</param>
public StrykerRunResult RunMutationTest(StrykerOptions options)
{
// start stopwatch
var stopwatch = new Stopwatch();
stopwatch.Start();
// setup logging
ApplicationLogging.ConfigureLogger(options.LogOptions);
var logger = ApplicationLogging.LoggerFactory.CreateLogger <StrykerRunner>();
try
{
// initialize
_reporter = ReporterFactory.Create(options);
_initialisationProcess = _initialisationProcess ?? new InitialisationProcess();
_input = _initialisationProcess.Initialize(options);
_mutationTestProcess = _mutationTestProcess ?? new MutationTestProcess(
mutationTestInput: _input,
excludedMutations: options.ExcludedMutations,
reporter: _reporter,
mutationTestExecutor: new MutationTestExecutor(_input.TestRunner, _input.TimeoutMS));
// mutate
_mutationTestProcess.Mutate(options);
// test mutations and return results
return(_mutationTestProcess.Test(options));
}
catch (Exception ex) when(!(ex is StrykerInputException))
{
logger.LogError(ex, "An error occurred during the mutation test run ");
throw;
}
finally {
// log duration
stopwatch.Stop();
logger.LogInformation("Time Elapsed {0}", stopwatch.Elapsed);
}
}
public void ScanDiff_Throws_Stryker_Input_Exception_When_Commit_null()
{
var options = new StrykerOptions()
{
SinceTarget = "branch"
};
var repositoryMock = new Mock <IRepository>();
var branchCollectionMock = new Mock <BranchCollection>();
var branchMock = new Mock <Branch>();
var commitMock = new Mock <Commit>();
branchCollectionMock
.Setup(x => x.Add(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new Mock <Branch>(MockBehavior.Loose).Object);
branchMock
.SetupGet(x => x.IsCurrentRepositoryHead)
.Returns(true);
branchMock
.SetupGet(x => x.FriendlyName)
.Returns("master");
branchCollectionMock
.Setup(x => x.GetEnumerator())
.Returns(((IEnumerable <Branch>) new List <Branch>
{
branchMock.Object
}).GetEnumerator());
repositoryMock.SetupGet(x => x.Branches).Returns(branchCollectionMock.Object);
var gitInfoMock = new Mock <IGitInfoProvider>();
gitInfoMock.Setup(x => x.DetermineCommit()).Returns((Commit)null);
gitInfoMock.SetupGet(x => x.Repository).Returns(repositoryMock.Object);
var target = new GitDiffProvider(options, null, gitInfoMock.Object);
Should.Throw <InputException>(() => target.ScanDiff());
}
/// <summary>
/// Finds the referencedProjects and looks for all files that should be mutated in those projects
/// </summary>
public ProjectInfo ResolveInput(StrykerOptions options)
{
var result = new ProjectInfo();
var testProjectFile = FindProjectFile(options.BasePath, options.TestProjectNameFilter);
// Analyze the test project
result.TestProjectAnalyzerResult = _projectFileReader.AnalyzeProject(testProjectFile, options.SolutionPath);
// Determine project under test
var reader = new ProjectFileReader();
var projectUnderTest = reader.DetermineProjectUnderTest(result.TestProjectAnalyzerResult.ProjectReferences, options.ProjectUnderTestNameFilter);
_logger.LogInformation("The project {0} will be mutated", projectUnderTest);
// Analyze project under test
result.ProjectUnderTestAnalyzerResult = _projectFileReader.AnalyzeProject(projectUnderTest, options.SolutionPath);
var inputFiles = new FolderComposite();
result.FullFramework = !result.TestProjectAnalyzerResult.TargetFramework.Contains("netcoreapp", StringComparison.InvariantCultureIgnoreCase);
var projectUnderTestDir = Path.GetDirectoryName(result.ProjectUnderTestAnalyzerResult.ProjectFilePath);
foreach (var dir in ExtractProjectFolders(result.ProjectUnderTestAnalyzerResult, result.FullFramework))
{
var folder = _fileSystem.Path.Combine(Path.GetDirectoryName(projectUnderTestDir), dir);
_logger.LogDebug($"Scanning {folder}");
if (!_fileSystem.Directory.Exists(folder))
{
throw new DirectoryNotFoundException($"Can't find {folder}");
}
inputFiles.Add(FindInputFiles(folder, options.FilesToExclude.ToList()));
}
MarkInputFilesAsExcluded(inputFiles, options.FilesToExclude.ToList(), projectUnderTestDir);
result.ProjectContents = inputFiles;
ValidateResult(result, options);
return(result);
}
/// <param name="mutators">The mutators that should be active during the mutation process</param>
public MutantOrchestrator(IEnumerable <IMutator> mutators = null, StrykerOptions options = null)
{
_options = options;
Mutators = mutators ?? new List <IMutator>
{
// the default list of mutators
new BinaryExpressionMutator(),
new BooleanMutator(),
new AssignmentExpressionMutator(),
new PrefixUnaryMutator(),
new PostfixUnaryMutator(),
new CheckedMutator(),
new LinqMutator(),
new StringMutator(),
new StringEmptyMutator(),
new InterpolatedStringMutator(),
new NegateConditionMutator(),
new InitializerMutator(),
new ObjectCreationMutator(),
new ArrayCreationMutator(),
new RegexMutator()
};
Mutants = new Collection <Mutant>();
Logger = ApplicationLogging.LoggerFactory.CreateLogger <MutantOrchestrator>();
_specificOrchestrator.RegisterHandlers(new List <INodeMutator>
{
new ForStatementOrchestrator(this),
new AssignmentStatementOrchestrator(this),
new PostfixUnaryExpressionOrchestrator(this),
new StaticFieldDeclarationOrchestrator(this),
new StaticConstructorOrchestrator(this),
new ArrayInitializerOrchestrator(this),
new BaseMethodDeclarationOrchestrator <BaseMethodDeclarationSyntax>(this),
new ConstLocalDeclarationOrchestrator(this),
new StatementSpecificOrchestrator <StatementSyntax>(this),
new BlockOrchestrator(this),
new ExpressionSpecificOrchestrator <ExpressionSyntax>(this),
new SyntaxNodeOrchestrator(this)
});
}
public async Task DashboardClient_Logs_And_Returns_Null_On_Publish_Report_Does_Not_Return_200()
{
// Arrange
var loggerMock = new Mock <ILogger <DashboardClient> >(MockBehavior.Loose);
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.BadRequest,
Content = new StringContent("Error message", Encoding.UTF8, "text/html")
})
.Verifiable();
var httpClient = new HttpClient(handlerMock.Object);
var options = new StrykerOptions
{
DashboardUrl = "http://www.example.com/",
DashboardApiKey = "Access_Token"
};
var target = new DashboardClient(options, httpClient, loggerMock.Object);
// Act
var result = await target.PublishReport(new MockJsonReport(null, null), "version");
loggerMock.Verify(
x => x.Log(
It.Is <LogLevel>(logLevel => logLevel == LogLevel.Error),
It.IsAny <EventId>(),
It.Is <It.IsAnyType>((v, t) => true),
It.IsAny <Exception>(),
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)));
result.ShouldBeNull();
}
public void ShouldValidateApiKey()
{
const string strykerDashboardApiKey = "STRYKER_DASHBOARD_API_KEY";
var key = Environment.GetEnvironmentVariable(strykerDashboardApiKey);
try
{
var options = new StrykerOptions();
Environment.SetEnvironmentVariable(strykerDashboardApiKey, string.Empty);
var ex = Assert.Throws<StrykerInputException>(() =>
{
new StrykerOptions(reporters: new string[] { "Dashboard" });
});
ex.Message.ShouldContain($"An API key is required when the {Reporter.Dashboard} reporter is turned on! You can get an API key at {options.DashboardUrl}");
ex.Message.ShouldContain($"A project name is required when the {Reporter.Dashboard} reporter is turned on!");
}
finally
{
Environment.SetEnvironmentVariable(strykerDashboardApiKey, key);
}
}
public void ShouldValidateOptimisationMode()
{
var options = new StrykerOptions(coverageAnalysis: "perTestInIsolation");
options.Optimizations.HasFlag(OptimizationFlags.CoverageBasedTest).ShouldBeTrue();
options.Optimizations.HasFlag(OptimizationFlags.CaptureCoveragePerTest).ShouldBeTrue();
options = new StrykerOptions();
options.Optimizations.HasFlag(OptimizationFlags.CoverageBasedTest).ShouldBeTrue();
options = new StrykerOptions(coverageAnalysis: "all");
options.Optimizations.HasFlag(OptimizationFlags.SkipUncoveredMutants).ShouldBeTrue();
options = new StrykerOptions(coverageAnalysis: "off");
options.Optimizations.HasFlag(OptimizationFlags.NoOptimization).ShouldBeTrue();
var ex = Assert.Throws<StrykerInputException>(() =>
{
new StrykerOptions(coverageAnalysis: "gibberish");
});
ex.Details.ShouldBe($"Incorrect coverageAnalysis option gibberish. The options are [off, all, perTest or perTestInIsolation].");
}
/// <param name="mutators">The mutators that should be active during the mutation process</param>
public MutantOrchestrator(IEnumerable <IMutator> mutators = null, StrykerOptions options = null)
{
_options = options;
Mutators = mutators ?? new List <IMutator>()
{
// the default list of mutators
new BinaryExpressionMutator(),
new BooleanMutator(),
new AssignmentExpressionMutator(),
new PrefixUnaryMutator(),
new PostfixUnaryMutator(),
new CheckedMutator(),
new LinqMutator(),
new StringMutator(),
new StringEmptyMutator(),
new InterpolatedStringMutator(),
new NegateConditionMutator(),
};
Mutants = new Collection <Mutant>();
Logger = ApplicationLogging.LoggerFactory.CreateLogger <MutantOrchestrator>();
}
