private static (bool Success, string[] Files) FindLocallyModifiedSourceFiles(
ISourceControlIntegration sourceControlIntegration,
Config config,
IOutputWriter outputWriter)
{
try
{
outputWriter.WriteLine("Finding local modifications...");
var files = sourceControlIntegration.FindLocallyModifiedFiles(config);
var noun = files.Length == 1 ? "change" : "changes";
outputWriter.WriteLine($"Found {files.Length} relevant {noun}.");
return(true, files);
}
catch (SourceControlIntegrationException ex)
{
outputWriter.WriteFailureLine(ex.Message);
return(false, null);
}
}
internal static int Run(
string[] args,
ITestRunnerFactory testRunnerFactory,
Func <ITestRunner, IEventListener, ICoverageAnalysisResult, IMutationTestRunner> mutationTestRunnerFactory,
Func <IEventListener, ICoverageAnalyser> coverageAnalyserFactory,
ISourceControlIntegration sourceControlIntegration,
IOutputWriter outputWriter)
{
try
{
outputWriter.WriteLine($"Fettle v{AssemblyVersionInformation.AssemblyVersion}");
var parsedArgs = CommandLineArguments.Parse(args, outputWriter);
if (!parsedArgs.Success)
{
return(ExitCodes.ConfigOrArgsAreInvalid);
}
var validationErrors = parsedArgs.Config.Validate().ToList();
if (validationErrors.Any())
{
OutputValidationErrors(validationErrors, outputWriter);
return(ExitCodes.ConfigOrArgsAreInvalid);
}
if (!string.IsNullOrEmpty(parsedArgs.Config.CustomTestRunnerCommand) &&
!parsedArgs.ConsoleOptions.SkipCoverageAnalysis)
{
WarnThatOptionsAreIncompatibleWithCoverageAnalysis(outputWriter);
}
if (parsedArgs.ConsoleOptions.ModificationsOnly)
{
var result = FindLocallyModifiedSourceFiles(sourceControlIntegration, parsedArgs.Config, outputWriter);
if (!result.Success)
{
outputWriter.WriteFailureLine("Failed to find local modifications.");
return(ExitCodes.UnexpectedError);
}
parsedArgs.Config.LocallyModifiedSourceFiles = result.Files;
}
if (!parsedArgs.Config.HasAnyMutatableDocuments().Result)
{
outputWriter.WriteLine("No source files found to mutate (or none matched the filters), exiting.");
return(ExitCodes.Success);
}
var eventListener = CreateEventListener(outputWriter, parsedArgs.ConsoleOptions.Verbosity);
ICoverageAnalysisResult coverageResult = null;
var shouldDoCoverageAnalysis = !parsedArgs.Config.HasCustomTestRunnerCommand && !parsedArgs.ConsoleOptions.SkipCoverageAnalysis;
if (shouldDoCoverageAnalysis)
{
var analyser = coverageAnalyserFactory(eventListener);
coverageResult = AnalyseCoverage(analyser, outputWriter, parsedArgs.Config);
if (!coverageResult.WasSuccessful)
{
OutputCoverageAnalysisError(coverageResult.ErrorDescription, outputWriter);
return(ExitCodes.ConfigOrArgsAreInvalid);
}
}
var testRunner = parsedArgs.Config.HasCustomTestRunnerCommand ?
testRunnerFactory.CreateCustomTestRunner(parsedArgs.Config.CustomTestRunnerCommand, parsedArgs.Config.BaseDirectory) :
testRunnerFactory.CreateNUnitTestRunner();
var mutationTestRunner = mutationTestRunnerFactory(testRunner, eventListener, coverageResult);
var mutationTestResult = PerformMutationTesting(mutationTestRunner, parsedArgs.Config, outputWriter);
if (mutationTestResult.Errors.Any())
{
outputWriter.WriteFailureLine("Unable to perform mutation testing:");
mutationTestResult.Errors.ToList().ForEach(e => outputWriter.WriteFailureLine($"==> {e}"));
{
return(ExitCodes.ConfigOrArgsAreInvalid);
}
}
if (mutationTestResult.SurvivingMutants.Any())
{
OutputAllSurvivorInfo(mutationTestResult.SurvivingMutants, outputWriter, parsedArgs.Config);
return(ExitCodes.SomeMutantsSurvived);
}
else
{
outputWriter.WriteSuccessLine("No mutants survived.");
return(ExitCodes.Success);
}
}
catch (Exception ex)
{
outputWriter.WriteFailureLine($"An error ocurred that Fettle didn't expect.{Environment.NewLine}{ex}");
return(ExitCodes.UnexpectedError);
}
}
