/// <summary>
/// Update Test Runs.
/// </summary>
/// <returns>Task.</returns>
private static async Task UpdateTestRunsAsync()
{
foreach (var testRunId in NewTestRunIds)
{
await AzureDevOpsUtility.UpdateTestRunAsync(tr, testRunId).ConfigureAwait(false);
}
}
/// <summary>
/// Upload TRX file as an Attachment.
/// </summary>
/// <param name="file">TRX file.</param>
/// <returns>Task.</returns>
private static async Task UploadTrxFileAsTestRunAttachment(string file)
{
foreach (var testRunId in NewTestRunIds)
{
await AzureDevOpsUtility.AddAttachmentToTestRunAsync(testRunId, file, NewTestRunIds).ConfigureAwait(false);
}
}
/// <summary>
/// Get Test Cases in each Test Plan.
/// </summary>
/// <returns>Task.</returns>
private static async Task GetTestCasesByPlanAsync()
{
var allWorkItems = new Dictionary <string, JObject>();
foreach (var item in AutomatedTestNames.Distinct())
{
allWorkItems.Add(item, await AzureDevOpsUtility.GetWorkItemsWithAutomatedTestNameAsAsync(item).ConfigureAwait(false));
}
foreach (var key in allWorkItems.Keys)
{
var result = allWorkItems[key];
if (result.SelectToken("workItems").Count() != 0)
{
var workItems = result.SelectToken("workItems");
foreach (var workItem in workItems)
{
TestCases.AddRange(await CommonUtility.GetCasesAsync(workItem, TestSuiteIds, Consideration).ConfigureAwait(false));
}
}
else
{
Log.Information($"No Test-case is found with Automated Test Name as: {key}");
}
}
TestCasesByPlanId = TestCases.GroupBy(y => y.TestPlanId).OrderBy(z => z.Key).ToList();
}
/// <summary>
/// Create new Test Run.
/// </summary>
/// <returns>Task.</returns>
private static async Task CreateNewTestRunsAsync()
{
for (var i = 0; i < TestCasesByPlanId.Count; i++)
{
var testPlanId = TestCasesByPlanId[i].Select(x => int.Parse(x.TestPlanId)).FirstOrDefault();
NewTestRunIds.Add((await AzureDevOpsUtility.CreateNewTestRunAsync(tr, testPlanId, TestPointIds[testPlanId.ToString()].ToArray()).ConfigureAwait(false)).SelectToken("id").ToString());
}
}
/// <summary>
/// Delete Test Runs.
/// </summary>
/// <returns>Task.</returns>
public static async Task DeleteTestRunsAsync(List <string> testRunIds)
{
if (testRunIds.Count() > 0)
{
foreach (var testRunId in testRunIds)
{
await AzureDevOpsUtility.DeleteTestRunAsync(testRunId).ConfigureAwait(false);
}
}
}
/// <summary>
/// Get Test Point Ids.
/// </summary>
/// <returns>Task.</returns>
private static async Task GetTestPointIdsAsync()
{
var testCasesIds = TestCases.Select(x => x.TestCaseId).Distinct();
if (testCasesIds.Count() > 0)
{
var result = await AzureDevOpsUtility.GetTestPointsByTestCaseIdsAsync(testCasesIds).ConfigureAwait(false);
TestPointIds = CommonUtility.GetTestPointsThatNeedsToBePartOfNewTestRunAsync(TestCases, result, TestSuiteIds, Consideration);
}
}
/// <summary>
/// Update Test Runs.
/// </summary>
/// <returns>Task.</returns>
private static async Task UpdateTestRunsAsync()
{
foreach (var testRunId in NewTestRunIds)
{
var testresults = await AzureDevOpsUtility.GetTestResultsOfATestRunAsync(testRunId).ConfigureAwait(false);
var resultArray = new List <object>();
foreach (var testresult in testresults.SelectToken("value").ToList())
{
var result = TestResults.TestCases.FirstOrDefault(z => z.TestCaseId.ToString().Equals(testresult.SelectToken("testCase.id").ToString()));
resultArray.Add(new { id = testresult.SelectToken("id"), state = Constants.Completed, outcome = result.Outcome.ToString(), durationInMs = 1000 });
}
await AzureDevOpsUtility.UpdateTestResultsOfATestRunAsync(testRunId, resultArray).ConfigureAwait(false);
await AzureDevOpsUtility.UpdateTestRunAsync(Tr, testRunId).ConfigureAwait(false);
}
}
/// <summary>
/// Create new Test Run.
/// </summary>
/// <returns>Task.</returns>
private static async Task CreateNewTestRunsAsync()
{
Tr = new TestRun
{
name = $"ManualTestRun_{DateTime.Now}",
Times = new TestRunTimes
{
start = DateTime.Now,
finish = DateTime.Now.AddHours(1)
}
};
for (var i = 0; i < TestCasesByPlanId.Count; i++)
{
var testPlanId = TestCasesByPlanId[i].Select(x => int.Parse(x.TestPlanId)).FirstOrDefault();
NewTestRunIds.Add((await AzureDevOpsUtility.CreateNewTestRunAsync(Tr, testPlanId, TestPointIds[testPlanId.ToString()].ToArray(), false).ConfigureAwait(false)).SelectToken("id").ToString());
}
}
/// <summary>
/// Update Test Results from TRX file.
/// </summary>
/// <returns>Task.</returns>
private static async Task UpdateTestResultsAsync()
{
foreach (var testRunId in NewTestRunIds)
{
var testresults = await AzureDevOpsUtility.GetTestResultsOfATestRunAsync(testRunId).ConfigureAwait(false);
var resultArray = new List <object>();
foreach (var testresult in testresults.SelectToken("value").ToList())
{
var testResultsFromTrx = TestResults.Where(x => (x.ClassName + "." + x.TestName.Split('(')[0]).Equals(testresult.SelectToken("automatedTestName").ToString()));
var testResult = testResultsFromTrx.Any(x => x.Outcome.Equals(Constants.Failed)) ? testResultsFromTrx.FirstOrDefault(x => x.Outcome.Equals(Constants.Failed)) : testResultsFromTrx.All(x => x.Outcome.Equals(Constants.NotExecuted)) ? testResultsFromTrx.FirstOrDefault() : testResultsFromTrx.FirstOrDefault(x => x.Outcome.Equals(Constants.Passed));
var(errorMessage, trace) = GetErrorMessageAndStackTrace(testResult, testResultsFromTrx);
resultArray.Add(new { id = testresult.SelectToken("id"), state = Constants.Completed, durationInMs = testResultsFromTrx.Sum(x => x.Duration.Value.Milliseconds), outcome = testResult.Outcome, computerName = testResult.ComputerName, errorMessage, stackTrace = trace });
}
await AzureDevOpsUtility.UpdateTestResultsOfATestRunAsync(testRunId, resultArray).ConfigureAwait(false);
}
}
/// <summary>
/// Get Test Point Ids.
/// </summary>
/// <returns>Task.</returns>
private static async Task GetTestPointIdsAsync()
{
var testCasesIds = TestCases.Select(x => x.TestCaseId).Distinct();
if (testCasesIds.Count() > 0)
{
var result = await AzureDevOpsUtility.GetTestPointsByTestCaseIdsAsync(testCasesIds).ConfigureAwait(false);
var points = result.SelectToken("points");
TestCases.Select(x => x.TestPlanId).Distinct().ToList().ForEach(y =>
{
var testCasesInThisPlan = TestCases.Where(l => l.TestPlanId.Equals(y)).GroupBy(m => m.TestCaseId).OrderBy(n => n.Key).ToList();
var tps = new List <string>();
foreach (var item in testCasesInThisPlan)
{
var testSuitesFromTestPointsOfThisTestCase = points.ToList().Where(r => r.SelectToken("testCase.id").ToString().Equals(item.Key) && r.SelectToken("testPlan.id").ToString().Equals(y)).ToList();
if (testSuitesFromTestPointsOfThisTestCase.Count > 1)
{
var tctsId = TestResults.TestCases.FirstOrDefault(z => z.TestCaseId.ToString().Equals(item.Key)).TestSuiteId;
var sId = TestResults.SuiteId;
if (tctsId != 0)
{
var point = testSuitesFromTestPointsOfThisTestCase.FirstOrDefault(z => z.SelectToken("suite.id").ToString().Equals(tctsId.ToString())).SelectToken("id").ToString();
tps.Add(point);
}
else if (sId != 0)
{
tps.Add(testSuitesFromTestPointsOfThisTestCase.FirstOrDefault(z => z.SelectToken("suite.id").ToString().Equals(sId.ToString())).SelectToken("id").ToString());
}
else
{
tps.AddRange(testSuitesFromTestPointsOfThisTestCase.Select(z => z.SelectToken("id").ToString()));
}
}
else
{
tps.Add(testSuitesFromTestPointsOfThisTestCase.FirstOrDefault().SelectToken("id").ToString());
}
}
TestPointIds.Add(y, tps);
});
}
}
/// <summary>
/// Get Test Cases to be updated in Azure DevOps.
/// </summary>
/// <param name="workItem">WorkItem object.</param>
/// <param name="testSuiteIds">Test Suite Ids.</param>
/// <param name="consideration">Consideration of Test Suite Ids.</param>
/// <returns>List of Test Cases.</returns>
public static async Task <List <TestCase> > GetCasesAsync(JToken workItem, IEnumerable <string> testSuiteIds, bool consideration)
{
var testCases = new List <TestCase>();
var testCaseId = workItem.SelectToken("id").ToString();
var testSuites = await AzureDevOpsUtility.GetTestSuitesByTestCaseIdAsync(testCaseId).ConfigureAwait(false);
var testSuitesValues = testSuites.SelectToken("value").ToList();
foreach (var testSuite in testSuitesValues)
{
var testSuiteId = testSuite.SelectToken("id").ToString();
var testPlanId = testSuite.SelectToken("plan.id").ToString();
if (!consideration && (testSuiteIds.Count() > 0))
{
if (testSuiteIds.Contains(testSuiteId))
{
testCases.Add(new TestCase(testCaseId, testSuiteId, testPlanId));
}
}
else if (consideration && (testSuiteIds.Count() > 0))
{
if (testSuitesValues.Count > 1)
{
if (testSuiteIds.Contains(testSuiteId))
{
testCases.Add(new TestCase(testCaseId, testSuiteId, testPlanId));
}
}
else
{
testCases.Add(new TestCase(testCaseId, testSuiteId, testPlanId));
}
}
else
{
testCases.Add(new TestCase(testCaseId, testSuiteId, testPlanId));
}
}
return(testCases);
}
/// <summary>
/// Update Test Results.
/// </summary>
/// <param name="filePath">TRX file path.</param>
/// <param name="account">Account.</param>
/// <param name="project">Project.</param>
/// <param name="token">PAT.</param>
/// <param name="testSuiteIds">Test Suite Ids.</param>
/// <param name="consideration">Consideration of specified Test Suite Ids.</param>
/// <returns>Integer.</returns>
public static int UpdateTestResults(string filePath, string account, string project, string token, IEnumerable <string> testSuiteIds, bool consideration)
{
TestSuiteIds = testSuiteIds;
Consideration = consideration;
AzureDevOpsUtility.UpdateAccountDetails(account, project, token);
try
{
ParseTestRun(filePath);
GetAutomatedTestNames();
GetTestCasesByPlanAsync().GetAwaiter().GetResult();
GetTestPointIdsAsync().GetAwaiter().GetResult();
CreateNewTestRunsAsync().GetAwaiter().GetResult();
UpdateTestResultsAsync().GetAwaiter().GetResult();
UploadTrxFileAsTestRunAttachment(filePath).GetAwaiter().GetResult();
UpdateTestRunsAsync().GetAwaiter().GetResult();
}
catch (Exception e)
{
CommonUtility.DeleteTestRunsAsync(NewTestRunIds).GetAwaiter().GetResult();
throw e;
}
return(0);
}
/// <summary>
/// Update Test Results.
/// </summary>
/// <param name="filePath">file path.</param>
/// <param name="isJson">Is input file type Json?</param>
/// <param name="account">Account.</param>
/// <param name="project">Project.</param>
/// <param name="token">Token.</param>
/// <returns>Integer.</returns>
public static int UpdateTestResults(string filePath, bool isJson, string account, string project, string token)
{
AzureDevOpsUtility.UpdateAccountDetails(account, project, token);
if (isJson)
{
var json = File.ReadAllText(filePath);
TestResults = JsonConvert.DeserializeObject <TestResults>(json);
}
else
{
var excel = new ExcelMapper(filePath);
excel.AddMapping <TestCaseOutcome>("TestCaseId", t => t.TestCaseId);
excel.AddMapping <TestCaseOutcome>("TestSuiteId", t => t.TestSuiteId);
excel.AddMapping <TestCaseOutcome>("Outcome", t => t.Outcome)
.SetPropertyUsing(v =>
{
if ((v as string).Equals(Constants.NotExecuted))
{
return(OutcomeType.NotExecuted);
}
if ((v as string).Equals(Constants.Failed))
{
return(OutcomeType.Failed);
}
else
{
return(OutcomeType.Passed);
}
});
var testCases = excel.Fetch <TestCaseOutcome>().ToList();
TestResults = new TestResults()
{
SuiteId = 0,
TestCases = testCases
};
}
try
{
GetTestCasesByPlanAsync().GetAwaiter().GetResult();
GetTestPointIdsAsync().GetAwaiter().GetResult();
CreateNewTestRunsAsync().GetAwaiter().GetResult();
UpdateTestRunsAsync().GetAwaiter().GetResult();
}
catch (FlurlHttpException e)
{
var statusCode = e.Call.Response.StatusCode.ToString();
if (statusCode.Equals(Constants.NonAuthoritativeInformation) || statusCode.Equals(Constants.Unauthorized))
{
Log.Error("Authentication Error!!! Please provide valid Account Details...\n");
}
}
catch (Exception e)
{
CommonUtility.DeleteTestRunsAsync(NewTestRunIds).GetAwaiter().GetResult();
throw e;
}
return(0);
}
/// <summary>
/// Get TestCases to be updated.
/// </summary>
/// <returns>Task.</returns>
private static async Task GetTestCasesByPlanAsync()
{
foreach (var testCase in TestResults.TestCases)
{
var testCaseId = testCase.TestCaseId.ToString();
var tsId = testCase.TestSuiteId.ToString();
JObject testSuites;
try
{
testSuites = await AzureDevOpsUtility.GetTestSuitesByTestCaseIdAsync(testCaseId).ConfigureAwait(false);
}
catch (FlurlHttpException e)
{
var statusCode = e.Call.Response.StatusCode.ToString();
if (statusCode.Equals(Constants.NotFound))
{
Log.Information($"No Test-case is found with Id - {testCaseId}");
continue;
}
else
{
throw e;
}
}
var testSuitesValues = testSuites.SelectToken("value").ToList();
if (testSuitesValues.Any())
{
if (testCase.TestSuiteId != 0)
{
var result = testSuitesValues.Any(x => x.SelectToken("id").ToString().Equals(tsId));
if (!result)
{
Log.Information($"Test-Case Id: {testCase.TestCaseId} is not present in Test-Suite: {tsId}");
continue;
}
else
{
var testPlanId = testSuitesValues.FirstOrDefault(x => x.SelectToken("id").ToString().Equals(tsId)).SelectToken("plan.id").ToString();
TestCases.Add(new TestCase(testCaseId, tsId, testPlanId));
}
}
else if (TestResults.SuiteId != 0)
{
var suiteId = TestResults.SuiteId.ToString();
var result = testSuitesValues.Any(x => x.SelectToken("id").ToString().Equals(suiteId));
if (!result)
{
Log.Information($"Test-Case Id: {testCase.TestCaseId} is not present in Test-Suite: {suiteId}");
continue;
}
else
{
var testPlanId = testSuitesValues.FirstOrDefault(x => x.SelectToken("id").ToString().Equals(suiteId)).SelectToken("plan.id").ToString();
TestCases.Add(new TestCase(testCaseId, suiteId, testPlanId));
}
}
else
{
foreach (var testSuite in testSuitesValues)
{
var testSuiteId = testSuite.SelectToken("id").ToString();
var testPlanId = testSuite.SelectToken("plan.id").ToString();
TestCases.Add(new TestCase(testCaseId, testSuiteId, testPlanId));
}
}
}
}
TestCasesByPlanId = TestCases.GroupBy(y => y.TestPlanId).OrderBy(z => z.Key).ToList();
}
