public async void OpenProject(string path)
{
_loadingDisplayer.ShowLoading($"Opening project at {Path.GetFileName(path)}");
UnimaConfig config = null;
try
{
config = await Task.Run(() => _mediator.Send(new OpenProjectCommand(path, true)));
_mutationModuleTabOpener.OpenOverviewTab(config);
}
catch (ValidationException ex)
{
ErrorDialogDisplayer.ShowErrorDialog("Unexpected error", "Failed to open project.", ex.Message);
return;
}
catch (OpenProjectException ex)
{
ErrorDialogDisplayer.ShowErrorDialog("Unexpected error", "Failed to open project.", ex.InnerException?.ToString());
return;
}
finally
{
_loadingDisplayer.HideLoading();
}
}
public void Initialize(MutationDocument document, UnimaConfig config)
{
_config = config;
_document = document;
FileName = document.FileName;
Title = $"{document.FileName} - {document.MutationDetails.Location})";
ShowFullCode(false);
}
public MutationDocumentsOverviewView(UnimaConfig config)
{
InitializeComponent();
var viewModel = DataContext as MutationDocumentsOverviewViewModel;
viewModel.Initialize(config);
}
public MutationDocumentDetailsView(MutationDocument document, UnimaConfig config)
{
InitializeComponent();
var dataContext = DataContext as MutationDocumentDetailsViewModel;
dataContext.Initialize(document, config);
}
public MutationFileDetailsView(FileMutationsModel file, UnimaConfig config)
{
InitializeComponent();
var dataContext = DataContext as MutationFileDetailsViewModel;
dataContext.Initialize(file, config);
}
private TimeSpan GetTimeout(UnimaConfig config)
{
if (config.BaselineInfos != null && config.BaselineInfos.Any())
{
return(new TimeSpan(config.BaselineInfos.Sum(b => b.ExecutionTime.Ticks * 4)));
}
return(TimeSpan.FromMinutes(config.MaxTestTimeMin));
}
public void SetDocuments(IReadOnlyList <MutationDocument> documents, UnimaConfig config)
{
_config = config;
RunningDocuments.AddRange(documents.Select(d => new TestRunDocument {
Document = d, Status = TestRunDocument.TestRunStatusEnum.Waiting
}));
MutationCount = documents.Count;
MutationsInQueueCount = MutationCount;
}
public async Task <IList <BaselineInfo> > CreateBaselineAsync(UnimaConfig config)
{
using (var workspace = MSBuildWorkspace.Create())
{
LogTo.Info("Opening solution..");
var solution = await workspace.OpenSolutionAsync(config.SolutionPath);
return(await CreateBaselineAsync(config, solution));
}
}
public ExecuteMutationsCommand(
UnimaConfig config,
IList <MutationDocument> mutationDocuments,
Action <MutationDocument> mutationDocumentStartedCallback = null,
Action <MutationDocumentResult> mutationDocumentCompledtedCallback = null)
{
Config = config;
MutationDocuments = mutationDocuments;
MutationDocumentStartedCallback = mutationDocumentStartedCallback;
MutationDocumentCompledtedCallback = mutationDocumentCompledtedCallback;
}
public async Task <IList <BaselineInfo> > CreateBaselineAsync(UnimaConfig config, Microsoft.CodeAnalysis.Solution solution)
{
LogTo.Info("Creating baseline and verifying solution/tests..");
if (Directory.Exists(BaselineDirectoryPath))
{
Directory.Delete(BaselineDirectoryPath, true);
}
Directory.CreateDirectory(BaselineDirectoryPath);
foreach (var mutationProject in config.MutationProjects)
{
var project = solution.Projects.FirstOrDefault(p => p.Name == mutationProject.Name);
var result = await _projectCompiler.CompileAsync(BaselineDirectoryPath, project);
if (!result.IsSuccess)
{
throw new BaselineException(
"Failed to compile base line.",
new CompilationException(result.Errors.Select(e => e.Message)));
}
}
var baselineInfos = new List <BaselineInfo>();
foreach (var testProject in config.TestProjects)
{
var result = await RunTestAsync(testProject, config.DotNetPath, config.MaxTestTimeMin);
if (!result.IsSuccess)
{
var failedTests = result.TestResults.Where(t => !t.IsSuccess);
LogTo.Error("Unit tests failed with base line");
LogTo.Error($"Name: {result.Name}");
foreach (var failedTest in failedTests)
{
LogTo.Error(JObject.FromObject(new { TestName = failedTest.Name, Message = failedTest.InnerText }).ToString());
}
throw new BaselineException("Failed to run all unit tests with baseline which make mutation testing impossible. See log for more details.");
}
LogTo.Info($"..done ({result.TestResults.Count(t => t.IsSuccess)} tests passed).");
baselineInfos.Add(new BaselineInfo(testProject.Project.Name, result.ExecutionTime));
}
LogBaselineSummary(baselineInfos);
LogTo.Info("Baseline completed.");
return(baselineInfos);
}
public MutationDocumentsExecutionView(IReadOnlyList <MutationDocument> documents, UnimaConfig config)
{
InitializeComponent();
var dataContext = DataContext as MutationDocumentsExecutionViewModel;
dataContext?.SetDocuments(documents, config);
}
public CreateMutationsCommand(UnimaConfig config, IList <IMutator> mutationOperators)
{
Config = config;
MutationOperators = mutationOperators;
}
public void Initialize(UnimaConfig config)
{
_config = config;
}
public async Task <IList <MutationDocument> > CreateMutationsAsync(UnimaConfig config, IList <IMutator> mutationOperators)
{
try
{
var workspace = MSBuildWorkspace.Create();
LogTo.Info("Opening solution..");
var solution = await workspace.OpenSolutionAsync(config.SolutionPath);
LogTo.Info("Starting to analyze test..");
var list = new List <MutationDocument>();
foreach (var mutationProjectInfo in config.MutationProjects)
{
var currentProject = solution.Projects.FirstOrDefault(p => p.Name == mutationProjectInfo.Name);
if (currentProject == null)
{
LogTo.Error($"Could not find any project with the name {mutationProjectInfo.Name}");
continue;
}
var documentIds = currentProject.DocumentIds;
LogTo.Info($"Starting to create mutations for {currentProject.Name}..");
foreach (var documentId in documentIds)
{
try
{
var document = currentProject.GetDocument(documentId);
if (config.Filter != null && !config.Filter.ResourceAllowed(document.FilePath))
{
LogTo.Info($"Ignoring {document.Name}.");
continue;
}
LogTo.Info($"Creating mutation for {document.Name}..");
var root = document.GetSyntaxRootAsync().Result;
var mutationDocuments = new List <MutationDocument>();
foreach (var mutationOperator in mutationOperators)
{
var mutatedDocuments = mutationOperator.GetMutatedDocument(root, document);
mutationDocuments.AddRange(mutatedDocuments.Where(m => config.Filter == null || config.Filter.ResourceLinesAllowed(document.FilePath, GetDocumentLine(m))));
}
list.AddRange(mutationDocuments);
}
catch (Exception ex)
{
LogTo.Error("Error when creating mutation: " + ex.Message);
}
}
}
if (!list.Any())
{
LogTo.Warn("Could not find a single mutation. Maybe check your filter?");
}
return(list);
}
catch (Exception ex)
{
LogTo.ErrorException("Unknown exception when creating mutation documents", ex);
throw new MutationDocumentException("Unknown exception when creating mutation documents", ex);
}
}
public void OpenTestRunTab(IReadOnlyList <MutationDocument> documents, UnimaConfig config)
{
_mainTabContainer.AddTab(new MutationDocumentsExecutionView(documents, config));
}
public void Initialize(FileMutationsModel file, UnimaConfig config)
{
_config = config;
File = file;
FileName = File.FileName;
}
public async Task <MutationDocumentResult> ExecuteMutationAsync(UnimaConfig config, MutationDocument mutationDocument)
{
var mutationResult = new MutationDocumentResult
{
Id = mutationDocument.Id,
MutationName = mutationDocument.MutationName,
ProjectName = mutationDocument.ProjectName,
FileName = mutationDocument.FileName,
Location = mutationDocument.MutationDetails.Location,
Orginal = mutationDocument.MutationDetails.Orginal.ToFullString(),
FullOrginal = mutationDocument.MutationDetails.FullOrginal.ToFullString(),
Mutation = mutationDocument.MutationDetails.Mutation.ToFullString(),
FullMutation = mutationDocument.MutationDetails.FullMutation.ToFullString()
};
mutationResult.GenerateHash();
LogTo.Info($"Running mutation: \"{mutationDocument.MutationName}\"");
var results = new List <TestSuiteResult>();
// Create the temporary "head" mutation directory to run all tests
var mutationDirectoryPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "TestRun", mutationDocument.Id.ToString());
// Where we should save our compiled mutation
var mutationDllPath = Path.Combine(mutationDirectoryPath, $"{config.MutationProjects.FirstOrDefault(m => m.Name == mutationDocument.ProjectName).OutputFileName}");
Directory.CreateDirectory(mutationDirectoryPath);
mutationResult.CompilationResult = await _compiler.CompileAsync(mutationDllPath, mutationDocument);
if (!mutationResult.CompilationResult.IsSuccess)
{
return(mutationResult);
}
foreach (var testProject in config.TestProjects)
{
var baseline = config.BaselineInfos.FirstOrDefault(b => b.TestProjectName.Equals(testProject.Project.Name, StringComparison.OrdinalIgnoreCase));
var result = await RunTestAsync(testProject, mutationDirectoryPath, mutationDllPath, config.DotNetPath, baseline?.GetTestProjectTimeout() ?? TimeSpan.FromMinutes(config.MaxTestTimeMin));
results.Add(result);
if (results.Any(r => !r.IsSuccess))
{
break;
}
}
try
{
Directory.Delete(mutationDirectoryPath, true);
}
catch (Exception ex)
{
LogTo.Error($"Failed to delete test directory: {ex.Message}");
}
var final = CombineResult(mutationDocument.FileName, results);
LogTo.Info($"\"{mutationDocument.MutationName}\" done. Ran {final.TestResults.Count} tests and {final.TestResults.Count(t => !t.IsSuccess)} failed.");
mutationResult.FailedTests = final.TestResults.Where(t => !t.IsSuccess).ToList();
mutationResult.TestsRunCount = final.TestResults.Count;
return(mutationResult);
}
public void OpenFileDetailsTab(FileMutationsModel file, UnimaConfig config)
{
_mainTabContainer.AddTab(new MutationFileDetailsView(file, config));
}
public void OpenOverviewTab(UnimaConfig config)
{
_mainTabContainer.RemoveAllTabs();
_mainTabContainer.AddTab(new MutationDocumentsOverviewView(config));
}
public CreateMutationsCommand(UnimaConfig config)
{
Config = config;
}
public void OpenDocumentDetailsTab(MutationDocument document, UnimaConfig config)
{
_mainTabContainer.AddTab(new MutationDocumentDetailsView(document, config));
}
public CreateBaselineCommand(UnimaConfig config)
{
Config = config;
}
public ExecuteMutationCommand(UnimaConfig config, MutationDocument mutation)
{
Config = config;
Mutation = mutation;
}
