public async Task <List <IdentityRef> > GetTestResultOwnersAsync(IList <TestCaseResult> resultIds)
{
using (new PerformanceMeasurementBlock("Fetching Test result owners", _logger))
{
var fieldsToFetch = new List <string>
{
FieldNameConstants.Owner
};
List <List <TestCaseResult> > chunks = resultIds.Split(MaxItemsSupported);
IList <TestCaseResult>[] chunkResults = await chunks.ParallelSelectAsync(async chunk =>
{
// TODO - retry
TestResultsQuery resultQuery = // RetryHelper.Retry(() =>
await _tcmClient.GetTestResultsByQueryAsync(_emailReportConfig.PipelineConfiguration.ProjectId, new TestResultsQuery
{
Fields = fieldsToFetch,
Results = chunk
});
return(resultQuery.Results);
});
return(chunkResults.Merge()
.Where(tcr => IdentityRefHelper.IsValid(tcr.Owner))
.Select(tcr => tcr.Owner)
.DistinctBy(identity => IdentityRefHelper.GetUniqueName(identity).ToLowerInvariant())
.ToList());
}
}
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);
}
private async Task <UserResultsViewModel> AggregateUserResults(string userId, IDictionary <string, int> userRanking)
{
var user = await _context.Users.FindAsync(userId);
var contest = await _context.Contests.FindAsync(ContestId);
var taskScoreQueries = contest.Tasks.Select(t => TaskScoreQuery.Create(t.Id, user.Id));
var taskResults = new List <TaskWithTestResults>();
var taskScores = new List <TaskScoreQueryResult>();
foreach (var query in taskScoreQueries)
{
var taskScore = await _taskScoreQueryHandler.HandleAsync(query);
var task = await _context.Tasks.FindAsync(query.TaskId);
var tests = _context.Tests.Where(t => t.TaskId == task.Id);
var solution = await _context.Solutions
.Where(s => s.TaskId == task.Id && s.IdentityUser.Id == userId)
.DefaultIfEmpty()
.SingleAsync();
var testResults = new List <TestResultsQueryResult>();
if (solution != null)
{
foreach (var test in tests)
{
var testResultsQuery = TestResultsQuery.Create(test.Id, solution.Id);
var testResult = await _testResultsQueryHandler.HandleAsync(testResultsQuery);
testResults.Add(testResult);
}
}
taskResults.Add(new TaskWithTestResults(taskScore, testResults));
}
return(MapToUserResultsViewModel(user.UserName, userRanking[userId], taskResults));
}
public override async Task <TestResultsQuery> GetTestResultsByQueryAsync(TestResultsQuery query)
{
return // TODO - RetryHelper.Retry(() =>
(await _tcmClient.GetTestResultsByQueryAsync(_emailReportConfig.PipelineConfiguration.ProjectName, query));
}
public abstract Task <TestResultsQuery> GetTestResultsByQueryAsync(TestResultsQuery query);
public Task <TestResultsQuery> GetTestResultsByQueryAsync(string project, TestResultsQuery query)
{
return(_tcm.GetTestResultsByQueryAsync(query, project));
}
