Exemplo n.º 1
0
        protected virtual async Task <IEnumerable <int> > FetchFailedTestCaseIdsAsync(PipelineConfiguration pipelineConfiguration)
        {
            var testSummary = await _tcmApiHelper.GetTestSummaryAsync(pipelineConfiguration, null, TestOutcome.Failed);

            var resultsToQuery = testSummary.ResultsForGroup.SelectMany(rfg => rfg.Results);
            var testCaseIds    = new List <int>();

            if (resultsToQuery.Any())
            {
                // API supports only 100 results at a time
                Parallel.ForEach(resultsToQuery.Split(100), resultList =>
                {
                    var query = new TestResultsQuery()
                    {
                        Fields  = TestResultFieldsToQuery,
                        Results = resultList
                    };

                    var ids = _tcmApiHelper.GetTestResultsByQueryAsync(query)
                              .SyncResult().Results
                              .Where(r => !r.IsTestFlaky())
                              .Select(r => r.TestCaseReferenceId);

                    if (ids.Any())
                    {
                        lock (testSummary)
                        {
                            testCaseIds.AddRange(ids);
                        }
                    }
                });
            }

            return(testCaseIds);
        }
        public async Task AddReportDataAsync(AbstractReport reportData)
        {
            var failedTestResultIds = await _tcmApiHelper.GetTestSummaryAsync(TestResultsConstants.TestRun, TestOutcome.Failed);

            List <TestCaseResult> resultsToFetch = failedTestResultIds.ResultsForGroup.SelectMany(group => group.Results).ToList();

            reportData.FailedTestOwners = await _tcmApiHelper.GetTestResultOwnersAsync(resultsToFetch);

            _logger.LogInformation("Fetched test owners data");
        }
        private async Task <TestSummaryGroup> GetTestSummaryByPriorityAsync()
        {
            TestResultsDetails testSummaryItemsByRuns = await _tcmApiHelper.GetTestSummaryAsync(TestResultsConstants.Priority);

            var testResultDetailsParserForPriority = new TestResultDetailsParserForPriority(testSummaryItemsByRuns, _logger);
            var testSummaryByRun = new TestSummaryGroup
            {
                GroupingType = TestResultsGroupingType.Priority,
                Runs         = testResultDetailsParserForPriority.GetSummaryItems()
            };

            return(testSummaryByRun);
        }
        private async Task GetFilteredTestResultsAsync(AbstractReport reportData)
        {
            if (_reportDataConfiguration.IncludeFailedTests || _reportDataConfiguration.IncludeOtherTests ||
                _reportDataConfiguration.IncludePassedTests)
            {
                var groupBy          = TestResultsConstants.GetName(_reportDataConfiguration.GroupTestResultsBy);
                var includedOutcomes = GetIncludedOutcomes();

                var resultIdsToFetch = await _tcmApiHelper.GetTestSummaryAsync(groupBy, includedOutcomes.ToArray());

                reportData.HasFilteredTests = FilterTestResults(resultIdsToFetch, _reportDataConfiguration.MaxFailuresToShow);
                reportData.FilteredResults  = (await GetTestResultsWithWorkItemsAsync(resultIdsToFetch)).ToList();
            }
        }