private async Task UploadTestSubResultsAttachmentAsync(int testRunId,
int testResultId,
TestCaseSubResultData subResultData,
TestSubResult subresult,
int level,
CancellationToken cancellationToken)
{
if (level > TestManagementConstants.maxHierarchyLevelForSubresults || subresult == null || subResultData == null || subResultData.AttachmentData == null)
{
return;
}
string[] attachments = subResultData.AttachmentData.AttachmentsFilePathList?.ToArray();
// remove duplicate entries
HashSet <string> attachedFiles = GetUniqueTestRunFiles(attachments);
if (attachedFiles != null && attachedFiles.Any())
{
var createAttachmentsTasks = attachedFiles
.Select(async attachment =>
{
TestAttachmentRequestModel reqModel = GetAttachmentRequestModel(attachment);
if (reqModel != null)
{
await _testResultsServer.CreateTestSubResultAttachmentAsync(reqModel, _projectName, testRunId, testResultId, subresult.Id, cancellationToken);
}
});
await Task.WhenAll(createAttachmentsTasks);
}
// Upload console log as attachment
string consoleLog = subResultData.AttachmentData.ConsoleLog;
TestAttachmentRequestModel attachmentRequestModel = GetConsoleLogAttachmentRequestModel(consoleLog);
if (attachmentRequestModel != null)
{
await _testResultsServer.CreateTestSubResultAttachmentAsync(attachmentRequestModel, _projectName, testRunId, testResultId, subresult.Id, cancellationToken);
}
// Upload standard error as attachment
string standardError = subResultData.AttachmentData.StandardError;
TestAttachmentRequestModel stdErrAttachmentRequestModel = GetStandardErrorAttachmentRequestModel(standardError);
if (stdErrAttachmentRequestModel != null)
{
await _testResultsServer.CreateTestSubResultAttachmentAsync(stdErrAttachmentRequestModel, _projectName, testRunId, testResultId, subresult.Id, cancellationToken);
}
if (subResultData.SubResultData != null)
{
for (int i = 0; i < subResultData.SubResultData.Count; ++i)
{
await UploadTestSubResultsAttachmentAsync(testRunId, testResultId, subResultData.SubResultData[i], subresult.SubResults[i], level + 1, cancellationToken);
}
}
}
private static void ConvertSubResults(TestCaseSubResultData testCaseSubResultData, TestSubResult testSubResultWebApi)
{
if (testCaseSubResultData.SubResultData == null || !testCaseSubResultData.SubResultData.Any())
{
return;
}
testSubResultWebApi.SubResults = new List <TestSubResult>();
foreach (var subResultData in testCaseSubResultData.SubResultData)
{
var subResultWebApi = new TestSubResult();
TestCaseSubResultDataConverter.Convert(subResultData, subResultWebApi);
testSubResultWebApi.SubResults.Add(subResultWebApi);
}
}
public static void Convert(TestCaseSubResultData testCaseSubResultData, TestSubResult testSubResultWebApi)
{
testSubResultWebApi.CompletedDate = testCaseSubResultData.CompletedDate;
testSubResultWebApi.Comment = testCaseSubResultData.Comment;
testSubResultWebApi.ComputerName = testCaseSubResultData.ComputerName;
testSubResultWebApi.Configuration = testCaseSubResultData.Configuration;
testSubResultWebApi.CustomFields = testCaseSubResultData.CustomFields;
testSubResultWebApi.DurationInMs = testCaseSubResultData.DurationInMs;
testSubResultWebApi.DisplayName = testCaseSubResultData.DisplayName;
testSubResultWebApi.ErrorMessage = testCaseSubResultData.ErrorMessage;
testSubResultWebApi.Id = testCaseSubResultData.Id;
testSubResultWebApi.LastUpdatedDate = testCaseSubResultData.LastUpdatedDate;
testSubResultWebApi.Outcome = testCaseSubResultData.Outcome;
testSubResultWebApi.ParentId = testCaseSubResultData.ParentId;
testSubResultWebApi.ResultGroupType = testCaseSubResultData.ResultGroupType;
testSubResultWebApi.StackTrace = testCaseSubResultData.StackTrace;
testSubResultWebApi.SequenceId = testCaseSubResultData.SequenceId;
testSubResultWebApi.StartedDate = testCaseSubResultData.StartedDate;
testSubResultWebApi.TestResult = testCaseSubResultData.TestResult;
testSubResultWebApi.Url = testCaseSubResultData.Url;
ConvertSubResults(testCaseSubResultData, testSubResultWebApi);
}
public TestRunPublisherTests()
{
_attachmentFilePath = "attachment.txt";
File.WriteAllText(_attachmentFilePath, "asdf");
_testRunContext = new TestRunContext("owner", "platform", "config", 1, "builduri", "releaseuri", "releaseenvuri");
_reader = new Mock <IResultReader>();
_reader.Setup(x => x.ReadResults(It.IsAny <IExecutionContext>(), It.IsAny <string>(), It.IsAny <TestRunContext>()))
.Callback <IExecutionContext, string, TestRunContext>
((executionContext, filePath, runContext) =>
{
_runContext = runContext;
_resultsFilepath = filePath;
})
.Returns((IExecutionContext executionContext, string filePath, TestRunContext runContext) =>
{
TestRunData trd = new TestRunData(
name: "xyz",
buildId: runContext.BuildId,
completedDate: "",
state: "InProgress",
isAutomated: true,
dueDate: "",
type: "",
buildFlavor: runContext.Configuration,
buildPlatform: runContext.Platform,
releaseUri: runContext.ReleaseUri,
releaseEnvironmentUri: runContext.ReleaseEnvironmentUri
);
trd.Attachments = new string[] { "attachment.txt" };
return(trd);
});
_testResultServer = new Mock <ITestResultsServer>();
_testResultServer.Setup(x => x.InitializeServer(It.IsAny <VssConnection>(), It.IsAny <IExecutionContext>()));
_testResultServer.Setup(x => x.AddTestResultsToTestRunAsync(It.IsAny <TestCaseResult[]>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <TestCaseResult[], string, int, CancellationToken>
((currentBatch, projectName, testRunId, cancellationToken) =>
{
_batchSizes.Add(currentBatch.Length);
_resultCreateModels = currentBatch;
})
.Returns(() =>
{
List <TestCaseResult> resultsList = new List <TestCaseResult>();
int i = 0;
int j = 1;
foreach (TestCaseResult resultCreateModel in _resultCreateModels)
{
List <TestSubResult> SubResults = null;
if (resultCreateModel.SubResults != null)
{
SubResults = new List <TestSubResult>();
foreach (var subresultdata in resultCreateModel.SubResults)
{
var subResult = new TestSubResult();
subResult.Id = j++;
SubResults.Add(subResult);
}
}
resultsList.Add(new TestCaseResult()
{
Id = ++i, SubResults = SubResults
});
}
return(Task.FromResult(resultsList));
});
_testResultServer.Setup(x => x.CreateTestRunAsync(It.IsAny <string>(), It.IsAny <RunCreateModel>(), It.IsAny <CancellationToken>()))
.Callback <string, RunCreateModel, CancellationToken>
((projectName, testRunData, cancellationToken) =>
{
_projectId = projectName;
_testRun = (TestRunData)testRunData;
})
.Returns(Task.FromResult(new TestRun()
{
Name = "TestRun", Id = 1
}));
_testResultServer.Setup(x => x.UpdateTestRunAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <RunUpdateModel>(), It.IsAny <CancellationToken>()))
.Callback <string, int, RunUpdateModel, CancellationToken>
((projectName, testRunId, updateModel, cancellationToken) =>
{
_runId = testRunId;
_projectId = projectName;
_updateProperties = updateModel;
})
.Returns(Task.FromResult(new TestRun()
{
Name = "TestRun", Id = 1
}));
_testResultServer.Setup(x => x.CreateTestRunAttachmentAsync(
It.IsAny <TestAttachmentRequestModel>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <TestAttachmentRequestModel, string, int, CancellationToken>
((reqModel, projectName, testRunId, cancellationToken) =>
{
_attachmentRequestModel = reqModel;
_projectId = projectName;
_runId = testRunId;
})
.Returns(Task.FromResult(new TestAttachmentReference()));
_testResultServer.Setup(x => x.CreateTestResultAttachmentAsync(It.IsAny <TestAttachmentRequestModel>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <TestAttachmentRequestModel, string, int, int, CancellationToken>
((reqModel, projectName, testRunId, testCaseResultId, cancellationToken) =>
{
if (_resultsLevelAttachments.ContainsKey(testCaseResultId))
{
_resultsLevelAttachments[testCaseResultId].Add(reqModel);
}
else
{
_resultsLevelAttachments.Add(testCaseResultId, new List <TestAttachmentRequestModel>()
{
reqModel
});
}
})
.Returns(Task.FromResult(new TestAttachmentReference()));
_testResultServer.Setup(x => x.CreateTestSubResultAttachmentAsync(It.IsAny <TestAttachmentRequestModel>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <TestAttachmentRequestModel, string, int, int, int, CancellationToken>
((reqModel, projectName, testRunId, testCaseResultId, testSubResultId, cancellationToken) =>
{
if (_subResultsLevelAttachments.ContainsKey(testCaseResultId))
{
if (_subResultsLevelAttachments[testCaseResultId].ContainsKey(testSubResultId))
{
_subResultsLevelAttachments[testCaseResultId][testSubResultId].Add(reqModel);
}
else
{
_subResultsLevelAttachments[testCaseResultId].Add(testSubResultId, new List <TestAttachmentRequestModel>()
{
reqModel
});
}
}
else
{
Dictionary <int, List <TestAttachmentRequestModel> > subResulAtt = new Dictionary <int, List <TestAttachmentRequestModel> >();
subResulAtt.Add(testSubResultId, new List <TestAttachmentRequestModel>()
{
reqModel
});
_subResultsLevelAttachments.Add(testCaseResultId, subResulAtt);
}
})
.Returns(Task.FromResult(new TestAttachmentReference()));
}
