public void CannotMakeTestResultWhenTestCaseIsNotInCache() { var fakeResultNode = FakeTestData.GetResultNode(); var testResult = testConverter.ConvertTestResult(fakeResultNode); Assert.Null(testResult); }
public void CannotMakeTestResultWhenTestCaseIsNotInCache() { var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode()); var results = testConverter.GetVsTestResults(fakeResultNode, Enumerable.Empty <XmlNode>().ToList()); Assert.That(results.TestResults.Count, Is.EqualTo(0)); }
public void CanMakeTestCaseShouldBuildTraitsCache() { var xmlNodeList = FakeTestData.GetTestNodes(); foreach (XmlNode node in xmlNodeList) { var testCase = testConverter.ConvertTestCase(new NUnitTestCase(node)); } var traitsCache = testConverter.TraitsCache; // There are 12 ids in the TestXml2, but will be storing only ancestor properties. // Not the leaf node test-case properties. Assert.That(traitsCache.Keys.Count, Is.EqualTo(7)); // Even though ancestor doesn't have any properties. Will be storing their ids. // So that we will not make call SelectNodes call again. CheckNodesWithNoProperties(traitsCache); // Will not be storing leaf nodes test-case nodes in the cache. CheckNoTestCaseNodesExist(traitsCache); // Checking assembly level attribute. CheckNodeProperties(traitsCache, "0-1009", new[] { new KeyValuePair <string, string>("Category", "AsmCat") }); // Checking Class level attributes base class & dervied class CheckNodeProperties(traitsCache, "0-1000", new[] { new KeyValuePair <string, string>("Category", "BaseClass") }); CheckNodeProperties(traitsCache, "0-1002", new[] { new KeyValuePair <string, string>("Category", "DerivedClass"), new KeyValuePair <string, string>("Category", "BaseClass") }); // Checking Nested class attributes. CheckNodeProperties(traitsCache, "0-1005", new[] { new KeyValuePair <string, string>("Category", "NS1") }); CheckNodeProperties(traitsCache, "0-1007", new[] { new KeyValuePair <string, string>("Category", "NS2") }); }
public void CannotMakeTestResultWhenTestCaseIsNotInCache() { var fakeResultNode = FakeTestData.GetResultNode(); var results = testConverter.GetVSTestResults(fakeResultNode); Assert.That(results.Count, Is.EqualTo(0)); }
public void Attachments_CorrectAmountOfConvertedAttachments() { var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode()); var testResults = testConverter.GetVsTestResults(fakeResultNode, Enumerable.Empty <INUnitTestEventTestOutput>().ToList()); var fakeAttachments = fakeResultNode.NUnitAttachments .Where(n => !string.IsNullOrEmpty(n.FilePath)) .ToArray(); TestContext.Out.WriteLine("Incoming attachments"); foreach (var attachment in fakeAttachments) { TestContext.Out.WriteLine($"{attachment.FilePath}"); } var convertedAttachments = testResults.TestResults .SelectMany(tr => tr.Attachments.SelectMany(ats => ats.Attachments)) .ToArray(); TestContext.Out.WriteLine("\nConverted attachments (Uri, path)"); foreach (var attachment in convertedAttachments) { TestContext.Out.WriteLine($"{attachment.Uri.AbsoluteUri} : {attachment.Uri.LocalPath}"); } Assert.Multiple(() => { Assert.That(convertedAttachments.Length, Is.GreaterThan(0), "Some converted attachments were expected"); Assert.That(convertedAttachments.Length, Is.EqualTo(fakeAttachments.Length), "Attachments are not converted"); }); }
public void SetUp() { fakeTestNode = FakeTestData.GetTestNode(); var settings = Substitute.For <IAdapterSettings>(); settings.CollectSourceInformation.Returns(true); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings); }
public void TestFinished_CallsRecordEnd_Then_RecordResult() { listener.TestFinished(new NUnitTestEventTestCase(FakeTestData.GetResultNode().AsString())); Assert.That(testLog.Events.Count, Is.EqualTo(2)); Assert.That(testLog.Events[0].EventType, Is.EqualTo(FakeFrameworkHandle.EventType.RecordEnd)); Assert.That( testLog.Events[1].EventType, Is.EqualTo(FakeFrameworkHandle.EventType.RecordResult)); }
public void TestFinished_CallsRecordResultCorrectly() { listener.TestFinished(new NUnitTestEventTestCase(FakeTestData.GetResultNode().AsString())); Assume.That(testLog.Events.Count, Is.EqualTo(2)); Assume.That(testLog.Events[1].EventType, Is.EqualTo(FakeFrameworkHandle.EventType.RecordResult)); VerifyTestResult(testLog.Events[1].TestResult); }
public void TestFinished_CallsRecordEndCorrectly() { listener.TestFinished(new NUnitTestEventTestCase(FakeTestData.GetResultNode().AsString())); Assume.That(testLog.Events.Count, Is.EqualTo(2)); Assume.That(testLog.Events[0].EventType, Is.EqualTo(FakeFrameworkHandle.EventType.RecordEnd)); VerifyTestCase(testLog.Events[0].TestCase); Assert.AreEqual(TestOutcome.Passed, testLog.Events[0].TestOutcome); }
public void SetUp() { fakeTestNode = new NUnitTestCase(FakeTestData.GetTestNode()); var settings = Substitute.For <IAdapterSettings>(); settings.ConsoleOut.Returns(0); settings.UseTestNameInConsoleOutput.Returns(false); settings.CollectSourceInformation.Returns(true); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings); }
public void TestFinished_CallsRecordEnd_Then_RecordResult() { listener.TestFinished(FakeTestData.GetResultNode()); Assert.AreEqual(2, testLog.Events.Count); Assert.AreEqual( FakeFrameworkHandle.EventType.RecordEnd, testLog.Events[0].EventType); Assert.AreEqual( FakeFrameworkHandle.EventType.RecordResult, testLog.Events[1].EventType); }
public void CanMakeTestResultFromNUnitTestResult2(string output, string expectedMessages) { var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode()); var outputNodes = output.Split(';').Select(i => XmlHelper.CreateXmlNode(i.Trim())).ToList(); var testResults = testConverter.GetVsTestResults(fakeResultNode, outputNodes); var testResult = testResults.TestResults[0]; var actualMessages = string.Join(";", testResult.Messages.Select(i => i.Category + ":" + i.Text)); Assert.That(actualMessages, Is.EqualTo(expectedMessages)); }
public void SetUp() { testLog = new FakeFrameworkHandle(); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub(), 0), FakeTestData.AssemblyPath); fakeTestNode = FakeTestData.GetTestNode(); // Ensure that the converted testcase is cached testConverter.ConvertTestCase(fakeTestNode); Assert.NotNull(testConverter.GetCachedTestCase("123")); listener = new NUnitEventListener(testLog, testConverter); }
public void SetUp() { testLog = new FakeFrameworkHandle(); using (var testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, collectSourceInformation: true)) { fakeTestNode = FakeTestData.GetTestNode(); // Ensure that the converted testcase is cached testConverter.ConvertTestCase(fakeTestNode); Assert.NotNull(testConverter.GetCachedTestCase("123")); listener = new NUnitEventListener(testLog, testConverter, null); } }
public void SetUp() { testLog = new FakeFrameworkHandle(); settings = Substitute.For <IAdapterSettings>(); executor = Substitute.For <INUnit3TestExecutor>(); executor.Settings.Returns(settings); executor.FrameworkHandle.Returns(testLog); settings.CollectSourceInformation.Returns(true); using var testConverter = new TestConverterForXml(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings); fakeTestNode = new NUnitEventTestCase(FakeTestData.GetTestNode()); // Ensure that the converted testcase is cached testConverter.ConvertTestCase(fakeTestNode); Assert.That(testConverter.GetCachedTestCase("123"), Is.Not.Null); listener = new NUnitEventListener(testConverter, executor); }
public void CanMakeTestCaseShouldBuildTraitsCache() { var xmlNodeList = FakeTestData.GetTestNodes(); var tf = Substitute.For <INUnitDiscoveryCanHaveTestCases>(); foreach (XmlNode node in xmlNodeList) { var xElem = XElement.Load(node.CreateNavigator().ReadSubtree()); var tc = DiscoveryConverter.ExtractTestCase(tf, xElem); var testCase = testConverter.ConvertTestCase(tc); } var traitsCache = testConverter.TraitsCache; Assert.Multiple(() => { // There are 12 ids in the TestXml2, but will be storing only ancestor properties. // Not the leaf node test-case properties. Assert.That(traitsCache.Keys.Count, Is.EqualTo(7)); // Even though ancestor doesn't have any properties. Will be storing their ids. // So that we will not make call SelectNodes call again. CheckNodesWithNoProperties(traitsCache); // Will not be storing leaf nodes test-case nodes in the cache. CheckNoTestCaseNodesExist(traitsCache); // Checking assembly level attribute. CheckNodeProperties(traitsCache, "0-1009", new[] { new KeyValuePair <string, string>("Category", "AsmCat") }); // Checking Class level attributes base class & dervied class CheckNodeProperties(traitsCache, "0-1000", new[] { new KeyValuePair <string, string>("Category", "BaseClass") }); CheckNodeProperties(traitsCache, "0-1002", new[] { new KeyValuePair <string, string>("Category", "DerivedClass"), new KeyValuePair <string, string>("Category", "BaseClass") }); // Checking Nested class attributes. CheckNodeProperties(traitsCache, "0-1005", new[] { new KeyValuePair <string, string>("Category", "NS1") }); CheckNodeProperties(traitsCache, "0-1007", new[] { new KeyValuePair <string, string>("Category", "NS2") }); }); }
public void CanMakeTestResultFromNUnitTestResult() { // This should put the TestCase in the cache var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = FakeTestData.GetResultNode(); var testResult = testConverter.ConvertTestResult(fakeResultNode); var testCase = testResult.TestCase; Assert.That(testCase, Is.SameAs(cachedTestCase)); CheckTestCase(testCase); Assert.That(testResult.Outcome, Is.EqualTo(TestOutcome.Passed)); Assert.That(testResult.ErrorMessage, Is.EqualTo("It passed!")); Assert.That(testResult.Duration, Is.EqualTo(TimeSpan.FromSeconds(1.234))); }
public void CanMakeTestResultFromNUnitTestResult() { // This should put the TestCase in the cache var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode()); var testResults = testConverter.GetVsTestResults(fakeResultNode, Enumerable.Empty <XmlNode>().ToList()); var testResult = testResults.TestResults[0]; var testCase = testResult.TestCase; Assert.That(testCase, Is.SameAs(cachedTestCase)); CheckTestCase(testCase); Assert.That(testResult.Outcome, Is.EqualTo(TestOutcome.Passed)); Assert.That(testResult.ErrorMessage, Is.EqualTo(null)); Assert.That(testResult.Duration, Is.EqualTo(TimeSpan.FromSeconds(1.234))); }
public void Attachments_AllFilePathesStartWithFileScheme() { const string fileUriScheme = "file://"; const string errorMessage = "Path must start with file:// uri scheme"; var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode().AsString()); var testResults = testConverter.GetVsTestResults(fakeResultNode, Enumerable.Empty <XmlNode>().ToList()); var convertedAttachments = testResults.TestResults .SelectMany(tr => tr.Attachments.SelectMany(ats => ats.Attachments)) .ToArray(); foreach (var attachment in convertedAttachments) { var originalPath = attachment.Uri.OriginalString; Assert.That(originalPath.LastIndexOf(fileUriScheme), Is.EqualTo(0), errorMessage); } }
public void Attachments_CorrectAmountOfConvertedAttachments() { var cachedTestCase = testConverterForXml.ConvertTestCase(fakeTestNode); var fakeResultNode = new NUnitTestEventTestCase(FakeTestData.GetResultNode()); var testResults = testConverterForXml.GetVsTestResults(fakeResultNode, Enumerable.Empty <INUnitTestEventTestOutput>().ToList()); var fakeAttachments = fakeResultNode.NUnitAttachments .Where(n => !string.IsNullOrEmpty(n.FilePath)) .ToArray(); var convertedAttachments = testResults.TestResults .SelectMany(tr => tr.Attachments.SelectMany(ats => ats.Attachments)) .ToArray(); Assert.Multiple(() => { Assert.That(convertedAttachments.Length, Is.GreaterThan(0), "Some converted attachments were expected"); Assert.That(convertedAttachments.Length, Is.EqualTo(fakeAttachments.Length), "Attachments are not converted"); }); }
public void Attachments_CorrectAmountOfConvertedAttachments() { var cachedTestCase = testConverter.ConvertTestCase(fakeTestNode); var fakeResultNode = FakeTestData.GetResultNode(); var testResults = testConverter.GetVSTestResults(fakeResultNode, Enumerable.Empty <XmlNode>().ToList()); var fakeAttachments = fakeResultNode.SelectNodes("attachments/attachment") .OfType <XmlNode>() .Where(n => !string.IsNullOrEmpty(n.SelectSingleNode("filePath")?.InnerText)) .ToArray(); var convertedAttachments = testResults.TestResults .SelectMany(tr => tr.Attachments.SelectMany(ats => ats.Attachments)) .ToArray(); Assert.Multiple(() => { Assert.That(convertedAttachments.Length, Is.GreaterThan(0), "Some converted attachments were expected"); Assert.That(convertedAttachments.Length, Is.EqualTo(fakeAttachments.Length), "Attachments are not converted"); }); }
public void SetUp() { fakeTestNode = FakeTestData.GetTestNode(); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, collectSourceInformation: true); }
public void SetUp() { fakeTestNode = FakeTestData.GetTestNode(); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub(), 0), FakeTestData.AssemblyPath); }