Пример #1
0
        public void CollectAllTrackedTestMethodsTest()
        {
            var             mockLogger = new Mock <ITestImpactLogger>();
            ICoverageHandle converter  = new CollectAllTrackedTestMethodsProvider("", testPath, "", "", "", "", mockLogger.Object);
            var             impactTest = new ImpactedTest();
            var             parseData  = converter.GenerateImpactMapForTest(impactTest, new SortedSet <string>(), @"c:\", mockLogger.Object);

            Assert.That(parseData.Files.Count, Is.EqualTo(16));
        }
Пример #2
0
        public void CollectTrackedTestMethodsTestForInvalidNameGiveReport()
        {
            var             mockLogger = new Mock <ITestImpactLogger>();
            ICoverageHandle converter  = new CollectCoveredMethodsForTestProvider("", @"e:\prod\ts-build");
            var             impactTest = new ImpactedTest();

            impactTest.TestName   = "TestName";
            impactTest.TestMethod = "AnotherTestMethodName";
            var parseData = converter.GenerateImpactMapForTestGivenAReportFile(impactTest, new SortedSet <string>(), Path.Combine(testPath, "cov-FTC_7.xml"), mockLogger.Object);

            Assert.That(parseData.Files.Count, Is.EqualTo(31));
        }
Пример #3
0
        public void CollectTrackedTestMethodsTestForInvalidName()
        {
            var             mockLogger = new Mock <ITestImpactLogger>();
            ICoverageHandle converter  = new CollectCoveredMethodsForTestProvider("", testPath);
            var             impactTest = new ImpactedTest();

            impactTest.TestName   = "TestName";
            impactTest.TestMethod = "AnotherTestMethodName";
            var parseData = converter.GenerateImpactMapForTest(impactTest, new SortedSet <string>(), @"c:\", mockLogger.Object);

            Assert.That(parseData.Files.Count, Is.EqualTo(0));
        }
        public virtual async Task <TResult> ExecuteRTSRun(TProgramDelta programDelta, CancellationToken token)
        {
            var testsDelta = await loggingHelper.ReportNeededTime(() => testsDeltaAdapter.GetTestsDelta(programDelta, FilterFunction, token), "Tests Discovery");

            token.ThrowIfCancellationRequested();

            await loggingHelper.ReportNeededTime(() => testSelector.SelectTests(testsDelta, programDelta, token), "Tests Selection");

            var impactedTests = testSelector.SelectedTests;

            foreach (var impactedTest in impactedTests)
            {
                token.ThrowIfCancellationRequested();
                ImpactedTest?.Invoke(this, new ImpactedTestEventArgs <TTestCase>(impactedTest,
                                                                                 responsibleChangesReporter.GetResponsibleChanges(testSelector.CorrespondenceModel, impactedTest, programDelta)));
            }

            loggingHelper.WriteMessage($"{impactedTests.Count} Tests impacted");

            var prioritizedTests = await loggingHelper.ReportNeededTime(() => testPrioritizer.PrioritizeTests(impactedTests, token), "Tests Prioritization");

            TestsPrioritized?.Invoke(this, new TestsPrioritizedEventArgs <TTestCase>(prioritizedTests));

            var executor = testProcessor as ITestExecutor <TTestCase, TProgramDelta, TProgram>;

            if (executor != null)
            {
                executor.TestResultAvailable += TestResultAvailable;
            }
            var processingResult = await loggingHelper.ReportNeededTime(() => testProcessor.ProcessTests(prioritizedTests, testsDelta, programDelta, token), "Tests Processing");

            if (executor != null)
            {
                executor.TestResultAvailable -= TestResultAvailable;
            }

            return(processingResult);
        }