Merge pull request #264 from dirkrombauts/nUnit3

Support for nUnit 3
Resolves #224

README.md

@@ -36,7 +36,7 @@ If there are other formats you would like to see feel free to create a [GitHub I
 Supported Test Runner Integrations
 ----------------------------------
 
-- NUnit
+- NUnit (versions 2.x and 3.x)
 - xUnit (versions 1.x and 2.x)
 - MSTest
 - Cucumber JSON

src/Pickles/Pickles.ObjectModel/TestResultsFormat.cs

@@ -55,6 +55,11 @@ public enum TestResultsFormat
         /// <summary>
         /// xUnit 2 format.
         /// </summary>
-        xUnit2
+        xUnit2,
+
+        /// <summary>
+        /// NUnit 3 format.
+        /// </summary>
+        NUnit3
     }
 }

src/Pickles/Pickles.TestFrameworks.UnitTests/NUnit3/WhenDeterminingTheSignatureOfAnNunit3ExampleRow.cs

@@ -0,0 +1,52 @@
+//  --------------------------------------------------------------------------------------------------------------------
+//  <copyright file="WhenDeterminingTheSignatureOfAnNunit3ExampleRow.cs" company="PicklesDoc">
+//  Copyright 2011 Jeffrey Cameron
+//  Copyright 2012-present PicklesDoc team and community contributors
+//
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  </copyright>
+//  --------------------------------------------------------------------------------------------------------------------
+
+using System;
+using System.Text.RegularExpressions;
+
+using Autofac;
+
+using NFluent;
+
+using NUnit.Framework;
+
+using PicklesDoc.Pickles.ObjectModel;
+using PicklesDoc.Pickles.Test;
+using PicklesDoc.Pickles.TestFrameworks.NUnit3;
+
+namespace PicklesDoc.Pickles.TestFrameworks.UnitTests.Nunit3
+{
+    [TestFixture]
+    public class WhenDeterminingTheSignatureOfAnNunit3ExampleRow : BaseFixture
+    {
+        [Test]
+        public void ThenCanSuccessfullyMatch()
+        {
+            var scenarioOutline = new ScenarioOutline { Name = "Adding several numbers" };
+            var exampleRow = new[] { "40", "50", "90" };
+
+            var signatureBuilder = Container.Resolve<NUnit3ExampleSignatureBuilder>();
+            Regex signature = signatureBuilder.Build(scenarioOutline, exampleRow);
+
+            var isMatch = signature.IsMatch("AddingSeveralNumbers(\"40\",\"50\",\"90\",System.String[])".ToLowerInvariant());
+            Check.That(isMatch).IsTrue();
+        }
+    }
+}

src/Pickles/Pickles.TestFrameworks.UnitTests/NUnit3/WhenParsingNunit3ResultsFile.cs

@@ -0,0 +1,253 @@
+//  --------------------------------------------------------------------------------------------------------------------
+//  <copyright file="WhenParsingNunit3ResultsFile.cs" company="PicklesDoc">
+//  Copyright 2011 Jeffrey Cameron
+//  Copyright 2012-present PicklesDoc team and community contributors
+//
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  </copyright>
+//  --------------------------------------------------------------------------------------------------------------------
+
+using System;
+
+using NFluent;
+
+using NUnit.Framework;
+
+using PicklesDoc.Pickles.ObjectModel;
+using PicklesDoc.Pickles.TestFrameworks.NUnit3;
+
+namespace PicklesDoc.Pickles.TestFrameworks.UnitTests.Nunit3
+{
+    [TestFixture]
+    public class WhenParsingNunit3ResultsFile : WhenParsingTestResultFiles<NUnit3Results>
+    {
+        public WhenParsingNunit3ResultsFile()
+            : base("NUnit3." + "results-example-nunit3.xml")
+        {
+        }
+
+        [Test]
+        public void ThenCanReadFeatureResultSuccessfully()
+        {
+            // Write out the embedded test results file
+            var results = ParseResultsFile();
+
+            var feature = new Feature { Name = "Addition" };
+            TestResult result = results.GetFeatureResult(feature);
+
+            Check.That(result).IsEqualTo(TestResult.Failed);
+        }
+
+        [Test]
+        public void ThenCanReadScenarioOutlineResultSuccessfully()
+        {
+            var results = ParseResultsFile();
+
+            var feature = new Feature { Name = "Addition" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "Adding several numbers", Feature = feature };
+            TestResult result = results.GetScenarioOutlineResult(scenarioOutline);
+
+            Check.That(result).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { "40", "50", "90" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] { "60", "70", "130" });
+            Check.That(exampleResult2).IsEqualTo(TestResult.Passed);
+        }
+
+        [Test]
+        public void ThenCanReadSuccessfulScenarioResultSuccessfully()
+        {
+            var results = ParseResultsFile();
+
+            var feature = new Feature { Name = "Addition" };
+
+            var passedScenario = new Scenario { Name = "Add two numbers", Feature = feature };
+            TestResult result = results.GetScenarioResult(passedScenario);
+
+            Check.That(result).IsEqualTo(TestResult.Passed);
+        }
+
+        [Test]
+        public void ThenCanReadFailedScenarioResultSuccessfully()
+        {
+            var results = ParseResultsFile();
+            var feature = new Feature { Name = "Addition" };
+            var scenario = new Scenario { Name = "Fail to add two numbers", Feature = feature };
+            TestResult result = results.GetScenarioResult(scenario);
+
+            Check.That(result).IsEqualTo(TestResult.Failed);
+        }
+
+        [Test]
+        public void ThenCanReadIgnoredScenarioResultSuccessfully()
+        {
+            var results = ParseResultsFile();
+            var feature = new Feature { Name = "Addition" };
+            var ignoredScenario = new Scenario { Name = "Ignored adding two numbers", Feature = feature };
+            var result = results.GetScenarioResult(ignoredScenario);
+
+            Check.That(result).IsEqualTo(TestResult.Inconclusive);
+        }
+
+        [Test]
+        public void ThenCanReadNotFoundScenarioCorrectly()
+        {
+            var results = ParseResultsFile();
+            var feature = new Feature { Name = "Addition" };
+            var notFoundScenario = new Scenario
+            {
+                Name = "Not in the file at all!",
+                Feature = feature
+            };
+
+            var result = results.GetScenarioResult(notFoundScenario);
+
+            Check.That(result).IsEqualTo(TestResult.Inconclusive);
+        }
+
+        [Test]
+        public void WithoutExampleSignatureBuilderThrowsInvalidOperationException()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(null);
+
+            var feature = new Feature { Name = "Addition" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "Adding several numbers", Feature = feature };
+
+            Check.ThatCode(() => results.GetExampleResult(scenarioOutline, new[] { "40", "50", "90" })).Throws<InvalidOperationException>();
+        }
+
+        [Test]
+        public void ThenCanReadIndividualResultsFromScenarioOutline_AllPass_ShouldBeTestResultPassed()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(new NUnit3ExampleSignatureBuilder());
+
+            var feature = new Feature { Name = "Scenario Outlines" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "This is a scenario outline where all scenarios pass", Feature = feature };
+
+            TestResult exampleResultOutline = results.GetScenarioOutlineResult(scenarioOutline);
+            Check.That(exampleResultOutline).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { "pass_1" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] { "pass_2" });
+            Check.That(exampleResult2).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult3 = results.GetExampleResult(scenarioOutline, new[] { "pass_3" });
+            Check.That(exampleResult3).IsEqualTo(TestResult.Passed);
+        }
+
+        [Test]
+        public void ThenCanReadIndividualResultsFromScenarioOutline_OneInconclusive_ShouldBeTestResultInconclusive()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(new NUnit3ExampleSignatureBuilder());
+
+            var feature = new Feature { Name = "Scenario Outlines" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "This is a scenario outline where one scenario is inconclusive", Feature = feature };
+
+            TestResult exampleResultOutline = results.GetScenarioOutlineResult(scenarioOutline);
+            Check.That(exampleResultOutline).IsEqualTo(TestResult.Inconclusive);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { "pass_1" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] { "pass_2" });
+            Check.That(exampleResult2).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult3 = results.GetExampleResult(scenarioOutline, new[] { "inconclusive_1" });
+            Check.That(exampleResult3).IsEqualTo(TestResult.Inconclusive);
+        }
+
+        [Test]
+        public void ThenCanReadIndividualResultsFromScenarioOutline_OneFailed_ShouldBeTestResultFailed()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(new NUnit3ExampleSignatureBuilder());
+
+            var feature = new Feature { Name = "Scenario Outlines" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "This is a scenario outline where one scenario fails", Feature = feature };
+
+            TestResult exampleResultOutline = results.GetScenarioOutlineResult(scenarioOutline);
+            Check.That(exampleResultOutline).IsEqualTo(TestResult.Failed);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { "pass_1" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] { "pass_2" });
+            Check.That(exampleResult2).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult3 = results.GetExampleResult(scenarioOutline, new[] { "fail_1" });
+            Check.That(exampleResult3).IsEqualTo(TestResult.Failed);
+        }
+
+        [Test]
+        public void ThenCanReadIndividualResultsFromScenarioOutline_MultipleExampleSections_ShouldBeTestResultFailed()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(new NUnit3ExampleSignatureBuilder());
+
+            var feature = new Feature { Name = "Scenario Outlines" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "And we can go totally bonkers with multiple example sections.", Feature = feature };
+
+            TestResult exampleResultOutline = results.GetScenarioOutlineResult(scenarioOutline);
+            Check.That(exampleResultOutline).IsEqualTo(TestResult.Failed);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { "pass_1" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] { "pass_2" });
+            Check.That(exampleResult2).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult3 = results.GetExampleResult(scenarioOutline, new[] { "inconclusive_1" });
+            Check.That(exampleResult3).IsEqualTo(TestResult.Inconclusive);
+
+            TestResult exampleResult4 = results.GetExampleResult(scenarioOutline, new[] { "inconclusive_2" });
+            Check.That(exampleResult4).IsEqualTo(TestResult.Inconclusive);
+
+            TestResult exampleResult5 = results.GetExampleResult(scenarioOutline, new[] { "fail_1" });
+            Check.That(exampleResult5).IsEqualTo(TestResult.Failed);
+
+            TestResult exampleResult6 = results.GetExampleResult(scenarioOutline, new[] { "fail_2" });
+            Check.That(exampleResult6).IsEqualTo(TestResult.Failed);
+        }
+
+        [Test]
+        public void ThenCanReadResultsWithBackslashes()
+        {
+            var results = ParseResultsFile();
+            results.SetExampleSignatureBuilder(new NUnit3ExampleSignatureBuilder());
+
+            var feature = new Feature { Name = "Scenario Outlines" };
+
+            var scenarioOutline = new ScenarioOutline { Name = "Deal correctly with backslashes in the examples", Feature = feature };
+
+            TestResult exampleResultOutline = results.GetScenarioOutlineResult(scenarioOutline);
+            Check.That(exampleResultOutline).IsEqualTo(TestResult.Passed);
+
+            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] { @"c:\Temp\" });
+            Check.That(exampleResult1).IsEqualTo(TestResult.Passed);
+        }
+    }
+}