private TestStepRun CreateFakeRun(string id, TestOutcome outcome, params TestStepRun[] children) { var run = new TestStepRun(new TestStepData(id, id, id, id)); run.Result = new TestResult(outcome); run.Children.AddRange(children); return run; }
public void ConstructorTest() { TestStepData step = new TestStepData("id", "name", "fullName", "testId"); TestStepRun testStepRun = new TestStepRun(step); Assert.AreSame(step, testStepRun.Step); Assert.Count(0, testStepRun.Children); }
private ObjectModel.TestResult CreateTest(TestData test, TestStepRun stepRun, TestCase testCase) { ObjectModel.TestResult testResult = new ObjectModel.TestResult(testCase); testResult.DisplayName = test.Name; testResult.ErrorLineNumber = test.CodeLocation.Line; //testResult.ErrorStackTrace testResult.StartTime = stepRun.StartTime; if (stepRun.TestLog.Streams.Count > 0) { testResult.ErrorMessage = stepRun.TestLog.Streams[0].ToString(); } testResult.EndTime = stepRun.EndTime; testResult.Duration = stepRun.Result.Duration; var testStatus = stepRun.Result.Outcome.Status; switch (testStatus) { case TestStatus.Passed: testResult.Outcome = ObjectModel.TestOutcome.Passed; break; case TestStatus.Failed: testResult.Outcome = ObjectModel.TestOutcome.Failed; break; case TestStatus.Skipped: testResult.Outcome = ObjectModel.TestOutcome.Skipped; break; case TestStatus.Inconclusive: testResult.Outcome = ObjectModel.TestOutcome.NotFound; break; } return testResult; }
public void TestStepFinished_Test() { var testStepRun = new TestStepRun(new TestStepData("root", "name", "fullName", "root")) { TestLog = new StructuredDocument() }; testStepRun.TestLog.Attachments.Add(new TextAttachment("name", "contentType", "text").ToAttachmentData()); var report = new Report { TestPackageRun = new TestPackageRun(), TestModel = new TestModelData() }; report.TestPackageRun.RootTestStepRun = testStepRun; testController.Stub(x => x.ReadReport(null)).IgnoreArguments().Do((Action<ReadAction<Report>>)(action => action(report))); testTreeModel.Stub(x => x.Root).Return(new TestTreeNode("root", "root")); var flag = false; executionLogController.ExecutionLogUpdated += (sender, e) => { Assert.Count(1, e.TestStepRuns); flag = true; }; var testData = new TestData("root", "name", "fullName") { IsTestCase = true }; executionLogController.Handle(new TestStepFinished(testData, null)); Assert.IsTrue(flag); }
private static GallioTestResult CreateTestResult(TestStepRun run, Guid runId, ITestElement test, bool includeTestStepRunXml) { var result = new GallioTestResult(runId, test); result.TestName = run.Step.FullName; result.Outcome = GetOutcome(run.Result.Outcome); foreach (StructuredStream stream in run.TestLog.Streams) { string contents = stream.ToString(); if (stream.Name == MarkupStreamNames.DebugTrace) result.DebugTrace += contents; else if (stream.Name == MarkupStreamNames.ConsoleOutput) result.StdOut += contents; else if (stream.Name == MarkupStreamNames.ConsoleError) result.StdErr += contents; else if (stream.Name == MarkupStreamNames.Failures || stream.Name == MarkupStreamNames.Warnings) result.ErrorMessage += contents; else result.DebugTrace += contents; } result.SetTimings(run.StartTime, run.EndTime, run.Result.Duration); if (includeTestStepRunXml) result.TestStepRunXml = TestStepRunToXml(run); foreach (TestStepRun childRun in run.Children) result.AddInnerResult(CreateTestResult(childRun, runId, test, false)); return result; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="lifecyclePhase">The lifecycle phase name.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/>, or <paramref name="lifecyclePhase"/> is null.</exception> public TestStepLifecyclePhaseChangedEventArgs(Report report, TestData test, TestStepRun testStepRun, string lifecyclePhase) : base(report, test, testStepRun) { if (lifecyclePhase == null) throw new ArgumentNullException("lifecyclePhase"); this.lifecyclePhase = lifecyclePhase; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <param name="sectionName">The name of the section that was started.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/>, <paramref name="logStreamName"/>, or <paramref name="sectionName"/> is null.</exception> public TestStepLogStreamBeginSectionBlockEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName, string sectionName) : base(report, test, testStepRun, logStreamName) { if (sectionName == null) throw new ArgumentNullException("sectionName"); this.sectionName = sectionName; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="attachment">The attachment.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/> or <paramref name="attachment"/> is null.</exception> public TestStepLogAttachEventArgs(Report report, TestData test, TestStepRun testStepRun, Attachment attachment) : base(report, test, testStepRun) { if (attachment == null) throw new ArgumentNullException("attachment"); this.attachment = attachment; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <param name="text">The text that was written.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/> or <paramref name="logStreamName"/> is null.</exception> public TestStepLogStreamWriteEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName, string text) : base(report, test, testStepRun, logStreamName) { if (text == null) throw new ArgumentNullException("text"); this.text = text; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/> or <paramref name="logStreamName"/> is null.</exception> protected TestStepLogStreamEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName) : base(report, test, testStepRun) { if (logStreamName == null) throw new ArgumentNullException("logStreamName"); this.logStreamName = logStreamName; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <param name="attachmentName">The name of the attachment that was embedded.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/>, <paramref name="logStreamName"/>, or <paramref name="attachmentName"/> is null.</exception> public TestStepLogStreamEmbedEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName, string attachmentName) : base(report, test, testStepRun, logStreamName) { if (attachmentName == null) throw new ArgumentNullException("attachmentName"); this.attachmentName = attachmentName; }
public void TestInstanceRuns() { TestStepRun testStepRun = new TestStepRun(new TestStepData("stepId", "stepName", "stepFullName", "testId")); testStepRun.Children.Add(new TestStepRun(new TestStepData("stepId", "stepName", "stepFullName", "testId"))); testPackageRun.RootTestStepRun = testStepRun; Assert.AreElementsEqual(new TestStepRun[] { testStepRun, testStepRun.Children[0] }, testPackageRun.AllTestStepRuns); }
private static TestStepFinished GetTestStepFinished(TestStatus testStatus) { var testStepRun = new TestStepRun(new TestStepData("id", "name", "fullName", "testId")) { Step = new TestStepData("id", "name", "fullName", "testId") { IsTestCase = true }, Result = new TestResult(new TestOutcome(testStatus)) }; return new TestStepFinished(null, testStepRun); }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="metadataKey">The metadata key.</param> /// <param name="metadataValue">The metadata value.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/>, <paramref name="metadataKey"/> or <paramref name="metadataValue" /> is null.</exception> public TestStepMetadataAddedEventArgs(Report report, TestData test, TestStepRun testStepRun, string metadataKey, string metadataValue) : base(report, test, testStepRun) { if (metadataKey == null) throw new ArgumentNullException("metadataKey"); if (metadataValue == null) throw new ArgumentNullException("metadataValue"); this.metadataKey = metadataKey; this.metadataValue = metadataValue; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// or <paramref name="testStepRun"/> is null.</exception> protected TestStepEventArgs(Report report, TestData test, TestStepRun testStepRun) { if (report == null) throw new ArgumentNullException("report"); if (test == null) throw new ArgumentNullException("test"); if (testStepRun == null) throw new ArgumentNullException("testStepRun"); this.report = report; this.test = test; this.testStepRun = testStepRun; }
public TestResult BuildTestResult(TestData testData, TestStepRun testStepRun, TestCase testCase) { var testResult = new TestResult(testCase) { DisplayName = testData.Name, StartTime = testStepRun.StartTime, EndTime = testStepRun.EndTime, Duration = testStepRun.Result.Duration, Outcome = GetOutcome(testStepRun.Result.Outcome.Status), }; var failuresStream = testStepRun.TestLog.GetStream(MarkupStreamNames.Failures); if (failuresStream != null) { testResult.ErrorMessage = failuresStream.ToString(); failuresStream.Body.AcceptContents(new StackTraceHunter(s => testResult.ErrorStackTrace = s)); } return testResult; }
public void MergeStepStatistics(TestStatus status, bool isTestCase) { TestStepRun testStepRun = new TestStepRun(new TestStepData("stepId", "stepName", "fullName", "testId")); testStepRun.Result.Outcome = new TestOutcome(status); testStepRun.Result.AssertCount = 3; testStepRun.Step.IsTestCase = isTestCase; stats.MergeStepStatistics(testStepRun); Assert.AreEqual(3, stats.AssertCount); Assert.AreEqual(1, stats.StepCount); Assert.AreEqual(isTestCase ? 1 : 0, stats.TestCount); Assert.AreEqual(isTestCase && status != TestStatus.Skipped ? 1 : 0, stats.RunCount); Assert.AreEqual(isTestCase && status == TestStatus.Skipped ? 1 : 0, stats.SkippedCount); Assert.AreEqual(isTestCase && status == TestStatus.Passed ? 1 : 0, stats.PassedCount); Assert.AreEqual(isTestCase && status == TestStatus.Inconclusive ? 1 : 0, stats.InconclusiveCount); Assert.AreEqual(isTestCase && status == TestStatus.Failed ? 1 : 0, stats.FailedCount); Assert.AreEqual(isTestCase ? 1 : 0, stats.GetOutcomeCount(new TestOutcome(status))); }
/// <summary> /// Merges statistics from a test step run, incrementing the relevant counters. /// </summary> /// <param name="testStepRun">The test step run.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="testStepRun"/> is null.</exception> public void MergeStepStatistics(TestStepRun testStepRun) { if (testStepRun == null) { throw new ArgumentNullException("testStepRun"); } // The assert count and duration statistics are pre-aggregated in that parent tests include // the values for their children when publishing their results. This implies that the // root test will contain the official final tally which will be larger than all previously // seen tallies. assertCount = Math.Max(assertCount, testStepRun.Result.AssertCount); duration = Math.Max(duration, testStepRun.Result.DurationInSeconds); stepCount += 1; if (!testStepRun.Step.IsTestCase) { return; } testCount += 1; AddOutcome(testStepRun.Result.Outcome); }
/// <summary> /// Returns the log of the specified test step run. /// </summary> /// <param name="run">The test step run.</param> /// <returns>The log text or an empty string.</returns> protected static string GetLog(TestStepRun run) { return GetLog(run, MarkupStreamNames.Default); }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// or <paramref name="testStepRun"/> is null.</exception> public TestStepFinishedEventArgs(Report report, TestData test, TestStepRun testStepRun) : base(report, test, testStepRun) { }
/// <summary> /// Returns the log of the specified test step run. /// </summary> /// <param name="run">The test step run.</param> /// <param name="streamName">The name of log stream.</param> /// <returns>The log text or an empty string.</returns> protected static string GetLog(TestStepRun run, string streamName) { StructuredStream stream = run.TestLog.GetStream(streamName); return (stream == null) ? String.Empty : stream.ToString(); }
private static IEnumerable <TestStepRun> GetChildren(TestStepRun node) { return(node.Children); }
public TestStepState(TestStepState parent, TestData testData, TestStepRun testStepRun) { Parent = parent; TestData = testData; TestStepRun = testStepRun; LogWriter = new StructuredDocumentWriter(); testStepRun.TestLog = LogWriter.Document; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/> or <paramref name="logStreamName"/> is null.</exception> public TestStepLogStreamEndBlockEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName) : base(report, test, testStepRun, logStreamName) { }
public TestStepFinished(TestData testData, TestStepRun testStepRun) { TestData = testData; TestStepRun = testStepRun; }
private static string FormatStream(TestStepRun testStepRun, string streamName) { StructuredStream stream = testStepRun.TestLog.GetStream(streamName); return stream != null ? stream.ToString() : @""; }
/// <summary> /// Builds the tree under the specified root test step run. /// </summary> /// <param name="root">The root test step run.</param> /// <returns></returns> public static TestStepRunNode BuildTreeFromRoot(TestStepRun root) { if (root == null) { var step = new TestStepData(String.Empty, String.Empty, String.Empty, String.Empty); root = new TestStepRun(step); root.Result = new TestResult(); } int index = 0; var node = new TestStepRunNode(root, null, index++); node.Children.AddRange(GetChildren(node, ref index)); return node; }
private static IEnumerable<TestStepRun> GetChildren(TestStepRun node) { return node.Children; }
private TestStepRun CreateFakeTestStepRun(string id, bool isTestCase, TestOutcome outcome, params TestStepRun[] children) { var step = new TestStepData(id, "Name-" + id, "FullName-" + id, "Test-" + id); step.IsTestCase = isTestCase; var run = new TestStepRun(step); run.Result = new TestResult() { Outcome = outcome }; run.Children.AddRange(children); return run; }
/// <summary> /// Initializes the event arguments. /// </summary> /// <param name="report">The report.</param> /// <param name="test">The test data.</param> /// <param name="testStepRun">The test step run.</param> /// <param name="logStreamName">The log stream name.</param> /// <param name="marker">The marker.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="report"/>, <paramref name="test"/> /// <paramref name="testStepRun"/> or <paramref name="logStreamName"/> is null.</exception> public TestStepLogStreamBeginMarkerBlockEventArgs(Report report, TestData test, TestStepRun testStepRun, string logStreamName, Marker marker) : base(report, test, testStepRun, logStreamName) { this.marker = marker; }
public void ExecutionLog_should_be_updated_when_test_selection_changes() { var testStepRun = new TestStepRun(new TestStepData("rootStep", "name", "fullName", "root")); var selectedTests = new List<TestTreeNode> { new TestTreeNode("name", "rootStep") }; var report = new Report { TestPackageRun = new TestPackageRun(), TestModel = new TestModelData() }; report.TestPackageRun.RootTestStepRun = testStepRun; testController.Stub(x => x.ReadReport(Arg<ReadAction<Report>>.Is.Anything)) .Do((Action<ReadAction<Report>>)(action => action(report))); testTreeModel.Stub(x => x.Root).Return(new TestTreeNode("root", "name")); var flag = false; executionLogController.ExecutionLogUpdated += delegate { flag = true; }; executionLogController.Handle(new TestSelectionChanged(selectedTests)); Assert.IsTrue(flag); }
/// <summary> /// Constructor. /// </summary> /// <param name="run">The test step run.</param> /// <param name="parent">The parent node.</param> /// <param name="index">The zero-based index of the test step run in the sequential representation of the tree.</param> public TestStepRunNode(TestStepRun run, TestStepRunNode parent, int index) { if (run == null) throw new ArgumentNullException("run"); this.run = run; this.parent = parent; this.index = index; }