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); }