private void AddVariousLogsForResultIfOutcomeIsFailed(TestCaseResultData resultCreateModel, XmlNode resultNode) { if (!resultCreateModel.Outcome.Equals("Failed")) { return; } XmlNode errorMessage, errorStackTrace, consoleLog, standardError; if ((errorMessage = resultNode.SelectSingleNode("./Output/ErrorInfo/Message")) != null && !string.IsNullOrWhiteSpace(errorMessage.InnerText)) { resultCreateModel.ErrorMessage = errorMessage.InnerText; } // stack trace if ((errorStackTrace = resultNode.SelectSingleNode("./Output/ErrorInfo/StackTrace")) != null && !string.IsNullOrWhiteSpace(errorStackTrace.InnerText)) { resultCreateModel.StackTrace = errorStackTrace.InnerText; } // console log if ((consoleLog = resultNode.SelectSingleNode("./Output/StdOut")) != null && !string.IsNullOrWhiteSpace(consoleLog.InnerText)) { resultCreateModel.AttachmentData.ConsoleLog = consoleLog.InnerText; } // standard error if ((standardError = resultNode.SelectSingleNode("./Output/StdErr")) != null && !string.IsNullOrWhiteSpace(standardError.InnerText)) { resultCreateModel.AttachmentData.StandardError = standardError.InnerText; } }
private TestCaseResultData getTestCaseResultData(XmlNode testCaseResultNode, string assemblyName, string hostname) { var testCaseResultData = new TestCaseResultData(); if (!string.IsNullOrEmpty(assemblyName)) { testCaseResultData.AutomatedTestStorage = assemblyName; } testCaseResultData.ComputerName = hostname; testCaseResultData.TestCaseTitle = testCaseResultNode.Attributes["name"]?.Value; testCaseResultData.AutomatedTestName = testCaseResultNode.Attributes["fullname"]?.Value; double duration = 0; double.TryParse(testCaseResultNode.Attributes["duration"]?.Value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out duration); testCaseResultData.DurationInMs = TimeSpan.FromSeconds(duration).TotalMilliseconds; var testExecutionStartedOn = DateTime.MinValue; DateTime.TryParse(testCaseResultNode.Attributes["start-time"]?.Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out testExecutionStartedOn); testCaseResultData.StartedDate = testExecutionStartedOn; var testExecutionEndedOn = DateTime.MinValue; DateTime.TryParse(testCaseResultNode.Attributes["end-time"]?.Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out testExecutionEndedOn); testCaseResultData.CompletedDate = testExecutionEndedOn; if (testCaseResultNode.Attributes["result"] != null) { if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Passed", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.Passed.ToString(); } else if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Failed", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.Failed.ToString(); } else if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Skipped", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.NotExecuted.ToString(); } else { testCaseResultData.Outcome = TestOutcome.Inconclusive.ToString(); } var failureNode = testCaseResultNode.SelectSingleNode("failure"); if (failureNode != null) { var failureMessageNode = failureNode.SelectSingleNode("message"); var failureStackTraceNode = failureNode.SelectSingleNode("stack-trace"); testCaseResultData.ErrorMessage = failureMessageNode?.InnerText; testCaseResultData.StackTrace = failureStackTraceNode?.InnerText; } } testCaseResultData.State = "Completed"; testCaseResultData.AutomatedTestType = "NUnit"; if (_runUserIdRef != null) { testCaseResultData.RunBy = _runUserIdRef; testCaseResultData.Owner = _runUserIdRef; } return(testCaseResultData); }
/// <summary> /// Publishes the given results to the test run. /// </summary> /// <param name="testResults">Results to be published.</param> public async Task AddResultsAsync(TestRun testRun, TestCaseResultData[] testResults, CancellationToken cancellationToken) { Trace.Entering(); int noOfResultsToBePublished = BATCH_SIZE; _executionContext.Output(StringUtil.Loc("PublishingTestResults", testRun.Id)); for (int i = 0; i < testResults.Length; i += BATCH_SIZE) { cancellationToken.ThrowIfCancellationRequested(); if (i + BATCH_SIZE >= testResults.Length) { noOfResultsToBePublished = testResults.Length - i; } _executionContext.Output(StringUtil.Loc("TestResultsRemaining", (testResults.Length - i), testRun.Id)); var currentBatch = new TestCaseResultData[noOfResultsToBePublished]; Array.Copy(testResults, i, currentBatch, 0, noOfResultsToBePublished); List<TestCaseResult> testresults = await _testResultsServer.AddTestResultsToTestRunAsync(currentBatch, _projectName, testRun.Id, cancellationToken); for (int j = 0; j < noOfResultsToBePublished; j++) { cancellationToken.ThrowIfCancellationRequested(); // Do not upload duplicate entries string[] attachments = testResults[i + j].Attachments; if (attachments != null) { Hashtable attachedFiles = new Hashtable(StringComparer.CurrentCultureIgnoreCase); var createAttachmentsTasks = attachments.Select(async attachment => { if (!attachedFiles.ContainsKey(attachment)) { TestAttachmentRequestModel reqModel = GetAttachmentRequestModel(attachment); if (reqModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(reqModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } attachedFiles.Add(attachment, null); } }); await Task.WhenAll(createAttachmentsTasks); } // Upload console log as attachment string consoleLog = testResults[i + j].ConsoleLog; TestAttachmentRequestModel attachmentRequestModel = GetConsoleLogAttachmentRequestModel(consoleLog); if (attachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(attachmentRequestModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } } } Trace.Leaving(); }
/// <summary> /// Publishes the given results to the test run. /// </summary> /// <param name="testResults">Results to be published.</param> public async Task AddResultsAsync(TestRun testRun, TestCaseResultData[] testResults, CancellationToken cancellationToken) { Trace.Entering(); int noOfResultsToBePublished = BATCH_SIZE; _executionContext.Output(StringUtil.Loc("PublishingTestResults", testRun.Id)); for (int i = 0; i < testResults.Length; i += BATCH_SIZE) { cancellationToken.ThrowIfCancellationRequested(); if (i + BATCH_SIZE >= testResults.Length) { noOfResultsToBePublished = testResults.Length - i; } _executionContext.Output(StringUtil.Loc("TestResultsRemaining", (testResults.Length - i), testRun.Id)); var currentBatch = new TestCaseResultData[noOfResultsToBePublished]; Array.Copy(testResults, i, currentBatch, 0, noOfResultsToBePublished); List <TestCaseResult> testresults = await _testResultsServer.AddTestResultsToTestRunAsync(currentBatch, _projectName, testRun.Id, cancellationToken); for (int j = 0; j < noOfResultsToBePublished; j++) { cancellationToken.ThrowIfCancellationRequested(); // Do not upload duplicate entries string[] attachments = testResults[i + j].Attachments; if (attachments != null) { Hashtable attachedFiles = new Hashtable(StringComparer.CurrentCultureIgnoreCase); var createAttachmentsTasks = attachments.Select(async attachment => { if (!attachedFiles.ContainsKey(attachment)) { TestAttachmentRequestModel reqModel = GetAttachmentRequestModel(attachment); if (reqModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(reqModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } attachedFiles.Add(attachment, null); } }); await Task.WhenAll(createAttachmentsTasks); } // Upload console log as attachment string consoleLog = testResults[i + j].ConsoleLog; TestAttachmentRequestModel attachmentRequestModel = GetConsoleLogAttachmentRequestModel(consoleLog); if (attachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(attachmentRequestModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } } } Trace.Leaving(); }
private async Task UploadTestResultsAttachmentAsync(int testRunId, TestCaseResultData testCaseResultData, TestCaseResult testCaseResult, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (testCaseResult == null || testCaseResultData == null) { return; } if (testCaseResultData.AttachmentData != null) { // Remove duplicate entries string[] attachments = testCaseResultData.AttachmentData.AttachmentsFilePathList?.ToArray(); 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.CreateTestResultAttachmentAsync(reqModel, _projectName, testRunId, testCaseResult.Id, cancellationToken); } }); await Task.WhenAll(createAttachmentsTasks); } // Upload console log as attachment string consoleLog = testCaseResultData?.AttachmentData.ConsoleLog; TestAttachmentRequestModel attachmentRequestModel = GetConsoleLogAttachmentRequestModel(consoleLog); if (attachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(attachmentRequestModel, _projectName, testRunId, testCaseResult.Id, cancellationToken); } // Upload standard error as attachment string standardError = testCaseResultData.AttachmentData.StandardError; TestAttachmentRequestModel stdErrAttachmentRequestModel = GetStandardErrorAttachmentRequestModel(standardError); if (stdErrAttachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(stdErrAttachmentRequestModel, _projectName, testRunId, testCaseResult.Id, cancellationToken); } } if (testCaseResult.SubResults != null && testCaseResult.SubResults.Any() && testCaseResultData.TestCaseSubResultData != null) { for (int i = 0; i < testCaseResultData.TestCaseSubResultData.Count; i++) { await UploadTestSubResultsAttachmentAsync(testRunId, testCaseResult.Id, testCaseResultData.TestCaseSubResultData[i], testCaseResult.SubResults[i], 1, cancellationToken); } } }
private void ProcessFailureNode(XmlNode failure, TestCaseResultData resultCreateModel) { resultCreateModel.Outcome = TestOutcome.Failed.ToString(); if (failure.Attributes["message"] != null && !string.IsNullOrWhiteSpace(failure.Attributes["message"].Value)) { resultCreateModel.ErrorMessage = failure.Attributes["message"].Value; } if (!string.IsNullOrWhiteSpace(failure.InnerText)) { resultCreateModel.StackTrace = failure.InnerText; } }
public TestRunData ReadResults(IExecutionContext executionContext, string filePath, TestRunContext runContext) { try { string jsonTestSummary = File.ReadAllText(filePath); if (string.IsNullOrWhiteSpace(jsonTestSummary)) { return(null); } JsonTestSummary testSummary = StringUtil.ConvertFromJson <JsonTestSummary>(jsonTestSummary); // Adding the minimum details from the JSON. TestRunData testRunData = new TestRunData(name: "Container Structure Test", isAutomated: true, buildId: runContext != null ? runContext.BuildId : 0, buildFlavor: runContext != null ? runContext.Configuration : string.Empty, buildPlatform: runContext != null ? runContext.Platform : string.Empty, releaseUri: runContext != null ? runContext.ReleaseUri : null, releaseEnvironmentUri: runContext != null ? runContext.ReleaseEnvironmentUri : null); List <TestCaseResultData> results = new List <TestCaseResultData>(); foreach (JsonTestResult result in testSummary.Results) { TestCaseResultData resultCreateModel = new TestCaseResultData(); resultCreateModel.TestCaseTitle = result.Name; resultCreateModel.AutomatedTestName = result.Name; bool outcome = result.Pass.Equals("true", StringComparison.OrdinalIgnoreCase); if (!outcome) { resultCreateModel.ErrorMessage = string.Join("|", result.Errors); } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; resultCreateModel.Outcome = outcome ? TestOutcome.Passed.ToString() : TestOutcome.Failed.ToString(); results.Add(resultCreateModel); } testRunData.Results = results.ToArray(); return(testRunData); } catch (Exception ex) { executionContext.Output("Error occured in reading results : " + ex); } return(null); }
public static void Convert(TestCaseResultData testCaseResultData, TestCaseResult testCaseResultWebApi) { testCaseResultWebApi.Area = testCaseResultData.Area; testCaseResultWebApi.AssociatedBugs = testCaseResultData.AssociatedBugs; testCaseResultWebApi.AutomatedTestId = testCaseResultData.AutomatedTestId; testCaseResultWebApi.AutomatedTestName = testCaseResultData.AutomatedTestName; testCaseResultWebApi.AutomatedTestStorage = testCaseResultData.AutomatedTestStorage; testCaseResultWebApi.AutomatedTestType = testCaseResultData.AutomatedTestType; testCaseResultWebApi.AutomatedTestTypeId = testCaseResultData.AutomatedTestTypeId; testCaseResultWebApi.Build = testCaseResultData.Build; testCaseResultWebApi.BuildReference = testCaseResultData.BuildReference; testCaseResultWebApi.Comment = testCaseResultData.Comment; testCaseResultWebApi.CompletedDate = testCaseResultData.CompletedDate; testCaseResultWebApi.ComputerName = testCaseResultData.ComputerName; testCaseResultWebApi.Configuration = testCaseResultData.Configuration; testCaseResultWebApi.CreatedDate = testCaseResultData.CreatedDate; testCaseResultWebApi.CustomFields = testCaseResultData.CustomFields; testCaseResultWebApi.DurationInMs = testCaseResultData.DurationInMs; testCaseResultWebApi.ErrorMessage = testCaseResultData.ErrorMessage; testCaseResultWebApi.FailureType = testCaseResultData.FailureType; testCaseResultWebApi.Id = testCaseResultData.Id; testCaseResultWebApi.IterationDetails = testCaseResultData.IterationDetails; testCaseResultWebApi.LastUpdatedBy = testCaseResultData.LastUpdatedBy; testCaseResultWebApi.LastUpdatedDate = testCaseResultData.LastUpdatedDate; testCaseResultWebApi.Outcome = testCaseResultData.Outcome; testCaseResultWebApi.Owner = testCaseResultData.Owner; testCaseResultWebApi.Priority = testCaseResultData.Priority; testCaseResultWebApi.Project = testCaseResultData.Project; testCaseResultWebApi.Release = testCaseResultData.Release; testCaseResultWebApi.ReleaseReference = testCaseResultData.ReleaseReference; testCaseResultWebApi.ResetCount = testCaseResultData.ResetCount; testCaseResultWebApi.ResolutionState = testCaseResultData.ResolutionState; testCaseResultWebApi.ResolutionStateId = testCaseResultData.ResolutionStateId; testCaseResultWebApi.ResultGroupType = testCaseResultData.ResultGroupType; testCaseResultWebApi.Revision = testCaseResultData.Revision; testCaseResultWebApi.RunBy = testCaseResultData.RunBy; testCaseResultWebApi.StackTrace = testCaseResultData.StackTrace; testCaseResultWebApi.StartedDate = testCaseResultData.StartedDate; testCaseResultWebApi.State = testCaseResultData.State; testCaseResultWebApi.TestCase = testCaseResultData.TestCase; testCaseResultWebApi.TestCaseReferenceId = testCaseResultData.TestCaseReferenceId; testCaseResultWebApi.TestCaseTitle = testCaseResultData.TestCaseTitle; testCaseResultWebApi.TestPlan = testCaseResultData.TestPlan; testCaseResultWebApi.TestPoint = testCaseResultData.TestPoint; testCaseResultWebApi.TestRun = testCaseResultData.TestRun; testCaseResultWebApi.TestSuite = testCaseResultData.TestSuite; testCaseResultWebApi.Url = testCaseResultData.Url; ConvertSubResults(testCaseResultData, testCaseResultWebApi); }
private static void ConvertSubResults(TestCaseResultData testCaseResultData, TestCaseResult testCaseResultWebApi) { if (testCaseResultData.TestCaseSubResultData == null || !testCaseResultData.TestCaseSubResultData.Any()) { return; } testCaseResultWebApi.SubResults = new List <TestSubResult>(); foreach (var subResultData in testCaseResultData.TestCaseSubResultData) { var subResultWebApi = new TestSubResult(); TestCaseSubResultDataConverter.Convert(subResultData, subResultWebApi); testCaseResultWebApi.SubResults.Add(subResultWebApi); } }
private void AddSystemLogsToResult(XmlNode testCaseNode, TestCaseResultData resultCreateModel) { XmlNode stdout, stderr; // Standard output logs stdout = testCaseNode.SelectSingleNode("./system-out"); if (stdout != null && !string.IsNullOrWhiteSpace(stdout.InnerText)) { resultCreateModel.ConsoleLog = stdout.InnerText; } // Standard error logs stderr = testCaseNode.SelectSingleNode("./system-err"); if (stderr != null && !string.IsNullOrWhiteSpace(stderr.InnerText)) { resultCreateModel.StandardError = stderr.InnerText; } }
/// <summary> /// Publishes the given results to the test run. /// </summary> /// <param name="testResults">Results to be published.</param> public async Task AddResultsAsync(TestRun testRun, TestCaseResultData[] testResults, CancellationToken cancellationToken) { Trace.Entering(); int noOfResultsToBePublished = BATCH_SIZE; _executionContext.Output(StringUtil.Loc("PublishingTestResults", testRun.Id)); for (int i = 0; i < testResults.Length; i += BATCH_SIZE) { cancellationToken.ThrowIfCancellationRequested(); if (i + BATCH_SIZE >= testResults.Length) { noOfResultsToBePublished = testResults.Length - i; } _executionContext.Output(StringUtil.Loc("TestResultsRemaining", (testResults.Length - i), testRun.Id)); var currentBatch = new TestCaseResultData[noOfResultsToBePublished]; var testResultsBatch = new TestCaseResult[noOfResultsToBePublished]; Array.Copy(testResults, i, currentBatch, 0, noOfResultsToBePublished); for (int testResultsIndex = 0; testResultsIndex < noOfResultsToBePublished; testResultsIndex++) { if (IsMaxLimitReachedForSubresultPreProcessing(currentBatch[testResultsIndex].AutomatedTestName, currentBatch[testResultsIndex].TestCaseSubResultData) == false) { _executionContext.Warning(StringUtil.Loc("MaxHierarchyLevelReached", TestManagementConstants.maxHierarchyLevelForSubresults)); currentBatch[testResultsIndex].TestCaseSubResultData = null; } testResultsBatch[testResultsIndex] = new TestCaseResult(); TestCaseResultDataConverter.Convert(currentBatch[testResultsIndex], testResultsBatch[testResultsIndex]); } List <TestCaseResult> uploadedTestResults = await _testResultsServer.AddTestResultsToTestRunAsync(testResultsBatch, _projectName, testRun.Id, cancellationToken); for (int j = 0; j < noOfResultsToBePublished; j++) { await this.UploadTestResultsAttachmentAsync(testRun.Id, testResults[i + j], uploadedTestResults[j], cancellationToken); } } Trace.Leaving(); }
/// <summary> /// Publishes the given results to the test run. /// </summary> /// <param name="testResults">Results to be published.</param> public async Task AddResultsAsync(TestRun testRun, TestCaseResultData[] testResults, CancellationToken cancellationToken) { Trace.Entering(); int noOfResultsToBePublished = BATCH_SIZE; _executionContext.Output(StringUtil.Loc("PublishingTestResults", testRun.Id)); for (int i = 0; i < testResults.Length; i += BATCH_SIZE) { cancellationToken.ThrowIfCancellationRequested(); if (i + BATCH_SIZE >= testResults.Length) { noOfResultsToBePublished = testResults.Length - i; } _executionContext.Output(StringUtil.Loc("TestResultsRemaining", (testResults.Length - i), testRun.Id)); var currentBatch = new TestCaseResultData[noOfResultsToBePublished]; var testResultsBatch = new TestCaseResult[noOfResultsToBePublished]; Array.Copy(testResults, i, currentBatch, 0, noOfResultsToBePublished); for (int testResultsIndex = 0; testResultsIndex < noOfResultsToBePublished; testResultsIndex++) { testResultsBatch[testResultsIndex] = new TestCaseResult(); TestCaseResultDataConverter.Convert(currentBatch[testResultsIndex], testResultsBatch[testResultsIndex]); } List <TestCaseResult> uploadedTestResults = await _testResultsServer.AddTestResultsToTestRunAsync(testResultsBatch, _projectName, testRun.Id, cancellationToken); for (int j = 0; j < noOfResultsToBePublished; j++) { await this.UploadTestResultsAttachmentAsync(testRun.Id, testResults[i + j], uploadedTestResults[j], cancellationToken); } } Trace.Leaving(); }
//Based on the XUnit V2 format: http://xunit.github.io/docs/format-xml-v2.html public TestRunData ReadResults(IExecutionContext executionContext, string filePath, TestRunContext runContext = null) { List <TestCaseResultData> results = new List <TestCaseResultData>(); XmlDocument doc = new XmlDocument(); try { var settings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }; using (XmlReader reader = XmlReader.Create(filePath, settings)) { doc.Load(reader); } } catch (XmlException ex) { executionContext.Warning(StringUtil.Loc("FailedToReadFile", filePath, ex.Message)); return(null); } string runName = Name + " Test Run"; string runUser = ""; if (runContext != null) { if (!string.IsNullOrWhiteSpace(runContext.RunName)) { runName = runContext.RunName; } else { runName = string.Format(CultureInfo.CurrentCulture, "{0} {1} {2}", runName, runContext.Configuration, runContext.Platform); } if (runContext.Owner != null) { runUser = runContext.Owner; } } IdentityRef runUserIdRef = new IdentityRef(); runUserIdRef.DisplayName = runUser; var minStartTime = DateTime.MaxValue; var maxCompletedTime = DateTime.MinValue; bool dateTimeParseError = true; bool assemblyRunDateTimeAttributesNotPresent = false; bool assemblyTimeAttributeNotPresent = false; double assemblyRunDuration = 0; double testRunDuration = 0; XmlNodeList assemblyNodes = doc.SelectNodes("/assemblies/assembly"); foreach (XmlNode assemblyNode in assemblyNodes) { var assemblyRunStartTimeStamp = DateTime.MinValue; if (assemblyNode.Attributes["run-date"] != null && assemblyNode.Attributes["run-time"] != null) { string runDate = assemblyNode.Attributes["run-date"].Value; string runTime = assemblyNode.Attributes["run-time"].Value; var startDate = DateTime.Now; var startTime = TimeSpan.Zero; if (DateTime.TryParse(runDate, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out startDate) && TimeSpan.TryParse(runTime, CultureInfo.InvariantCulture, out startTime)) { dateTimeParseError = false; } assemblyRunStartTimeStamp = startDate + startTime; if (minStartTime > assemblyRunStartTimeStamp) { minStartTime = assemblyRunStartTimeStamp; } } else { assemblyRunDateTimeAttributesNotPresent = true; } if (!assemblyTimeAttributeNotPresent && assemblyNode.Attributes["time"] != null) { double assemblyDuration = 0; Double.TryParse(assemblyNode.Attributes["time"].Value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out assemblyDuration); assemblyRunDuration = assemblyRunDuration + assemblyDuration; var durationFromSeconds = TimeSpan.FromSeconds(assemblyDuration); // no assemblystarttime available so dont calculate assemblycompletedtime if (assemblyRunStartTimeStamp != DateTime.MinValue) { DateTime assemblyRunCompleteTimeStamp = assemblyRunStartTimeStamp.AddTicks(durationFromSeconds.Ticks); //finding maximum comleted time if (maxCompletedTime < assemblyRunCompleteTimeStamp) { maxCompletedTime = assemblyRunCompleteTimeStamp; } } } else { assemblyTimeAttributeNotPresent = true; } XmlNodeList testCaseNodeList = assemblyNode.SelectNodes("./collection/test"); foreach (XmlNode testCaseNode in testCaseNodeList) { TestCaseResultData resultCreateModel = new TestCaseResultData() { Priority = TestManagementConstants.UnspecifiedPriority, //Priority is int type so if no priority set then its 255. }; //Test storage. if (assemblyNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestStorage = Path.GetFileName(assemblyNode.Attributes["name"].Value); } //Fully Qualified Name. if (testCaseNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } //Test Method Name. if (testCaseNode.Attributes["method"] != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["method"].Value; } //Test duration. if (testCaseNode.Attributes["time"] != null && testCaseNode.Attributes["time"].Value != null) { double duration = 0; double.TryParse(testCaseNode.Attributes["time"].Value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out duration); var durationFromSeconds = TimeSpan.FromSeconds(duration); resultCreateModel.DurationInMs = durationFromSeconds.TotalMilliseconds; // no assemblystarttime available so dont set testcase start and completed if (assemblyRunStartTimeStamp != DateTime.MinValue) { resultCreateModel.StartedDate = assemblyRunStartTimeStamp; resultCreateModel.CompletedDate = assemblyRunStartTimeStamp.AddTicks(durationFromSeconds.Ticks); assemblyRunStartTimeStamp = assemblyRunStartTimeStamp.AddTicks(1) + durationFromSeconds; //next start time } //Calculate overall run duration. testRunDuration += duration; } //Test outcome. if (testCaseNode.SelectSingleNode("./failure") != null) { resultCreateModel.Outcome = TestOutcome.Failed.ToString(); //Error message. XmlNode failureMessageNode = testCaseNode.SelectSingleNode("./failure/message"); if (failureMessageNode != null && !string.IsNullOrWhiteSpace(failureMessageNode.InnerText)) { resultCreateModel.ErrorMessage = failureMessageNode.InnerText; } //Stack trace. XmlNode failureStackTraceNode = testCaseNode.SelectSingleNode("./failure/stack-trace"); if (failureStackTraceNode != null && !string.IsNullOrWhiteSpace(failureStackTraceNode.InnerText)) { resultCreateModel.StackTrace = failureStackTraceNode.InnerText; } // Console log resultCreateModel.AttachmentData = new AttachmentData(); XmlNode consoleLog = testCaseNode.SelectSingleNode("./output"); if (consoleLog != null && !string.IsNullOrWhiteSpace(consoleLog.InnerText)) { resultCreateModel.AttachmentData.ConsoleLog = consoleLog.InnerText; } } else if (testCaseNode.Attributes["result"] != null && string.Equals(testCaseNode.Attributes["result"].Value, "pass", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } else { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); } //Test priority. XmlNode priorityTrait = testCaseNode.SelectSingleNode("./traits/trait[@name='priority']"); if (priorityTrait != null && priorityTrait.Attributes["value"] != null) { var priorityValue = priorityTrait.Attributes["value"].Value; resultCreateModel.Priority = !string.IsNullOrEmpty(priorityValue) ? Convert.ToInt32(priorityValue) : TestManagementConstants.UnspecifiedPriority; } //Test owner. XmlNode ownerNode = testCaseNode.SelectSingleNode("./traits/trait[@name='owner']"); if (ownerNode != null && ownerNode.Attributes["value"] != null && ownerNode.Attributes["value"].Value != null) { IdentityRef ownerIdRef = new IdentityRef(); ownerIdRef.DisplayName = ownerNode.Attributes["value"].Value; ownerIdRef.DirectoryAlias = ownerNode.Attributes["value"].Value; resultCreateModel.Owner = ownerIdRef; } resultCreateModel.RunBy = runUserIdRef; resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } } if (dateTimeParseError || assemblyRunDateTimeAttributesNotPresent) { executionContext.Warning("Atleast for one assembly start time was not obtained due to tag not present or parsing issue, total run duration will now be summation of time taken by each assembly"); if (assemblyTimeAttributeNotPresent) { executionContext.Warning("Atleast for one assembly time tag is not present, total run duration will now be summation of time from all test runs"); } } //if minimum start time is not available then set it to present time minStartTime = minStartTime == DateTime.MaxValue ? DateTime.UtcNow : minStartTime; //if start time cannot be obtained even for one assembly then fallback duration to sum of assembly run time //if assembly run time cannot be obtained even for one assembly then fallback duration to total test run maxCompletedTime = dateTimeParseError || assemblyRunDateTimeAttributesNotPresent || maxCompletedTime == DateTime.MinValue ? minStartTime.Add(assemblyTimeAttributeNotPresent ? TimeSpan.FromSeconds(testRunDuration) : TimeSpan.FromSeconds(assemblyRunDuration)) : maxCompletedTime; executionContext.Output(string.Format("Obtained XUnit Test Run Start Date: {0} and Completed Date: {1}", minStartTime.ToString("o"), maxCompletedTime.ToString("o"))); TestRunData testRunData = new TestRunData( name: runName, buildId: runContext != null ? runContext.BuildId : 0, startedDate: minStartTime != DateTime.MinValue ? minStartTime.ToString("o") : null, completedDate: maxCompletedTime != DateTime.MinValue ? maxCompletedTime.ToString("o") : null, state: TestRunState.InProgress.ToString(), isAutomated: true, buildFlavor: runContext != null ? runContext.Configuration : null, buildPlatform: runContext != null ? runContext.Platform : null, releaseUri: runContext != null ? runContext.ReleaseUri : null, releaseEnvironmentUri: runContext != null ? runContext.ReleaseEnvironmentUri : null ); testRunData.Results = results.ToArray(); testRunData.Attachments = AddResultsFileToRunLevelAttachments ? new string[] { filePath } : new string[0]; return(testRunData); }
private List <TestCaseResultData> ReadActualResults(XmlNodeList resultsNodes, TestType testType) { List <TestCaseResultData> results = new List <TestCaseResultData>(); object sync = new object(); Parallel.ForEach <XmlNode>(resultsNodes.Cast <XmlNode>(), resultNode => { TestCaseResultData resultCreateModel = new TestCaseResultData() { Priority = TestManagementConstants.UnspecifiedPriority, //Priority is int type so if no priority set then its 255. }; //Find and format dates as per TCM requirement. TimeSpan duration; if (resultNode.Attributes["duration"] != null && resultNode.Attributes["duration"].Value != null) { TimeSpan.TryParse(resultNode.Attributes["duration"].Value, CultureInfo.InvariantCulture, out duration); } else { duration = TimeSpan.Zero; } resultCreateModel.DurationInMs = duration.TotalMilliseconds; DateTime startedDate; if (resultNode.Attributes["startTime"] != null && resultNode.Attributes["startTime"].Value != null) { DateTime.TryParse(resultNode.Attributes["startTime"].Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out startedDate); } else { startedDate = DateTime.UtcNow; } resultCreateModel.StartedDate = startedDate; DateTime completedDate = startedDate.AddTicks(duration.Ticks); resultCreateModel.CompletedDate = completedDate; if ((DateTime.Compare(default(DateTime), startedDate) < 0 && DateTime.Compare(startedDate, (DateTime)SqlDateTime.MinValue) <= 0) || (DateTime.Compare(default(DateTime), completedDate) < 0 && DateTime.Compare(completedDate, (DateTime)SqlDateTime.MinValue) <= 0)) { DateTime utcNow = DateTime.UtcNow; resultCreateModel.StartedDate = utcNow; resultCreateModel.CompletedDate = utcNow.AddTicks(duration.Ticks); } if (resultNode.Attributes["outcome"] == null || resultNode.Attributes["outcome"].Value == null || string.Equals(resultNode.Attributes["outcome"].Value, "failed", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Failed.ToString();; } else if (string.Equals(resultNode.Attributes["outcome"].Value, "passed", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } else if (string.Equals(resultNode.Attributes["outcome"].Value, "inconclusive", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Inconclusive.ToString(); } else { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); } if (resultNode.Attributes["testName"] != null && resultNode.Attributes["testName"].Value != null) { resultCreateModel.TestCaseTitle = resultNode.Attributes["testName"].Value; } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = testType.ToString(); if (resultNode.Attributes["computerName"] != null && resultNode.Attributes["computerName"].Value != null) { resultCreateModel.ComputerName = resultNode.Attributes["computerName"].Value; } if (resultNode.Attributes["testId"] != null && resultNode.Attributes["testId"].Value != null) { resultCreateModel.AutomatedTestId = resultNode.Attributes["testId"].Value; } string executionId = null; if (resultNode.Attributes["executionId"] != null && resultNode.Attributes["executionId"].Value != null) { executionId = resultNode.Attributes["executionId"].Value; } lock (sync) { if (resultCreateModel.AutomatedTestId != null && _definitions.ContainsKey(resultCreateModel.AutomatedTestId)) { TestCaseDefinition definition = _definitions[resultCreateModel.AutomatedTestId]; if (definition != null) { if (definition.Storage != null) { resultCreateModel.AutomatedTestStorage = definition.Storage; } if (definition.Priority != null) { resultCreateModel.Priority = !string.IsNullOrEmpty(definition.Priority) ? Convert.ToInt32(definition.Priority) : TestManagementConstants.UnspecifiedPriority; } if (definition.Owner != null) { resultCreateModel.Owner = definition.Owner; } if (definition.AutomatedTestName != null) { resultCreateModel.AutomatedTestName = definition.AutomatedTestName; } } } //AutomatedTestId should be a valid guid. Delaying the check to here since we use it as dictionary key above. Guid automatedTestId; if (!Guid.TryParse(resultCreateModel.AutomatedTestId, out automatedTestId)) { resultCreateModel.AutomatedTestId = null; } } if (resultNode.Attributes["testType"] != null && resultNode.Attributes["testType"].Value != null) { Guid automatedTestType; if (Guid.TryParse(resultNode.Attributes["testType"].Value, out automatedTestType)) { resultCreateModel.AutomatedTestTypeId = resultNode.Attributes["testType"].Value; } } resultCreateModel.RunBy = _runUserIdRef; List <string> resulLeveltAttachments = new List <string>() { }; XmlNodeList resultAttachmentNodes = resultNode.SelectNodes("CollectorDataEntries/Collector/UriAttachments/UriAttachment/A"); if (resultAttachmentNodes.Count > 0 && executionId != null) { foreach (XmlNode resultAttachmentNode in resultAttachmentNodes) { if (resultAttachmentNode.Attributes["href"]?.Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultAttachmentNode.Attributes["href"].Value)); } } } XmlNodeList resultFileNodes = resultNode.SelectNodes("ResultFiles/ResultFile"); if (resultFileNodes.Count > 0 && executionId != null) { foreach (XmlNode resultFileNode in resultFileNodes) { if (resultFileNode.Attributes["path"]?.Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultFileNode.Attributes["path"].Value)); } } } resultCreateModel.AttachmentData = new AttachmentData() { AttachmentsFilePathList = resulLeveltAttachments.ToArray() }; AddVariousLogsForResultIfOutcomeIsFailed(resultCreateModel, resultNode); XmlNode innerResults = resultNode.SelectSingleNode("InnerResults"); if (innerResults != null) { resultCreateModel.ResultGroupType = GetResultGroupType(resultNode, testType); XmlNodeList resNodes = innerResults.SelectNodes("UnitTestResult"); XmlNodeList webTestResultNodes = innerResults.SelectNodes("WebTestResult"); XmlNodeList orderedTestResultNodes = innerResults.SelectNodes("TestResultAggregation"); resultCreateModel.TestCaseSubResultData = new List <TestCaseSubResultData>(); resultCreateModel.TestCaseSubResultData.AddRange(ReadActualSubResults(resNodes, TestType.UnitTest, 1)); resultCreateModel.TestCaseSubResultData.AddRange(ReadActualSubResults(webTestResultNodes, TestType.WebTest, 1)); resultCreateModel.TestCaseSubResultData.AddRange(ReadActualSubResults(orderedTestResultNodes, TestType.OrderedTest, 1)); } lock (sync) { //Mandatory fields. Skip if they are not available. if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } }); return(results); }
public void SystemInformationFileUploadsWithCorrectAttachmentType() { SetupMocks(); File.WriteAllText("SystemInformation.xml", "asdf"); ResetValues(); _testRunData = _publisher.ReadResultsFromFile(_testRunContext, "filepath"); _publisher.StartTestRunAsync(_testRunData).Wait(); TestCaseResultData result = new TestCaseResultData(); result.Attachments = new string[] { "SystemInformation.xml" }; var testRun = new TestRun { Id = 1 }; _publisher.AddResultsAsync(testRun, new TestCaseResultData[] { result }).Wait(); Assert.Equal(_resultsLevelAttachments.Count, 1); Assert.Equal(_resultsLevelAttachments[1].Count, 1); Assert.Equal(_resultsLevelAttachments[1][0].AttachmentType, AttachmentType.IntermediateCollectorData.ToString()); try { File.Delete("SystemInformation.xml"); } catch { } }
public void PublishConsoleLogIsSuccessful() { SetupMocks(); ResetValues(); TestCaseResultData testResultWithLog = new TestCaseResultData(); testResultWithLog.ConsoleLog = "Publish console log is successfully logged"; TestCaseResultData testResultWithNoLog = new TestCaseResultData(); testResultWithNoLog.ConsoleLog = ""; TestCaseResultData testResultDefault = new TestCaseResultData(); List<TestCaseResultData> testResults = new List<TestCaseResultData>() { testResultWithLog, testResultWithNoLog, testResultDefault }; // execute publish task _testRunData = _publisher.ReadResultsFromFile(_testRunContext, "filepath"); _publisher.StartTestRunAsync(_testRunData).Wait(); var testRun = new TestRun { Id = 1 }; _publisher.AddResultsAsync(testRun, testResults.ToArray()).Wait(); _publisher.EndTestRunAsync(_testRunData, 1).Wait(); // validate Assert.Equal(_resultsLevelAttachments.Count, 1); Assert.Equal(_resultsLevelAttachments[1].Count, 1); Assert.Equal(_resultsLevelAttachments[1][0].AttachmentType, AttachmentType.ConsoleLog.ToString()); string encodedData = _resultsLevelAttachments[1][0].Stream; byte[] bytes = Convert.FromBase64String(encodedData); string decodedData = System.Text.Encoding.UTF8.GetString(bytes); Assert.Equal(decodedData, testResultWithLog.ConsoleLog); }
/// <summary> /// Read testcases under testsuite node in xml /// </summary> /// <param name="rootNode"></param> private TestSuiteSummary ReadTestSuite(XmlNode rootNode, IdentityRef runUserIdRef) { TestSuiteSummary testSuiteSummary = new TestSuiteSummary(Name); TimeSpan totalTestSuiteDuration = TimeSpan.Zero; TimeSpan totalTestCaseDuration = TimeSpan.Zero; if (rootNode.Attributes["name"] != null && rootNode.Attributes["name"].Value != null) { testSuiteSummary.Name = rootNode.Attributes["name"].Value; } if (rootNode.Attributes["hostname"] != null && rootNode.Attributes["hostname"].Value != null) { testSuiteSummary.Host = rootNode.Attributes["hostname"].Value; } //assume runtimes from xml are current local time since timezone information is not in the xml, if xml datetime > current local time, fallback to local start time DateTime timestampFromXml = DateTime.MinValue; XmlAttribute timestampNode = rootNode.Attributes["timestamp"]; if (timestampNode != null && timestampNode.Value != null) { if (DateTime.TryParse(timestampNode.Value, out timestampFromXml)) { testSuiteSummary.TimeStamp = timestampFromXml; } } totalTestSuiteDuration = GetTimeSpan(rootNode); DateTime testSuiteStartTime = testSuiteSummary.TimeStamp; //find test case nodes in JUnit result xml XmlNodeList testCaseNodes = rootNode.SelectNodes("./testcase"); if (testCaseNodes != null) { DateTime testCaseStartTime = testSuiteStartTime; //Add test case results to the test run foreach (XmlNode testCaseNode in testCaseNodes) { TestCaseResultData resultCreateModel = new TestCaseResultData(); //test case name and type if (testCaseNode.Attributes["name"] != null && testCaseNode.Attributes["name"].Value != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["name"].Value; resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } if (testCaseNode.Attributes["classname"] != null && testCaseNode.Attributes["classname"].Value != null) { resultCreateModel.AutomatedTestStorage = testCaseNode.Attributes["classname"].Value; } //test case duration TimeSpan testCaseDuration = GetTimeSpan(testCaseNode); resultCreateModel.DurationInMs = testCaseDuration.TotalMilliseconds.ToString(CultureInfo.InvariantCulture); resultCreateModel.StartedDate = testCaseStartTime.ToString("o"); resultCreateModel.CompletedDate = testCaseStartTime.AddTicks(testCaseDuration.Ticks).ToString("o"); testCaseStartTime = testCaseStartTime.AddTicks(1) + testCaseDuration; //next start time //test case outcome XmlNode failure, error, skipped; if ((failure = testCaseNode.SelectSingleNode("./failure")) != null) { ProcessFailureNode(failure, resultCreateModel); } else if ((error = testCaseNode.SelectSingleNode("./error")) != null) { ProcessFailureNode(error, resultCreateModel); } else if ((skipped = testCaseNode.SelectSingleNode("./skipped")) != null) { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); if (skipped.Attributes["message"] != null && !string.IsNullOrWhiteSpace(skipped.Attributes["message"].Value)) { resultCreateModel.ErrorMessage = skipped.Attributes["message"].Value; } } else { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; //other properties - host name and user resultCreateModel.ComputerName = testSuiteSummary.Host; if (runUserIdRef != null) { resultCreateModel.RunBy = runUserIdRef; resultCreateModel.Owner = runUserIdRef; } if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { testSuiteSummary.Results.Add(resultCreateModel); } } } if (TimeSpan.Compare(totalTestSuiteDuration, totalTestCaseDuration) < 0) { totalTestSuiteDuration = totalTestCaseDuration; //run duration may not be set in the xml, so use total test case duration } testSuiteSummary.Duration = totalTestSuiteDuration; return testSuiteSummary; }
public void TestImpactFileUploadsWithCorrectAttachmentType() { SetupMocks(); File.WriteAllText("testimpact.xml", "asdf"); ResetValues(); _testRunData = _publisher.ReadResultsFromFile(_testRunContext, "filepath"); _publisher.StartTestRunAsync(_testRunData).Wait(); var result = new TestCaseResultData(); var testRun = new TestRun { Id = 1 }; result.Attachments = new string[] { "testimpact.xml" }; _publisher.AddResultsAsync(testRun, new TestCaseResultData[] { result }).Wait(); Assert.Equal(_resultsLevelAttachments.Count, 1); Assert.Equal(_resultsLevelAttachments[1].Count, 1); Assert.Equal(_resultsLevelAttachments[1][0].AttachmentType, AttachmentType.TestImpactDetails.ToString()); try { File.Delete("testimpact.xml"); } catch { } }
/// <summary> /// Read testcases under testsuite node in xml /// </summary> /// <param name="rootNode"></param> private TestSuiteSummary ReadTestSuite(XmlNode rootNode, IdentityRef runUserIdRef) { TestSuiteSummary testSuiteSummary = new TestSuiteSummary(Name); TimeSpan totalTestSuiteDuration = TimeSpan.Zero; TimeSpan totalTestCaseDuration = TimeSpan.Zero; if (rootNode.Attributes["name"] != null && rootNode.Attributes["name"].Value != null) { testSuiteSummary.Name = rootNode.Attributes["name"].Value; } if (rootNode.Attributes["hostname"] != null && rootNode.Attributes["hostname"].Value != null) { testSuiteSummary.Host = rootNode.Attributes["hostname"].Value; } //assume runtimes from xml are current local time since timezone information is not in the xml, if xml datetime > current local time, fallback to local start time DateTime timestampFromXml = DateTime.MinValue; XmlAttribute timestampNode = rootNode.Attributes["timestamp"]; if (timestampNode != null && timestampNode.Value != null) { if (DateTime.TryParse(timestampNode.Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out timestampFromXml)) { testSuiteSummary.TimeStamp = timestampFromXml; } } if (timestampFromXml == DateTime.MinValue) { testSuiteSummary.SuiteTimeStampAvailable = false; } bool SuiteTimeDataAvailable = false; totalTestSuiteDuration = GetTimeSpan(rootNode, out SuiteTimeDataAvailable); testSuiteSummary.SuiteTimeDataAvailable = SuiteTimeDataAvailable; var testSuiteStartTime = testSuiteSummary.TimeStamp; //find test case nodes in JUnit result xml XmlNodeList testCaseNodes = rootNode.SelectNodes("./testcase"); if (testCaseNodes != null) { DateTime testCaseStartTime = testSuiteStartTime; //Add test case results to the test run foreach (XmlNode testCaseNode in testCaseNodes) { TestCaseResultData resultCreateModel = new TestCaseResultData(); //test case name and type if (testCaseNode.Attributes["name"] != null && testCaseNode.Attributes["name"].Value != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["name"].Value; resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } if (testCaseNode.Attributes["classname"] != null && testCaseNode.Attributes["classname"].Value != null) { resultCreateModel.AutomatedTestStorage = testCaseNode.Attributes["classname"].Value; } if (testCaseNode.Attributes["owner"]?.Value != null) { var ownerName = testCaseNode.Attributes["owner"].Value; resultCreateModel.Owner = new IdentityRef { DisplayName = ownerName, DirectoryAlias = ownerName }; } //test case duration bool TestCaseTimeDataAvailable = false; var testCaseDuration = GetTimeSpan(testCaseNode, out TestCaseTimeDataAvailable); totalTestCaseDuration = totalTestCaseDuration + testCaseDuration; resultCreateModel.DurationInMs = testCaseDuration.TotalMilliseconds; resultCreateModel.StartedDate = testCaseStartTime; resultCreateModel.CompletedDate = testCaseStartTime.AddTicks(testCaseDuration.Ticks); testCaseStartTime = testCaseStartTime.AddTicks(1) + testCaseDuration; //next start time //test case outcome XmlNode failure, error, skipped; if ((failure = testCaseNode.SelectSingleNode("./failure")) != null) { ProcessFailureNode(failure, resultCreateModel); AddSystemLogsToResult(testCaseNode, resultCreateModel); } else if ((error = testCaseNode.SelectSingleNode("./error")) != null) { ProcessFailureNode(error, resultCreateModel); AddSystemLogsToResult(testCaseNode, resultCreateModel); } else if ((skipped = testCaseNode.SelectSingleNode("./skipped")) != null) { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); if (skipped.Attributes["message"] != null && !string.IsNullOrWhiteSpace(skipped.Attributes["message"].Value)) { resultCreateModel.ErrorMessage = skipped.Attributes["message"].Value; } } else { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; //other properties - host name and user resultCreateModel.ComputerName = testSuiteSummary.Host; if (runUserIdRef != null) { resultCreateModel.RunBy = runUserIdRef; } if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { testSuiteSummary.Results.Add(resultCreateModel); } } } testSuiteSummary.TestSuiteDuration = totalTestSuiteDuration; testSuiteSummary.TotalTestCaseDuration = totalTestCaseDuration; return(testSuiteSummary); }
private TestCaseResultData getTestCaseResultData(XmlNode testCaseResultNode, string assemblyName, string hostname) { var testCaseResultData = new TestCaseResultData(); if (!string.IsNullOrEmpty(assemblyName)) { testCaseResultData.AutomatedTestStorage = assemblyName; } testCaseResultData.ComputerName = hostname; testCaseResultData.TestCaseTitle = testCaseResultNode.Attributes["name"]?.Value; testCaseResultData.AutomatedTestName = testCaseResultNode.Attributes["fullname"]?.Value; double duration = 0; double.TryParse(testCaseResultNode.Attributes["duration"]?.Value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out duration); // Ensure Duration cannot be negative duration = (duration < 0) ? 0 : duration; testCaseResultData.DurationInMs = TimeSpan.FromSeconds(duration).TotalMilliseconds; var testExecutionStartedOn = DateTime.MinValue; DateTime.TryParse(testCaseResultNode.Attributes["start-time"]?.Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out testExecutionStartedOn); testCaseResultData.StartedDate = testExecutionStartedOn; var testExecutionEndedOn = DateTime.MinValue; DateTime.TryParse(testCaseResultNode.Attributes["end-time"]?.Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out testExecutionEndedOn); testCaseResultData.CompletedDate = testExecutionEndedOn; if (testCaseResultNode.Attributes["result"] != null) { if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Passed", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.Passed.ToString(); } else if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Failed", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.Failed.ToString(); } else if (string.Equals(testCaseResultNode.Attributes["result"].Value, "Skipped", StringComparison.OrdinalIgnoreCase)) { testCaseResultData.Outcome = TestOutcome.NotExecuted.ToString(); } else { testCaseResultData.Outcome = TestOutcome.Inconclusive.ToString(); } var failureNode = testCaseResultNode.SelectSingleNode("failure"); if (failureNode != null) { var failureMessageNode = failureNode.SelectSingleNode("message"); var failureStackTraceNode = failureNode.SelectSingleNode("stack-trace"); testCaseResultData.ErrorMessage = failureMessageNode?.InnerText; testCaseResultData.StackTrace = failureStackTraceNode?.InnerText; // console log XmlNode consoleLog = testCaseResultNode.SelectSingleNode("output"); if (consoleLog != null && !string.IsNullOrWhiteSpace(consoleLog.InnerText)) { testCaseResultData.ConsoleLog = consoleLog.InnerText; } } } testCaseResultData.State = "Completed"; testCaseResultData.AutomatedTestType = "NUnit"; if (_runUserIdRef != null) { testCaseResultData.RunBy = _runUserIdRef; testCaseResultData.Owner = _runUserIdRef; } // Adding test-case result level attachments testCaseResultData.Attachments = this.GetTestCaseResultLevelAttachments(testCaseResultNode).ToArray(); return(testCaseResultData); }
/// <summary> /// Publishes the given results to the test run. /// </summary> /// <param name="testResults">Results to be published.</param> public async Task AddResultsAsync(TestRun testRun, TestCaseResultData[] testResults, CancellationToken cancellationToken) { Trace.Entering(); int noOfResultsToBePublished = BATCH_SIZE; _executionContext.Output(StringUtil.Loc("PublishingTestResults", testRun.Id)); for (int i = 0; i < testResults.Length; i += BATCH_SIZE) { cancellationToken.ThrowIfCancellationRequested(); if (i + BATCH_SIZE >= testResults.Length) { noOfResultsToBePublished = testResults.Length - i; } _executionContext.Output(StringUtil.Loc("TestResultsRemaining", (testResults.Length - i), testRun.Id)); var currentBatch = new TestCaseResultData[noOfResultsToBePublished]; var testResultsBatch = new TestCaseResult[noOfResultsToBePublished]; Array.Copy(testResults, i, currentBatch, 0, noOfResultsToBePublished); for (int testResultsIndex = 0; testResultsIndex < noOfResultsToBePublished; testResultsIndex++) { testResultsBatch[testResultsIndex] = new TestCaseResult(); TestCaseResultDataConverter.Convert(currentBatch[testResultsIndex], testResultsBatch[testResultsIndex]); } List <TestCaseResult> testresults = await _testResultsServer.AddTestResultsToTestRunAsync(testResultsBatch, _projectName, testRun.Id, cancellationToken); for (int j = 0; j < noOfResultsToBePublished; j++) { cancellationToken.ThrowIfCancellationRequested(); // Remove duplicate entries string[] attachments = testResults[i + j]?.AttachmentData?.AttachmentsFilePathList?.ToArray(); HashSet <string> attachedFiles = GetUniqueTestRunFiles(attachments); if (attachedFiles != null) { var createAttachmentsTasks = attachedFiles.Select(async attachment => { TestAttachmentRequestModel reqModel = GetAttachmentRequestModel(attachment); if (reqModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(reqModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } }); await Task.WhenAll(createAttachmentsTasks); } // Upload console log as attachment string consoleLog = testResults[i + j]?.AttachmentData?.ConsoleLog; TestAttachmentRequestModel attachmentRequestModel = GetConsoleLogAttachmentRequestModel(consoleLog); if (attachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(attachmentRequestModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } // Upload standard error as attachment string standardError = testResults[i + j]?.AttachmentData?.StandardError; TestAttachmentRequestModel stdErrAttachmentRequestModel = GetStandardErrorAttachmentRequestModel(standardError); if (stdErrAttachmentRequestModel != null) { await _testResultsServer.CreateTestResultAttachmentAsync(stdErrAttachmentRequestModel, _projectName, testRun.Id, testresults[j].Id, cancellationToken); } } } Trace.Leaving(); }
private List <TestCaseResultData> ReadActualResults(XmlNodeList resultsNodes, string testType) { List <TestCaseResultData> results = new List <TestCaseResultData>(); object sync = new object(); Parallel.ForEach <XmlNode>(resultsNodes.Cast <XmlNode>(), resultNode => { TestCaseResultData resultCreateModel = new TestCaseResultData(); //Find and format dates as per TCM requirement. TimeSpan duration; if (resultNode.Attributes["duration"] != null && resultNode.Attributes["duration"].Value != null) { TimeSpan.TryParse(resultNode.Attributes["duration"].Value, out duration); } else { duration = TimeSpan.Zero; } resultCreateModel.DurationInMs = ((int)duration.TotalMilliseconds).ToString(); DateTime startedDate; if (resultNode.Attributes["startTime"] != null && resultNode.Attributes["startTime"].Value != null) { DateTime.TryParse(resultNode.Attributes["startTime"].Value, out startedDate); } else { startedDate = DateTime.Now; } resultCreateModel.StartedDate = startedDate.ToString("o"); DateTime completedDate = startedDate.AddTicks(duration.Ticks); resultCreateModel.CompletedDate = completedDate.ToString("o"); if (resultNode.Attributes["outcome"] != null && resultNode.Attributes["outcome"].Value != null) { resultCreateModel.Outcome = resultNode.Attributes["outcome"].Value; } else { resultCreateModel.Outcome = "Failed"; } if (resultNode.Attributes["testName"] != null && resultNode.Attributes["testName"].Value != null) { resultCreateModel.TestCaseTitle = resultNode.Attributes["testName"].Value; } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = testType; if (resultNode.Attributes["computerName"] != null && resultNode.Attributes["computerName"].Value != null) { resultCreateModel.ComputerName = resultNode.Attributes["computerName"].Value; } if (resultNode.Attributes["testId"] != null && resultNode.Attributes["testId"].Value != null) { resultCreateModel.AutomatedTestId = resultNode.Attributes["testId"].Value; } string executionId = null; if (resultNode.Attributes["executionId"] != null && resultNode.Attributes["executionId"].Value != null) { executionId = resultNode.Attributes["executionId"].Value; } lock (sync) { if (resultCreateModel.AutomatedTestId != null && _definitions.ContainsKey(resultCreateModel.AutomatedTestId)) { TestCaseDefinition definition = _definitions[resultCreateModel.AutomatedTestId]; if (definition != null) { if (definition.Storage != null) { resultCreateModel.AutomatedTestStorage = definition.Storage; } if (definition.Priority != null) { resultCreateModel.TestCasePriority = definition.Priority; } if (definition.Owner != null) { resultCreateModel.Owner = definition.Owner; } if (definition.AutomatedTestName != null) { resultCreateModel.AutomatedTestName = definition.AutomatedTestName; } } } //AutomatedTestId should be a valid guid. Delaying the check to here since we use it as dictionary key above. Guid automatedTestId; if (!Guid.TryParse(resultCreateModel.AutomatedTestId, out automatedTestId)) { resultCreateModel.AutomatedTestId = null; } } if (resultNode.Attributes["testType"] != null && resultNode.Attributes["testType"].Value != null) { Guid automatedTestType; if (Guid.TryParse(resultNode.Attributes["testType"].Value, out automatedTestType)) { resultCreateModel.AutomatedTestTypeId = resultNode.Attributes["testType"].Value; } } resultCreateModel.RunBy = _runUserIdRef; if (resultCreateModel.Outcome.Equals("Failed")) { XmlNode errorMessage, errorStackTrace, consoleLog; if ((errorMessage = resultNode.SelectSingleNode("./Output/ErrorInfo/Message")) != null && !string.IsNullOrWhiteSpace(errorMessage.InnerText)) { resultCreateModel.ErrorMessage = errorMessage.InnerText; } // stack trace if ((errorStackTrace = resultNode.SelectSingleNode("./Output/ErrorInfo/StackTrace")) != null && !string.IsNullOrWhiteSpace(errorStackTrace.InnerText)) { resultCreateModel.StackTrace = errorStackTrace.InnerText; } // console log if ((consoleLog = resultNode.SelectSingleNode("./Output/StdOut")) != null && !string.IsNullOrWhiteSpace(consoleLog.InnerText)) { resultCreateModel.ConsoleLog = consoleLog.InnerText; } } List <string> resulLeveltAttachments = new List <string>() { }; XmlNodeList resultAttachmentNodes = resultNode.SelectNodes("CollectorDataEntries/Collector/UriAttachments/UriAttachment/A"); if (resultAttachmentNodes.Count > 0 && executionId != null) { foreach (XmlNode resultAttachmentNode in resultAttachmentNodes) { if (resultAttachmentNode.Attributes["href"] != null && resultAttachmentNode.Attributes["href"].Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultAttachmentNode.Attributes["href"].Value)); } } } XmlNodeList resultFileNodes = resultNode.SelectNodes("ResultFiles/ResultFile"); if (resultFileNodes.Count > 0 && executionId != null) { foreach (XmlNode resultFileNode in resultFileNodes) { if (resultFileNode.Attributes["path"] != null && resultFileNode.Attributes["path"].Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultFileNode.Attributes["path"].Value)); } } } resultCreateModel.Attachments = resulLeveltAttachments.ToArray(); lock (sync) { //Mandatory fields. Skip if they are not available. if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } }); return(results); }
private List<TestCaseResultData> FindTestCaseNodes(XmlNode startNode, string hostName, IdentityRef runUserIdRef, DateTime assemblyStartTime, string assemblyName = null) { List<TestCaseResultData> results = new List<TestCaseResultData>(); string testStorage = assemblyName; if (startNode.Attributes["type"] != null && startNode.Attributes["type"].Value != null && startNode.Attributes["type"].Value.Equals("assembly", StringComparison.OrdinalIgnoreCase)) { if (startNode.Attributes["name"] != null && startNode.Attributes["name"].Value != null) { testStorage = startNode.Attributes["name"].Value; } } //get each test case result information XmlNodeList testCaseNodes = startNode.SelectNodes("results/test-case"); //all test-case nodes under testAssemblyNode if (testCaseNodes != null) { DateTime testCaseStartTime = assemblyStartTime; foreach (XmlNode testCaseNode in testCaseNodes) { TestCaseResultData resultCreateModel = new TestCaseResultData(); //test case name and type if (testCaseNode.Attributes["name"] != null && testCaseNode.Attributes["name"].Value != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["name"].Value; resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } if (!string.IsNullOrEmpty(testStorage)) { resultCreateModel.AutomatedTestStorage = testStorage; } //test case duration, starttime and endtime TimeSpan testCaseDuration = TimeSpan.Zero; if (testCaseNode.Attributes["time"] != null && testCaseNode.Attributes["time"].Value != null) { double duration = 0; double.TryParse(testCaseNode.Attributes["time"].Value, out duration); testCaseDuration = TimeSpan.FromSeconds(duration); } resultCreateModel.DurationInMs = testCaseDuration.TotalMilliseconds.ToString(CultureInfo.InvariantCulture); if (assemblyStartTime != DateTime.MinValue) { resultCreateModel.StartedDate = testCaseStartTime.ToString("o"); resultCreateModel.CompletedDate = testCaseStartTime.AddTicks(testCaseDuration.Ticks).ToString("o"); testCaseStartTime = testCaseStartTime.AddTicks(1) + testCaseDuration; //next start time } //test run outcome if (testCaseNode.SelectSingleNode("./failure") != null) { resultCreateModel.Outcome = "Failed"; XmlNode failureMessageNode, failureStackTraceNode; if ((failureMessageNode = testCaseNode.SelectSingleNode("./failure/message")) != null && !string.IsNullOrWhiteSpace(failureMessageNode.InnerText)) { resultCreateModel.ErrorMessage = failureMessageNode.InnerText; } // stack trace if ((failureStackTraceNode = testCaseNode.SelectSingleNode("./failure/stack-trace")) != null && !string.IsNullOrWhiteSpace(failureStackTraceNode.InnerText)) { resultCreateModel.StackTrace = failureStackTraceNode.InnerText; } } else { resultCreateModel.Outcome = "Passed"; } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; //other properties if (runUserIdRef != null) { resultCreateModel.RunBy = runUserIdRef; resultCreateModel.Owner = runUserIdRef; } resultCreateModel.ComputerName = hostName; if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } } XmlNodeList testSuiteNodes = startNode.SelectNodes("results/test-suite"); if (testSuiteNodes != null) { foreach (XmlNode testSuiteNode in testSuiteNodes) { results.AddRange(FindTestCaseNodes(testSuiteNode, hostName, runUserIdRef, assemblyStartTime, testStorage)); } } return results; }
/// <summary> /// Reads all test result nodes /// </summary> /// <param name="resultsNodes"></param> /// <returns>List of test case results</returns> private List <TestCaseResultData> ReadActualResults(XmlNodeList resultsNodes) { List <TestCaseResultData> results = new List <TestCaseResultData>(); var resultXmlNodes = resultsNodes.Cast <XmlNode>(); foreach (var testCaseNode in resultXmlNodes) { TestCaseResultData resultCreateModel = new TestCaseResultData(); // find test case title and other information resultCreateModel.TestCaseTitle = testCaseNode.SelectSingleNode("./Name")?.InnerText; resultCreateModel.AutomatedTestName = testCaseNode.SelectSingleNode("./FullName")?.InnerText; resultCreateModel.AutomatedTestStorage = testCaseNode.SelectSingleNode("./Path")?.InnerText; resultCreateModel.AutomatedTestType = ParserName; // find duration of test case, starttime and endtime resultCreateModel.DurationInMs = (long)GetTestCaseResultDuration(testCaseNode).TotalMilliseconds; // start time of test case is kept as run start time sice test case start is not available resultCreateModel.StartedDate = _runStartDate; resultCreateModel.CompletedDate = resultCreateModel.StartedDate.AddMilliseconds(resultCreateModel.DurationInMs); // find test case outcome resultCreateModel.Outcome = GetTestCaseOutcome(testCaseNode).ToString(); // If test outcome is failed, fill stacktrace and error message if (resultCreateModel.Outcome.ToString().Equals(TestOutcome.Failed.ToString())) { XmlNode failure; // Stacktrace if ((failure = testCaseNode.SelectSingleNode("./Results/Measurement/Value")) != null) { if (!string.IsNullOrEmpty(failure.InnerText)) { resultCreateModel.StackTrace = failure.InnerText; } } } else { // fill console logs resultCreateModel.AttachmentData = new AttachmentData(); XmlNode stdOutputLog = testCaseNode.SelectSingleNode("./Results/Measurement/Value"); if (!string.IsNullOrEmpty(stdOutputLog?.InnerText)) { resultCreateModel.AttachmentData.ConsoleLog = stdOutputLog.InnerText; } } resultCreateModel.State = "Completed"; //other properties if (_runUserIdRef != null) { resultCreateModel.RunBy = _runUserIdRef; resultCreateModel.Owner = _runUserIdRef; } //Mandatory fields. Skip if they are not available. if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } return(results); }
private List <TestCaseResultData> ReadActualResults(XmlNodeList resultsNodes, string testType) { List <TestCaseResultData> results = new List <TestCaseResultData>(); object sync = new object(); Parallel.ForEach <XmlNode>(resultsNodes.Cast <XmlNode>(), resultNode => { TestCaseResultData resultCreateModel = new TestCaseResultData() { Priority = TestManagementConstants.UnspecifiedPriority, //Priority is int type so if no priority set then its 255. }; //Find and format dates as per TCM requirement. TimeSpan duration; if (resultNode.Attributes["duration"] != null && resultNode.Attributes["duration"].Value != null) { TimeSpan.TryParse(resultNode.Attributes["duration"].Value, CultureInfo.InvariantCulture, out duration); } else { duration = TimeSpan.Zero; } resultCreateModel.DurationInMs = duration.TotalMilliseconds; DateTime startedDate; if (resultNode.Attributes["startTime"] != null && resultNode.Attributes["startTime"].Value != null) { DateTime.TryParse(resultNode.Attributes["startTime"].Value, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out startedDate); } else { startedDate = DateTime.UtcNow; } resultCreateModel.StartedDate = startedDate; DateTime completedDate = startedDate.AddTicks(duration.Ticks); resultCreateModel.CompletedDate = completedDate; if (resultNode.Attributes["outcome"] == null || resultNode.Attributes["outcome"].Value == null || string.Equals(resultNode.Attributes["outcome"].Value, "failed", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Failed.ToString();; } else if (string.Equals(resultNode.Attributes["outcome"].Value, "passed", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } else if (string.Equals(resultNode.Attributes["outcome"].Value, "inconclusive", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Inconclusive.ToString(); } else { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); } if (resultNode.Attributes["testName"] != null && resultNode.Attributes["testName"].Value != null) { resultCreateModel.TestCaseTitle = resultNode.Attributes["testName"].Value; } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = testType; if (resultNode.Attributes["computerName"] != null && resultNode.Attributes["computerName"].Value != null) { resultCreateModel.ComputerName = resultNode.Attributes["computerName"].Value; } if (resultNode.Attributes["testId"] != null && resultNode.Attributes["testId"].Value != null) { resultCreateModel.AutomatedTestId = resultNode.Attributes["testId"].Value; } string executionId = null; if (resultNode.Attributes["executionId"] != null && resultNode.Attributes["executionId"].Value != null) { executionId = resultNode.Attributes["executionId"].Value; } lock (sync) { if (resultCreateModel.AutomatedTestId != null && _definitions.ContainsKey(resultCreateModel.AutomatedTestId)) { TestCaseDefinition definition = _definitions[resultCreateModel.AutomatedTestId]; if (definition != null) { if (definition.Storage != null) { resultCreateModel.AutomatedTestStorage = definition.Storage; } if (definition.Priority != null) { resultCreateModel.Priority = !string.IsNullOrEmpty(definition.Priority) ? Convert.ToInt32(definition.Priority) : TestManagementConstants.UnspecifiedPriority; } if (definition.Owner != null) { resultCreateModel.Owner = definition.Owner; } if (definition.AutomatedTestName != null) { resultCreateModel.AutomatedTestName = definition.AutomatedTestName; } } } //AutomatedTestId should be a valid guid. Delaying the check to here since we use it as dictionary key above. Guid automatedTestId; if (!Guid.TryParse(resultCreateModel.AutomatedTestId, out automatedTestId)) { resultCreateModel.AutomatedTestId = null; } } if (resultNode.Attributes["testType"] != null && resultNode.Attributes["testType"].Value != null) { Guid automatedTestType; if (Guid.TryParse(resultNode.Attributes["testType"].Value, out automatedTestType)) { resultCreateModel.AutomatedTestTypeId = resultNode.Attributes["testType"].Value; } } resultCreateModel.RunBy = _runUserIdRef; if (resultCreateModel.Outcome.Equals("Failed")) { XmlNode errorMessage, errorStackTrace, consoleLog, standardError; if ((errorMessage = resultNode.SelectSingleNode("./Output/ErrorInfo/Message")) != null && !string.IsNullOrWhiteSpace(errorMessage.InnerText)) { resultCreateModel.ErrorMessage = errorMessage.InnerText; } // stack trace if ((errorStackTrace = resultNode.SelectSingleNode("./Output/ErrorInfo/StackTrace")) != null && !string.IsNullOrWhiteSpace(errorStackTrace.InnerText)) { resultCreateModel.StackTrace = errorStackTrace.InnerText; } // console log if ((consoleLog = resultNode.SelectSingleNode("./Output/StdOut")) != null && !string.IsNullOrWhiteSpace(consoleLog.InnerText)) { resultCreateModel.ConsoleLog = consoleLog.InnerText; } // standard error if ((standardError = resultNode.SelectSingleNode("./Output/StdErr")) != null && !string.IsNullOrWhiteSpace(standardError.InnerText)) { resultCreateModel.StandardError = standardError.InnerText; } } List <string> resulLeveltAttachments = new List <string>() { }; XmlNodeList resultAttachmentNodes = resultNode.SelectNodes("CollectorDataEntries/Collector/UriAttachments/UriAttachment/A"); if (resultAttachmentNodes.Count > 0 && executionId != null) { foreach (XmlNode resultAttachmentNode in resultAttachmentNodes) { if (resultAttachmentNode.Attributes["href"] != null && resultAttachmentNode.Attributes["href"].Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultAttachmentNode.Attributes["href"].Value)); } } } XmlNodeList resultFileNodes = resultNode.SelectNodes("ResultFiles/ResultFile"); if (resultFileNodes.Count > 0 && executionId != null) { foreach (XmlNode resultFileNode in resultFileNodes) { if (resultFileNode.Attributes["path"] != null && resultFileNode.Attributes["path"].Value != null) { resulLeveltAttachments.Add(Path.Combine(_attachmentLocation, executionId, resultFileNode.Attributes["path"].Value)); } } } resultCreateModel.Attachments = resulLeveltAttachments.ToArray(); lock (sync) { //Mandatory fields. Skip if they are not available. if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } }); return(results); }
public void AddResultsWithAttachmentsCallsRightApi() { SetupMocks(); //Add results _testRunData = _publisher.ReadResultsFromFile(_testRunContext, "filepath"); _publisher.StartTestRunAsync(_testRunData); var result = new TestCaseResultData(); var testRun = new TestRun { Id = 1 }; result.Attachments = new string[] { "attachment.txt" }; _publisher.AddResultsAsync(testRun, new TestCaseResultData[] { result }).Wait(); Assert.Equal(_resultsLevelAttachments.Count, 1); Assert.Equal(_resultsLevelAttachments[1].Count, 1); Assert.Equal(_resultsLevelAttachments[1][0].AttachmentType, AttachmentType.GeneralAttachment.ToString()); Assert.Equal(_resultsLevelAttachments[1][0].Comment, ""); Assert.Equal(_resultsLevelAttachments[1][0].FileName, "attachment.txt"); }
private List <TestCaseResultData> FindTestCaseNodes(XmlNode startNode, string hostName, IdentityRef runUserIdRef, DateTime assemblyStartTime, string assemblyName = null) { List <TestCaseResultData> results = new List <TestCaseResultData>(); string testStorage = assemblyName; if (startNode.Attributes["type"] != null && startNode.Attributes["type"].Value != null && startNode.Attributes["type"].Value.Equals("assembly", StringComparison.OrdinalIgnoreCase)) { if (startNode.Attributes["name"] != null && startNode.Attributes["name"].Value != null) { testStorage = startNode.Attributes["name"].Value; } } //get each test case result information XmlNodeList testCaseNodes = startNode.SelectNodes(TestCaseNodeName); //all test-case nodes under testAssemblyNode if (testCaseNodes != null) { DateTime testCaseStartTime = assemblyStartTime; foreach (XmlNode testCaseNode in testCaseNodes) { TestCaseResultData resultCreateModel = new TestCaseResultData(); //test case name and type if (testCaseNode.Attributes["name"] != null && testCaseNode.Attributes["name"].Value != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["name"].Value; resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } if (!string.IsNullOrEmpty(testStorage)) { resultCreateModel.AutomatedTestStorage = testStorage; } //test case duration, starttime and endtime TimeSpan testCaseDuration = TimeSpan.Zero; if (testCaseNode.Attributes["time"] != null && testCaseNode.Attributes["time"].Value != null) { double duration = 0; double.TryParse(testCaseNode.Attributes["time"].Value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out duration); testCaseDuration = TimeSpan.FromSeconds(duration); } resultCreateModel.DurationInMs = testCaseDuration.TotalMilliseconds; if (assemblyStartTime != DateTime.MinValue) { resultCreateModel.StartedDate = testCaseStartTime; resultCreateModel.CompletedDate = testCaseStartTime.AddTicks(testCaseDuration.Ticks); testCaseStartTime = testCaseStartTime.AddTicks(1) + testCaseDuration; //next start time } //test run outcome if (testCaseNode.SelectSingleNode("./failure") != null) { resultCreateModel.Outcome = "Failed"; XmlNode failureMessageNode, failureStackTraceNode; if ((failureMessageNode = testCaseNode.SelectSingleNode("./failure/message")) != null && !string.IsNullOrWhiteSpace(failureMessageNode.InnerText)) { resultCreateModel.ErrorMessage = failureMessageNode.InnerText; } // stack trace if ((failureStackTraceNode = testCaseNode.SelectSingleNode("./failure/stack-trace")) != null && !string.IsNullOrWhiteSpace(failureStackTraceNode.InnerText)) { resultCreateModel.StackTrace = failureStackTraceNode.InnerText; } } else { if (testCaseNode.Attributes["result"] != null && string.Equals(testCaseNode.Attributes["result"].Value, "Ignored", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = "NotExecuted"; } else { resultCreateModel.Outcome = "Passed"; } } resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = "NUnit"; //other properties if (runUserIdRef != null) { resultCreateModel.RunBy = runUserIdRef; resultCreateModel.Owner = runUserIdRef; } resultCreateModel.ComputerName = hostName; if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } } XmlNodeList testSuiteNodes = startNode.SelectNodes(InnerTestSuiteNodeName); if (testSuiteNodes != null) { foreach (XmlNode testSuiteNode in testSuiteNodes) { results.AddRange(FindTestCaseNodes(testSuiteNode, hostName, runUserIdRef, assemblyStartTime, testStorage)); } } return(results); }
//Based on the XUnit V2 format: http://xunit.github.io/docs/format-xml-v2.html public TestRunData ReadResults(IExecutionContext executionContext, string filePath, TestRunContext runContext = null) { List<TestCaseResultData> results = new List<TestCaseResultData>(); XmlDocument doc = new XmlDocument(); try { var settings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Prohibit }; using (XmlReader reader = XmlReader.Create(filePath, settings)) { doc.Load(reader); } } catch (XmlException ex) { executionContext.Warning(StringUtil.Loc("FailedToReadFile", filePath, ex.Message)); return null; } string runName = Name + " Test Run"; string runUser = ""; if (runContext != null) { if (!string.IsNullOrWhiteSpace(runContext.RunName)) { runName = runContext.RunName; } else { runName = string.Format(CultureInfo.CurrentCulture, "{0} {1} {2}", runName, runContext.Configuration, runContext.Platform); } if (runContext.Owner != null) { runUser = runContext.Owner; } } IdentityRef runUserIdRef = new IdentityRef(); runUserIdRef.DisplayName = runUser; var runStartTime = DateTime.MinValue; double testRunDuration = 0; XmlNodeList assemblyNodes = doc.SelectNodes("/assemblies/assembly"); foreach (XmlNode assemblyNode in assemblyNodes) { var assemblyRunStartTimeStamp = DateTime.MinValue; if (assemblyNode.Attributes["run-date"] != null && assemblyNode.Attributes["run-time"] != null) { string runDate = assemblyNode.Attributes["run-date"].Value; string runTime = assemblyNode.Attributes["run-time"].Value; var startDate = DateTime.Now; var startTime = TimeSpan.Zero; if (DateTime.TryParse(runDate, out startDate)) { TimeSpan.TryParse(runTime, out startTime); } assemblyRunStartTimeStamp = startDate + startTime; if (testRunDuration == 0) { // first assembly start time is runstart time runStartTime = assemblyRunStartTimeStamp; } } XmlNodeList testCaseNodeList = assemblyNode.SelectNodes("./collection/test"); foreach (XmlNode testCaseNode in testCaseNodeList) { TestCaseResultData resultCreateModel = new TestCaseResultData(); //Test storage. if (assemblyNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestStorage = Path.GetFileName(assemblyNode.Attributes["name"].Value); } //Fully Qualified Name. if (testCaseNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } //Test Method Name. if (testCaseNode.Attributes["method"] != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["method"].Value; } //Test duration. if (testCaseNode.Attributes["time"] != null && testCaseNode.Attributes["time"].Value != null) { double duration = 0; double.TryParse(testCaseNode.Attributes["time"].Value, out duration); var durationFromSeconds = TimeSpan.FromSeconds(duration); resultCreateModel.DurationInMs = durationFromSeconds.TotalMilliseconds.ToString(CultureInfo.InvariantCulture); // no assemblystarttime available so dont set testcase start and completed if (assemblyRunStartTimeStamp != DateTime.MinValue) { resultCreateModel.StartedDate = assemblyRunStartTimeStamp.ToString("o"); resultCreateModel.CompletedDate = assemblyRunStartTimeStamp.AddTicks(durationFromSeconds.Ticks).ToString("o"); assemblyRunStartTimeStamp = assemblyRunStartTimeStamp.AddTicks(1) + durationFromSeconds; //next start time } //Calculate overall run duration. testRunDuration += duration; } //Test outcome. if (testCaseNode.SelectSingleNode("./failure") != null) { resultCreateModel.Outcome = TestOutcome.Failed.ToString(); //Error message. XmlNode failureMessageNode = testCaseNode.SelectSingleNode("./failure/message"); if (failureMessageNode != null && !string.IsNullOrWhiteSpace(failureMessageNode.InnerText)) { resultCreateModel.ErrorMessage = failureMessageNode.InnerText; } //Stack trace. XmlNode failureStackTraceNode = testCaseNode.SelectSingleNode("./failure/stack-trace"); if (failureStackTraceNode != null && !string.IsNullOrWhiteSpace(failureStackTraceNode.InnerText)) { resultCreateModel.StackTrace = failureStackTraceNode.InnerText; } } else if (testCaseNode.Attributes["result"] != null && string.Equals(testCaseNode.Attributes["result"].Value, "pass", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } else { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); } //Test priority. XmlNode priorityTrait = testCaseNode.SelectSingleNode("./traits/trait[@name='priority']"); if (priorityTrait != null && priorityTrait.Attributes["value"] != null) { resultCreateModel.TestCasePriority = priorityTrait.Attributes["value"].Value; } //Test owner. XmlNode ownerNode = testCaseNode.SelectSingleNode("./traits/trait[@name='owner']"); if (ownerNode != null && ownerNode.Attributes["value"] != null && ownerNode.Attributes["value"].Value != null) { IdentityRef ownerIdRef = new IdentityRef(); ownerIdRef.DisplayName = ownerNode.Attributes["value"].Value; resultCreateModel.Owner = ownerIdRef; } resultCreateModel.RunBy = runUserIdRef; resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } } TestRunData testRunData = new TestRunData( name: runName, buildId: runContext != null ? runContext.BuildId : 0, startedDate: (runStartTime == DateTime.MinValue) ? string.Empty : runStartTime.ToString("o"), completedDate: (runStartTime == DateTime.MinValue) ? string.Empty : runStartTime.Add(TimeSpan.FromSeconds(testRunDuration)).ToString("o"), state: TestRunState.InProgress.ToString(), isAutomated: true, buildFlavor: runContext != null ? runContext.Configuration : null, buildPlatform: runContext != null ? runContext.Platform : null, releaseUri: runContext != null ? runContext.ReleaseUri : null, releaseEnvironmentUri: runContext != null ? runContext.ReleaseEnvironmentUri : null ); testRunData.Results = results.ToArray(); testRunData.Attachments = AddResultsFileToRunLevelAttachments ? new string[] { filePath } : new string[0]; return testRunData; }
//Based on the XUnit V2 format: http://xunit.github.io/docs/format-xml-v2.html public TestRunData ReadResults(IExecutionContext executionContext, string filePath, TestRunContext runContext = null) { List <TestCaseResultData> results = new List <TestCaseResultData>(); XmlDocument doc = new XmlDocument(); try { var settings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }; using (XmlReader reader = XmlReader.Create(filePath, settings)) { doc.Load(reader); } } catch (XmlException ex) { executionContext.Warning(StringUtil.Loc("FailedToReadFile", filePath, ex.Message)); return(null); } string runName = Name + " Test Run"; string runUser = ""; if (runContext != null) { if (!string.IsNullOrWhiteSpace(runContext.RunName)) { runName = runContext.RunName; } else { runName = string.Format(CultureInfo.CurrentCulture, "{0} {1} {2}", runName, runContext.Configuration, runContext.Platform); } if (runContext.Owner != null) { runUser = runContext.Owner; } } IdentityRef runUserIdRef = new IdentityRef(); runUserIdRef.DisplayName = runUser; var runStartTime = DateTime.MinValue; double testRunDuration = 0; XmlNodeList assemblyNodes = doc.SelectNodes("/assemblies/assembly"); foreach (XmlNode assemblyNode in assemblyNodes) { var assemblyRunStartTimeStamp = DateTime.MinValue; if (assemblyNode.Attributes["run-date"] != null && assemblyNode.Attributes["run-time"] != null) { string runDate = assemblyNode.Attributes["run-date"].Value; string runTime = assemblyNode.Attributes["run-time"].Value; var startDate = DateTime.Now; var startTime = TimeSpan.Zero; if (DateTime.TryParse(runDate, out startDate)) { TimeSpan.TryParse(runTime, out startTime); } assemblyRunStartTimeStamp = startDate + startTime; if (testRunDuration == 0) { // first assembly start time is runstart time runStartTime = assemblyRunStartTimeStamp; } } XmlNodeList testCaseNodeList = assemblyNode.SelectNodes("./collection/test"); foreach (XmlNode testCaseNode in testCaseNodeList) { TestCaseResultData resultCreateModel = new TestCaseResultData() { Priority = TestManagementConstants.UnspecifiedPriority, //Priority is int type so if no priority set then its 255. }; //Test storage. if (assemblyNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestStorage = Path.GetFileName(assemblyNode.Attributes["name"].Value); } //Fully Qualified Name. if (testCaseNode.Attributes["name"] != null) { resultCreateModel.AutomatedTestName = testCaseNode.Attributes["name"].Value; } //Test Method Name. if (testCaseNode.Attributes["method"] != null) { resultCreateModel.TestCaseTitle = testCaseNode.Attributes["method"].Value; } //Test duration. if (testCaseNode.Attributes["time"] != null && testCaseNode.Attributes["time"].Value != null) { double duration = 0; double.TryParse(testCaseNode.Attributes["time"].Value, out duration); var durationFromSeconds = TimeSpan.FromSeconds(duration); resultCreateModel.DurationInMs = durationFromSeconds.TotalMilliseconds; // no assemblystarttime available so dont set testcase start and completed if (assemblyRunStartTimeStamp != DateTime.MinValue) { resultCreateModel.StartedDate = assemblyRunStartTimeStamp; resultCreateModel.CompletedDate = assemblyRunStartTimeStamp.AddTicks(durationFromSeconds.Ticks); assemblyRunStartTimeStamp = assemblyRunStartTimeStamp.AddTicks(1) + durationFromSeconds; //next start time } //Calculate overall run duration. testRunDuration += duration; } //Test outcome. if (testCaseNode.SelectSingleNode("./failure") != null) { resultCreateModel.Outcome = TestOutcome.Failed.ToString(); //Error message. XmlNode failureMessageNode = testCaseNode.SelectSingleNode("./failure/message"); if (failureMessageNode != null && !string.IsNullOrWhiteSpace(failureMessageNode.InnerText)) { resultCreateModel.ErrorMessage = failureMessageNode.InnerText; } //Stack trace. XmlNode failureStackTraceNode = testCaseNode.SelectSingleNode("./failure/stack-trace"); if (failureStackTraceNode != null && !string.IsNullOrWhiteSpace(failureStackTraceNode.InnerText)) { resultCreateModel.StackTrace = failureStackTraceNode.InnerText; } } else if (testCaseNode.Attributes["result"] != null && string.Equals(testCaseNode.Attributes["result"].Value, "pass", StringComparison.OrdinalIgnoreCase)) { resultCreateModel.Outcome = TestOutcome.Passed.ToString(); } else { resultCreateModel.Outcome = TestOutcome.NotExecuted.ToString(); } //Test priority. XmlNode priorityTrait = testCaseNode.SelectSingleNode("./traits/trait[@name='priority']"); if (priorityTrait != null && priorityTrait.Attributes["value"] != null) { var priorityValue = priorityTrait.Attributes["value"].Value; resultCreateModel.Priority = !string.IsNullOrEmpty(priorityValue) ? Convert.ToInt32(priorityValue) : TestManagementConstants.UnspecifiedPriority; } //Test owner. XmlNode ownerNode = testCaseNode.SelectSingleNode("./traits/trait[@name='owner']"); if (ownerNode != null && ownerNode.Attributes["value"] != null && ownerNode.Attributes["value"].Value != null) { IdentityRef ownerIdRef = new IdentityRef(); ownerIdRef.DisplayName = ownerNode.Attributes["value"].Value; resultCreateModel.Owner = ownerIdRef; } resultCreateModel.RunBy = runUserIdRef; resultCreateModel.State = "Completed"; resultCreateModel.AutomatedTestType = Name; if (!string.IsNullOrEmpty(resultCreateModel.AutomatedTestName) && !string.IsNullOrEmpty(resultCreateModel.TestCaseTitle)) { results.Add(resultCreateModel); } } } TestRunData testRunData = new TestRunData( name: runName, buildId: runContext != null ? runContext.BuildId : 0, startedDate: (runStartTime == DateTime.MinValue) ? string.Empty : runStartTime.ToString("o"), completedDate: (runStartTime == DateTime.MinValue) ? string.Empty : runStartTime.Add(TimeSpan.FromSeconds(testRunDuration)).ToString("o"), state: TestRunState.InProgress.ToString(), isAutomated: true, buildFlavor: runContext != null ? runContext.Configuration : null, buildPlatform: runContext != null ? runContext.Platform : null, releaseUri: runContext != null ? runContext.ReleaseUri : null, releaseEnvironmentUri: runContext != null ? runContext.ReleaseEnvironmentUri : null ); testRunData.Results = results.ToArray(); testRunData.Attachments = AddResultsFileToRunLevelAttachments ? new string[] { filePath } : new string[0]; return(testRunData); }
public void VerifyStartEndTestRunTimeWhenPublishingToSingleTestRun() { SetupMocks(); var resultCommand = new ResultsCommandExtension(); resultCommand.Initialize(_hc); var command = new Command("results", "publish"); command.Properties.Add("resultFiles", "file1.trx,file2.trx"); command.Properties.Add("type", "NUnit"); command.Properties.Add("mergeResults", bool.TrueString); var resultsFiles = new List<string> { "file1.trx", "file2.trx" }; var durationInMs = 10; var testRunData = new TestRunData(); var testCaseResultData = new TestCaseResultData(); testCaseResultData.DurationInMs = durationInMs.ToString(); testRunData.Results = new TestCaseResultData[] { testCaseResultData, testCaseResultData }; testRunData.Attachments = new string[] { "attachment1", "attachment2" }; _mockTestRunPublisher.Setup(q => q.StartTestRunAsync(It.IsAny<TestRunData>(), It.IsAny<CancellationToken>())) .Callback((TestRunData trd, CancellationToken cancellationToken) => { var startedDate = DateTime.Parse(trd.StartDate, null, DateTimeStyles.RoundtripKind); var endedDate = DateTime.Parse(trd.CompleteDate, null, DateTimeStyles.RoundtripKind); Assert.Equal(resultsFiles.Count * testRunData.Results.Length * durationInMs, (endedDate - startedDate).TotalMilliseconds); }); _mockTestRunPublisher.Setup(q => q.AddResultsAsync(It.IsAny<TestRun>(), It.IsAny<TestCaseResultData[]>(), It.IsAny<CancellationToken>())) .Callback((TestRun testRun, TestCaseResultData[] tcrd, CancellationToken cancellationToken) => { }); _mockTestRunPublisher.Setup(q => q.ReadResultsFromFile(It.IsAny<TestRunContext>(), It.IsAny<string>())) .Returns(testRunData); _mockTestRunPublisher.Setup(q => q.EndTestRunAsync(It.IsAny<TestRunData>(), It.IsAny<int>(), It.IsAny<bool>(), It.IsAny<CancellationToken>())) .Returns(Task.CompletedTask); resultCommand.ProcessCommand(_ec.Object, command); }