public Task SelectTests(StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta,
CancellationToken cancellationToken)
{
var delta = deltaAdapter.Convert(programDelta);
CorrespondenceModel = correspondenceModelProvider.GetCorrespondenceModel(delta.OldModel, testsDelta.OldModel);
ISet <TTestCase> impactedTests = new HashSet <TTestCase>();
foreach (var testcase in testsDelta.NewModel.TestSuite)
{
cancellationToken.ThrowIfCancellationRequested();
HashSet <string> linkedElements;
if (CorrespondenceModel.CorrespondenceModelLinks.TryGetValue(testcase.Id, out linkedElements))
{
if (delta.ChangedElements.Any(x => linkedElements.Any(y => x.Id.Equals(y, StringComparison.Ordinal))) ||
delta.DeletedElements.Any(x => linkedElements.Any(y => x.Id.Equals(y, StringComparison.Ordinal))))
{
impactedTests.Add(testcase);
}
}
else
{
impactedTests.Add(testcase);
}
}
SelectedTests = impactedTests;
return(Task.CompletedTask);
}
public StructuralDelta <CSharpFilesProgramModel, CSharpFileElement> Convert(StructuralDelta <FilesProgramModel, FileElement> delta)
{
var oldCSharpFilesModel = new CSharpFilesProgramModel
{
AbsoluteSolutionPath = delta.OldModel.AbsoluteSolutionPath,
VersionId = delta.OldModel.VersionId
};
oldCSharpFilesModel.Files.AddRange(delta.OldModel.Files.Where(x => x.Id.EndsWith(".cs")).Select(x => new CSharpFileElement(x.Id, x.GetContent)));
var newCSharpFilesModel = new CSharpFilesProgramModel
{
AbsoluteSolutionPath = delta.NewModel.AbsoluteSolutionPath,
VersionId = delta.NewModel.VersionId
};
newCSharpFilesModel.Files.AddRange(delta.NewModel.Files.Where(x => x.Id.EndsWith(".cs")).Select(x => new CSharpFileElement(x.Id, x.GetContent)));
var result = new StructuralDelta <CSharpFilesProgramModel, CSharpFileElement>(oldCSharpFilesModel, newCSharpFilesModel);
result.AddedElements.AddRange(delta.AddedElements.Where(x => x.Id.EndsWith(".cs")).Select(x => new CSharpFileElement(x.Id, x.GetContent)));
result.ChangedElements.AddRange(delta.ChangedElements.Where(x => x.Id.EndsWith(".cs")).Select(x => new CSharpFileElement(x.Id, x.GetContent)));
result.DeletedElements.AddRange(delta.DeletedElements.Where(x => x.Id.EndsWith(".cs")).Select(x => new CSharpFileElement(x.Id, x.GetContent)));
return(result);
}
public async Task SelectTests(StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TInputProgramDelta programDelta, CancellationToken cancellationToken)
{
var convertedDelta = deltaAdapter.Convert(programDelta);
var dataStructure = await dataStructureBuilder.GetDataStructure(convertedDelta.NewModel, cancellationToken);
SelectedTests = staticSelector.SelectTests(dataStructure, testsDelta, convertedDelta, cancellationToken);
}
public StructuralDelta <FilesProgramModel, FileElement> Parse(IntendedChangesArtefact artefact)
{
var delta = new StructuralDelta <FilesProgramModel, FileElement>(artefact.ProgramModel, artefact.ProgramModel);
foreach (string intendedChange in artefact.IntendedChanges)
{
var relativePathToSolution = RelativePathHelper.GetRelativePath(artefact.ProgramModel, intendedChange);
delta.ChangedElements.Add(new FileElement(relativePathToSolution, () => File.ReadAllText(intendedChange)));
}
return(delta);
}
public StructuralDelta <CSharpClassesProgramModel, CSharpClassElement> Convert(StructuralDelta <CSharpFilesProgramModel, CSharpFileElement> delta)
{
var result = new StructuralDelta <CSharpClassesProgramModel, CSharpClassElement>(Convert(delta.OldModel), Convert(delta.NewModel));
foreach (var cSharpFile in delta.ChangedElements)
{
result.ChangedElements.AddRange(GetContainedClasses(cSharpFile.GetContent()));
}
foreach (var cSharpFile in delta.AddedElements)
{
result.AddedElements.AddRange(GetContainedClasses(cSharpFile.GetContent()));
}
foreach (var cSharpFile in delta.DeletedElements)
{
result.DeletedElements.AddRange(GetContainedClasses(cSharpFile.GetContent()));
}
return(result);
}
public ISet <TTestCase> SelectTests(IntertypeRelationGraph dataStructure, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, StructuralDelta <CSharpClassesProgramModel, CSharpClassElement> programDelta, CancellationToken cancellationToken)
{
ISet <ImpactedTest <TTestCase> > impactedTests = new HashSet <ImpactedTest <TTestCase> >();
var changedTypes = new List <AffectedType>();
changedTypes.AddRange(programDelta.AddedElements.Select(x => new AffectedType {
Id = x.Id, ImpactedDueTo = x.Id
}));
changedTypes.AddRange(programDelta.ChangedElements.Select(x => new AffectedType {
Id = x.Id, ImpactedDueTo = x.Id
}));
var affectedTypes = new List <AffectedType>(changedTypes);
foreach (var type in changedTypes)
{
cancellationToken.ThrowIfCancellationRequested();
ExtendAffectedTypesAndReportImpactedTests(type, dataStructure, affectedTypes, testsDelta.NewModel.TestSuite, impactedTests, cancellationToken);
}
testsDelta.AddedElements.ForEach(x =>
{
if (impactedTests.All(y => y.TestCase.Id != x.Id))
{
impactedTests.Add(new ImpactedTest <TTestCase> {
TestCase = x, ImpactedDueTo = null
});
}
});
CorrespondenceModel = new CorrespondenceModel.Models.CorrespondenceModel
{
ProgramVersionId = programDelta.NewModel.VersionId,
CorrespondenceModelLinks = impactedTests.ToDictionary(
x => x.TestCase.Id,
x => x.ImpactedDueTo == null ? new HashSet <string>() : new HashSet <string>(new[] { x.ImpactedDueTo }))
};
return(new HashSet <TTestCase>(impactedTests.Select(x => x.TestCase)));
}
public async Task <StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase> > GetTestsDelta(TDelta programDelta, Func <MSTestTestcase, bool> filterFunction, CancellationToken token)
{
var oldTestsModel = testsModelAdapter.Parse(GetTestsStorage(programDelta.OldModel.VersionId));
if (!runConfiguration.DiscoverNewTests && oldTestsModel != null)
{
return(new StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase>(oldTestsModel, oldTestsModel));
}
if (oldTestsModel == null)
{
oldTestsModel = new TestsModel <MSTestTestcase>
{
TestSuite = new HashSet <MSTestTestcase>(),
VersionId = programDelta.OldModel.VersionId
};
}
var parsingResult = await assembliesAdapter.Parse(programDelta.NewModel.AbsoluteSolutionPath, token);
token.ThrowIfCancellationRequested();
var sources = parsingResult.Select(x => x.AbsolutePath).Where(x => x.EndsWith(settingsProvider.TestAssembliesFilter));
var vsTestCases = await DiscoverTests(sources, token);
var newTestsModel = new TestsModel <MSTestTestcase>
{
TestSuite = new HashSet <MSTestTestcase>(vsTestCases.Select(x => vsTestCaseAdapter.Parse(x)).Where(x => !x.Ignored && filterFunction(x))),
VersionId = programDelta.NewModel.VersionId
};
testsModelAdapter.Unparse(newTestsModel, GetTestsStorage(programDelta.NewModel.VersionId));
var testsDelta = new StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase>(oldTestsModel, newTestsModel);
testsDelta.AddedElements.AddRange(newTestsModel.TestSuite.Except(oldTestsModel.TestSuite));
testsDelta.DeletedElements.AddRange(oldTestsModel.TestSuite.Except(newTestsModel.TestSuite));
return(testsDelta);
}
public StructuralDelta <FilesProgramModel, FileElement> Discover(FilesProgramModel oldVersion, FilesProgramModel newVersion)
{
var delta = new StructuralDelta <FilesProgramModel, FileElement>(oldVersion, newVersion);
delta.AddedElements.AddRange(newVersion.Files.Where(x => oldVersion.Files.All(y => !x.Id.Equals(y.Id, StringComparison.Ordinal))));
delta.DeletedElements.AddRange(oldVersion.Files.Where(x => newVersion.Files.All(y => !x.Id.Equals(y.Id, StringComparison.Ordinal))));
var elementsExistingInBothVersion = oldVersion.Files.Where(x => newVersion.Files.Any(y => x.Id.Equals(y.Id, StringComparison.Ordinal)));
foreach (var element in elementsExistingInBothVersion)
{
var oldContent = element.GetContent();
var newContent = newVersion.Files.Single(x => x.Id == element.Id).GetContent();
if (!oldContent.Equals(newContent, StringComparison.Ordinal))
{
delta.ChangedElements.Add(element);
}
}
return(delta);
}
private void RemoveDeletedTests <TTestCase>(Models.CorrespondenceModel correspondenceModel, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta)
where TTestCase : ITestCase
{
testsDelta.DeletedElements.ForEach(x => correspondenceModel.CorrespondenceModelLinks.Remove(x.Id));
}
public void UpdateCorrespondenceModel <TProgramDelta, TTestCase>(CorrespondenceLinks correspondenceLinks, TProgramDelta programDelta, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, IEnumerable <string> failedTests)
where TProgramDelta : IDelta <TModel>
where TTestCase : ITestCase
{
var oldCorrespondenceModel = GetCorrespondenceModel(programDelta.OldModel, testsDelta.OldModel);
var newCorrespondenceModel = CloneModel(oldCorrespondenceModel, programDelta.NewModel.VersionId);
UpdateByNewLinks(newCorrespondenceModel, ConvertLinks(correspondenceLinks));
RemoveDeletedTests(newCorrespondenceModel, testsDelta);
RemoveFailedTests(newCorrespondenceModel, failedTests);
PersistCorrespondenceModel(newCorrespondenceModel);
}
public virtual async Task <ITestsExecutionResult <MSTestTestcase> > ProcessTests(IList <MSTestTestcase> impactedTests, StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase> testsDelta, TProgramDelta programDelta, CancellationToken cancellationToken)
{
msTestTestcases = impactedTests;
var vsTestResults = await ExecuteTests(msTestTestcases.Select(x => x.VsTestTestCase), cancellationToken);
var result = new MSTestExectionResult();
result.TestcasesResults.AddRange(testResultsAdapter.Parse(new VsTestResultsToConvert
{
MSTestTestcases = msTestTestcases,
Results = vsTestResults
}));
if (settingsProvider.CleanupTestResultsDirectory)
{
var resultsPath = Path.GetFullPath(MSTestConstants.TestResultsFolder);
DirectoryInfo resulsDirectory = new DirectoryInfo(resultsPath);
foreach (DirectoryInfo dir in resulsDirectory.EnumerateDirectories("Deploy*"))
{
dir.Delete(true);
}
}
return(result);
}
public Task <TestListResult <TTestCase> > ProcessTests(IList <TTestCase> impactedTests, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta, CancellationToken cancellationToken)
{
return(Task.FromResult(new TestListResult <TTestCase> {
IdentifiedTests = impactedTests
}));
}
public async Task <ITestsExecutionResult <TTestCase> > ProcessTests(IList <TTestCase> impactedTests, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta,
CancellationToken cancellationToken)
{
using (instrumentor)
{
applicationClosedHandler.AddApplicationClosedListener(instrumentor);
await instrumentor.Instrument(programDelta.NewModel, impactedTests, cancellationToken);
executor.TestResultAvailable += TestResultAvailable;
var result = await executor.ProcessTests(impactedTests, testsDelta, programDelta, cancellationToken);
executor.TestResultAvailable -= TestResultAvailable;
CorrespondenceLinks coverage = instrumentor.GetCorrespondenceLinks();
var failedTests = result.TestcasesResults.Where(x => x.Outcome == TestExecutionOutcome.Failed).Select(x => x.TestCase.Id).ToList();
var coveredTests = coverage.Links.Select(x => x.Item1).Distinct().ToList();
var testsWithoutCoverage = impactedTests.Where(x => !coveredTests.Contains(x.Id)).Select(x => x.Id).ToList();
testsWithoutCoverage.ForEach(x => loggingHelper.WriteMessage("Not covered: " + x));
failedTests.ForEach(x => loggingHelper.WriteMessage("Failed Tests: " + x));
testsWithoutCoverage.Except(failedTests).ForEach(x => loggingHelper.WriteMessage("Not covered and not failed Tests: " + x));
correspondenceModelManager.UpdateCorrespondenceModel(coverage, programDelta, testsDelta, failedTests);
applicationClosedHandler.RemovedApplicationClosedListener(instrumentor);
return(result);
}
}
public Task <PercentageImpactedTestsStatistic> ProcessTests(IList <TTestCase> impactedTests, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta, CancellationToken cancellationToken)
{
double percentage = (double)impactedTests.Count / testsDelta.NewModel.TestSuite.Count;
string deltaIdentifier = $"Delta: {programDelta.OldModel.VersionId} --> {programDelta.NewModel.VersionId}";
var statistcs = new PercentageImpactedTestsStatistic();
statistcs.DeltaIdPercentageTestsTuples.Add(new Tuple <string, double>(deltaIdentifier, percentage));
return(Task.FromResult(statistcs));
}
public IntendedChangesArtefact Unparse(StructuralDelta <FilesProgramModel, FileElement> model, IntendedChangesArtefact artefact)
{
throw new System.NotImplementedException();
}
public virtual async Task <ITestsExecutionResult <MSTestTestcase> > ProcessTests(IList <MSTestTestcase> impactedTests, StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase> testsDelta, TProgramDelta programDelta, CancellationToken cancellationToken)
{
var executionResult = new MSTestExectionResult();
CurrentlyExecutedTests = impactedTests;
CurrentlyExecutedTests = CurrentlyExecutedTests.Where(x => !x.Ignored).ToList();
if (CurrentlyExecutedTests.Any())
{
var arguments = BuildVsTestsArguments();
await ExecuteVsTestsByArguments(arguments, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
executionResult = ParseVsTestsTrxAnswer();
}
return(executionResult);
}
//TODO: Artefact Adapter
public Task <StructuralDelta <TestsModel <CsvFileTestcase>, CsvFileTestcase> > GetTestsDelta(TProgramDelta programDelta, Func <CsvFileTestcase, bool> filterFunction, CancellationToken token)
{
var csvFile = runConfigurationProvider.CsvTestsFile;
if (!File.Exists(csvFile))
{
throw new ArgumentException($"The CSV file '{csvFile}' does not exist!");
}
var oldTestsModel = testsModelAdapter.Parse(GetTestsStorage(programDelta.OldModel.VersionId));
if (oldTestsModel == null)
{
oldTestsModel = new TestsModel <CsvFileTestcase>
{
TestSuite = new HashSet <CsvFileTestcase>(),
VersionId = programDelta.OldModel.VersionId
};
}
TestsModel <CsvFileTestcase> newTestsModel = new TestsModel <CsvFileTestcase>
{
TestSuite = new HashSet <CsvFileTestcase>(),
VersionId = programDelta.NewModel.VersionId
};
foreach (string line in File.ReadAllLines(csvFile))
{
token.ThrowIfCancellationRequested();
string testName = line.Substring(0, line.IndexOf(';'));
string linkedClass = line.Substring(line.IndexOf(';') + 1);
var testCase = new CsvFileTestcase
{
Id = testName,
AssociatedClasses = new List <string> {
linkedClass
}
};
if (filterFunction(testCase))
{
var exisitingTest = newTestsModel.TestSuite.SingleOrDefault(x => x.Id == testCase.Id);
if (exisitingTest != null)
{
exisitingTest.AssociatedClasses.AddRange(testCase.AssociatedClasses);
}
else
{
newTestsModel.TestSuite.Add(testCase);
}
}
}
testsModelAdapter.Unparse(newTestsModel, GetTestsStorage(programDelta.NewModel.VersionId));
var testsDelta = new StructuralDelta <TestsModel <CsvFileTestcase>, CsvFileTestcase>(oldTestsModel, newTestsModel);
testsDelta.AddedElements.AddRange(newTestsModel.TestSuite.Except(oldTestsModel.TestSuite));
testsDelta.DeletedElements.AddRange(oldTestsModel.TestSuite.Except(newTestsModel.TestSuite));
return(Task.FromResult(testsDelta));
}
public StructuralDelta <TP, TPe> Convert(StructuralDelta <TP, TPe> delta)
{
return(delta);
}
public List <string> GetResponsibleChanges(ICorrespondenceModel correspondenceModel, TTestCase testCase, StructuralDelta <TModel, TModelElement> delta)
{
var selectionDelta = deltaAdapter.Convert(delta);
if (correspondenceModel == null)
{
return(new List <string>(new[] { "Responsible changes unkown!" }));
}
if (correspondenceModel.CorrespondenceModelLinks.ContainsKey(testCase.Id))
{
var linksOfTestcase = correspondenceModel.CorrespondenceModelLinks[testCase.Id];
return(linksOfTestcase.Where(x => selectionDelta.AddedElements.Any(y => y.Id == x) ||
selectionDelta.ChangedElements.Any(y => y.Id == x) ||
selectionDelta.DeletedElements.Any(y => y.Id == x)).ToList());
}
return(new List <string>());
}
public Task SelectTests(StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta, CancellationToken cancellationToken)
{
SelectedTests = testsDelta.NewModel.TestSuite;
return(Task.CompletedTask);
}
