public void Format(IXLWorksheet worksheet, ScenarioOutline scenarioOutline, ref int row)
        {
            int originalRow = row;
            worksheet.Cell(row++, "B").Value = scenarioOutline.Name;
            worksheet.Cell(row++, "C").Value = scenarioOutline.Description;

            var results = this.testResults.GetScenarioOutlineResult(scenarioOutline);
            if (this.configuration.HasTestResults && (results != TestResult.Inconclusive))
            {
                worksheet.Cell(originalRow, "B").Style.Fill.SetBackgroundColor(results == TestResult.Passed
                    ? XLColor.AppleGreen
                    : XLColor.CandyAppleRed);
            }

            foreach (Step step in scenarioOutline.Steps)
            {
                this.excelStepFormatter.Format(worksheet, step, ref row);
            }

            row++;

            foreach (var example in scenarioOutline.Examples)
            {
                worksheet.Cell(row++, "B").Value = "Examples";
                worksheet.Cell(row, "C").Value = example.Description;
                this.excelTableFormatter.Format(worksheet, example.TableArgument, ref row);
            }
        }
        public TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] exampleValues)
        {
            XElement featureElement = this.GetFeatureElement(scenarioOutline.Feature);
            XElement examplesElement = null;
            if (featureElement != null)
            {
                var signatureBuilder = this.ExampleSignatureBuilder;

                if (signatureBuilder == null)
                {
                    throw new InvalidOperationException(
                        "You need to set the ExampleSignatureBuilder before using GetExampleResult.");
                }

                Regex exampleSignature = signatureBuilder.Build(scenarioOutline, exampleValues);

                var parameterizedTestElement = featureElement
                    .Descendants("test-suite")
                    .FirstOrDefault(x => IsMatchingParameterizedTestElement(x, scenarioOutline));

                if (parameterizedTestElement != null)
                {
                    examplesElement = parameterizedTestElement.Descendants("test-case")
                        .FirstOrDefault(x => IsMatchingTestCase(x, exampleSignature));
                }
            }

            return this.GetResultFromElement(examplesElement);
        }
        public void ThenCanFormatCompleteScenarioOutlineCorrectly()
        {
            var table = new Table
            {
                HeaderRow = new TableRow("Var1", "Var2", "Var3", "Var4"),
                DataRows =
                    new List<TableRow>(new[]
                    {
                        new TableRow("1", "2", "3", "4"),
                        new TableRow("5", "6", "7", "8")
                    })
            };

            var example = new Example { Name = "Some examples", Description = "An example", TableArgument = table };
            var examples = new List<Example>();
            examples.Add(example);

            var scenarioOutline = new ScenarioOutline
            {
                Name = "Testing a scenario outline",
                Description = "We need to make sure that scenario outlines work properly",
                Examples = examples
            };

            var htmlScenarioOutlineFormatter = Container.Resolve<HtmlScenarioOutlineFormatter>();
            var output = htmlScenarioOutlineFormatter.Format(scenarioOutline, 0);

            Check.That(output).ContainsGherkinScenario();
            Check.That(output).ContainsGherkinTable();
        }
        public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
        {
            if (this.specRunFeatures == null)
            {
                return TestResult.Inconclusive;
            }

            var specRunFeature = this.FindSpecRunFeature(scenarioOutline.Feature);

            if (specRunFeature == null)
            {
                return TestResult.Inconclusive;
            }

            Parser.SpecRun.Scenario[] specRunScenarios = FindSpecRunScenarios(scenarioOutline, specRunFeature);

            if (specRunScenarios.Length == 0)
            {
                return TestResult.Inconclusive;
            }

            TestResult result = StringsToTestResult(specRunScenarios.Select(srs => srs.Result));

            return result;
        }
        public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
        {
            IEnumerable<assembliesAssemblyCollectionTest> exampleElements = this.GetScenarioOutlineElements(scenarioOutline);
            int passedCount = 0;
            int failedCount = 0;
            int skippedCount = 0;

            foreach (var exampleElement in exampleElements)
            {
                TestResult result = this.GetResultFromElement(exampleElement);
                if (result == TestResult.Inconclusive)
                {
                    skippedCount++;
                }

                if (result == TestResult.Passed)
                {
                    passedCount++;
                }

                if (result == TestResult.Failed)
                {
                    failedCount++;
                }
            }

            return GetAggregateResult(passedCount, failedCount, skippedCount);
        }
        public void Format(Body body, ScenarioOutline scenarioOutline)
        {
            if (this.configuration.HasTestResults)
            {
                TestResult testResult = this.testResults.GetScenarioOutlineResult(scenarioOutline);
                if (testResult == TestResult.Passed)
                {
                    body.GenerateParagraph("Passed", "Passed");
                }
                else if (testResult == TestResult.Failed)
                {
                    body.GenerateParagraph("Failed", "Failed");
                }
            }

            body.GenerateParagraph(scenarioOutline.Name, "Heading2");
            if (!string.IsNullOrEmpty(scenarioOutline.Description))
            {
                body.GenerateParagraph(scenarioOutline.Description, "Normal");
            }

            foreach (Step step in scenarioOutline.Steps)
            {
                this.wordStepFormatter.Format(body, step);
            }

            foreach (var example in scenarioOutline.Examples)
            {
                body.GenerateParagraph("Examples: " + example.Description, "Heading3");
                this.wordTableFormatter.Format(body, example.TableArgument);
            }
        }
        private XElement FormatHeading(ScenarioOutline scenarioOutline)
        {
            if (string.IsNullOrEmpty(scenarioOutline.Name))
            {
                return null;
            }

            var result = new XElement(
                this.xmlns + "div",
                new XAttribute("class", "scenario-heading"),
                string.IsNullOrEmpty(scenarioOutline.Slug) ? null : new XAttribute("id", scenarioOutline.Slug),
                new XElement(this.xmlns + "h2", scenarioOutline.Name));

            var tags = RetrieveTags(scenarioOutline);
            if (tags.Length > 0)
            {
                var paragraph = new XElement(this.xmlns + "p", HtmlScenarioFormatter.CreateTagElements(tags.OrderBy(t => t).ToArray(), this.xmlns));
                paragraph.Add(new XAttribute("class", "tags"));
                result.Add(paragraph);
            }

            result.Add(this.htmlDescriptionFormatter.Format(scenarioOutline.Description));

            return result;
        }
Exemple #8
0
        public XElement Format(Table table, ScenarioOutline scenarioOutline, bool includeResults)
        {
            if (table == null) return null;

            var headerCells = table.HeaderRow.ToArray();

            if (includeResults)
            {
                headerCells = headerCells.Concat(new[] { " " }).ToArray();
            }

            return new XElement(this.xmlns + "div",
                                new XAttribute("class", "table_container"),
                                new XElement(this.xmlns + "table",
                                             new XAttribute("class", "datatable"),
                                             new XElement(this.xmlns + "thead",
                                                          new XElement(this.xmlns + "tr",
                                                                       headerCells.Select(
                                                                           cell => new XElement(this.xmlns + "th", cell))
                                                              )
                                                 ),
                                             new XElement(this.xmlns + "tbody",
                                                          table.DataRows.Select(row => this.FormatRow(row, scenarioOutline, includeResults))
                                                 )
                                    ));
        }
        public bool IsMatch(ScenarioOutline scenarioOutline, string[] exampleValues, object scenarioElement)
        {
            var element = (XElement)scenarioElement;

            var valuesInScenario = element.DetermineValuesInScenario();

            var isMatch = exampleValues.OrderBy(e => e).SequenceEqual(valuesInScenario.OrderBy(v => v));
            return isMatch;
        }
        public override TestResult GetExampleResult(ScenarioOutline scenario, string[] exampleValues)
        {
            var cucumberScenarios = this.GetCucumberScenarios(scenario);

            var query = cucumberScenarios.Where(cs => this.ScenarioHasStepsForAllExampleValues(cs.ScenarioBase, exampleValues))
                .Select(cs => ToTestResult(cs.ScenarioBase, cs.Background));

            return query.FirstOrDefault();
        }
        public Regex Build(ScenarioOutline scenarioOutline, string[] row)
        {
            var stringBuilder = new StringBuilder();
            stringBuilder.Append(Regex.Escape(scenarioOutline.Name));
            stringBuilder.Append("(, Examples (\\d*))?");
            stringBuilder.Append(", " + Regex.Escape(row[0]));

            return new Regex(stringBuilder.ToString());
        }
        public void ThenCanSuccessfullyMatch()
        {
            var scenarioOutline = new ScenarioOutline {Name = "Adding several numbers"};
            var exampleRow = new[] {"40", "50", "90"};

            var signatureBuilder = Container.Resolve<xUnitExampleSignatureBuilder>();
            Regex signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            signature.IsMatch("Pickles.TestHarness.xUnit.AdditionFeature.AddingSeveralNumbers(firstNumber: \"40\", secondNumber: \"50\", result: \"90\", exampleTags: System.String[])".ToLowerInvariant()).ShouldBeTrue();
        }
        public void Map_NoSteps_ReturnsEmtpyListOfSteps()
        {
            var scenarioOutline = new ScenarioOutline { Steps = null };

            var mapper = CreateMapper();

            JsonScenarioOutline actual = mapper.Map(scenarioOutline);

            Check.That(actual.Steps.Count).IsEqualTo(0);
        }
        public void Map_NoExamples_ReturnsEmptyListOfExamples()
        {
            var scenarioOutline = new ScenarioOutline { Examples = null };

            var mapper = CreateMapper();

            JsonScenarioOutline actual = mapper.Map(scenarioOutline);

            Check.That(actual.Examples.Count).IsEqualTo(0);
        }
        public void Map_SomeScenarioOutline_ReturnsSomeJsonScenarioOutline()
        {
            var scenarioOutline = new ScenarioOutline();

            var mapper = CreateMapper();

            JsonScenarioOutline actual = mapper.Map(scenarioOutline);

            Check.That(actual).IsNotNull();
        }
        public XElement Format(ScenarioOutline scenarioOutline)
        {
            if (this.configuration.HasTestResults)
            {
                TestResult scenarioResult = this.results.GetScenarioOutlineResult(scenarioOutline);

                return this.BuildImageElement(scenarioResult);
            }

            return null;
        }
        private XElement FormatSteps(ScenarioOutline scenarioOutline)
        {
            if (scenarioOutline.Steps == null) return null;

            return new XElement(this.xmlns + "div",
                                new XAttribute("class", "steps"),
                                new XElement(this.xmlns + "ul",
                                             scenarioOutline.Steps.Select(
                                                 step => this.htmlStepFormatter.Format(step)))
                );
        }
        public void ThenCanSuccessfullyMatchSpecialCharacters()
        {
            var scenarioOutline = new ScenarioOutline { Name = "Adding several numbers (foo-bar, foo bar)" };
            var exampleRow = new[] { "40", "50", "90" };

            var signatureBuilder = new NUnit3ExampleSignatureBuilder();
            Regex signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            var isMatch = signature.IsMatch("AddingSeveralNumbersFoo_BarFooBar(\"40\",\"50\",\"90\",System.String[])".ToLowerInvariant());
            Check.That(isMatch).IsTrue();
        }
        public void ThenCanSuccessfullyMatch()
        {
            var scenarioOutline = new ScenarioOutline { Name = "Adding several numbers" };
            var exampleRow = new[] { "40", "50", "90" };

            var signatureBuilder = Container.Resolve<NUnitExampleSignatureBuilder>();
            Regex signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            var isMatch = signature.IsMatch("Pickles.TestHarness.AdditionFeature.AddingSeveralNumbers(\"40\",\"50\",\"90\",System.String[])".ToLowerInvariant());
            Check.That(isMatch).IsTrue();
        }
        public override TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] exampleValues)
        {
            IEnumerable<XElement> exampleElements = this.GetScenarioOutlineElements(scenarioOutline);

            foreach (XElement exampleElement in exampleElements)
            {
                if (this.ScenarioOutlineExampleMatcher.IsMatch(scenarioOutline, exampleValues, exampleElement))
                {
                    return this.GetResultFromElement(exampleElement);
                }
            }

            return TestResult.Inconclusive;
        }
        public Regex Build(ScenarioOutline scenarioOutline, string[] row)
        {
            var stringBuilder = new StringBuilder();
            stringBuilder.Append(scenarioOutline.Name.ToLowerInvariant().Replace(" ", string.Empty) + "\\(");

            foreach (string value in row)
            {
                stringBuilder.AppendFormat("\"{0}\",", value.ToLowerInvariant().Replace(@"\", string.Empty).Replace(@"$", @"\$"));
            }

            stringBuilder.Remove(stringBuilder.Length - 1, 1);

            return new Regex(stringBuilder.ToString());
        }
        public Regex Build(ScenarioOutline scenarioOutline, string[] row)
        {
            var stringBuilder = new StringBuilder();

            var name = SpecFlowNameMapping.Build(scenarioOutline.Name.ToLowerInvariant());
            stringBuilder.Append(name).Append("\\(");

            foreach (var value in row.Select(v => v.Length > MaxExampleValueLength ? new { Value = v.Substring(0, MaxExampleValueLength), Ellipsis = "..." } : new { Value = v, Ellipsis = "" }))
                stringBuilder.AppendFormat("(.*): \"{0}\"{1}, ", Regex.Escape(value.Value.ToLowerInvariant()), value.Ellipsis);

            stringBuilder.Remove(stringBuilder.Length - 2, 2);

            return new Regex(stringBuilder.ToString());
        }
        protected override XElement GetScenarioOutlineElement(ScenarioOutline scenarioOutline)
        {
            XElement featureElement = this.GetFeatureElement(scenarioOutline.Feature);
            XElement scenarioOutlineElement = null;
            if (featureElement != null)
            {
                scenarioOutlineElement =
                    this.GetFeatureElement(scenarioOutline.Feature)
                        .Descendants("test-suite")
                        .Where(x => x.Attribute("description") != null)
                        .FirstOrDefault(x => x.Attribute("description").Value == scenarioOutline.Name);
            }

            return scenarioOutlineElement;
        }
        public void ThenCanSuccessfullyMatchExamplesWithLongValues()
        {
            var scenarioOutline = new ScenarioOutline { Name = "Deal correctly with overlong example values" };
            var exampleRow = new[]
            {
                "Please enter a valid two letter country code (e.g. DE)!",
                "This is just a very very very veery long error message!"
            };

            var signatureBuilder = new XUnitExampleSignatureBuilder();
            var signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            var isMatch = signature.IsMatch("Pickles.TestHarness.xunit2.ScenarioOutlinesFeature.DealCorrectlyWithOverlongExampleValues(value1: \"Please enter a valid two letter country code (e.g.\"..., value2: \"This is just a very very very veery long error mes\"..., exampleTags: [])".ToLowerInvariant());
            Check.That(isMatch).IsTrue();
        }
        public void ThenCanSuccessfullyMatchExamplesWithLongValues()
        {
            var scenarioOutline = new ScenarioOutline { Name = "Deal correctly with overlong example values" };
            var exampleRow = new[]
            {
                "Please enter a valid two letter country code (e.g. DE)!",
                "This is just a very very very veery long error message!"
            };

            var signatureBuilder = new NUnit3ExampleSignatureBuilder();
            var signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            var isMatch = signature.IsMatch("DealCorrectlyWithOverlongExampleValues(\"Please enter a valid two letter count...\",\"This is just a very very very veery l...\",null)".ToLowerInvariant());
            Check.That(isMatch).IsTrue();
        }
        public Regex Build(ScenarioOutline scenarioOutline, string[] row)
        {
            var stringBuilder = new StringBuilder();

            var name = SpecFlowNameMapping.Build(scenarioOutline.Name.ToLowerInvariant());
            stringBuilder.Append(name).Append("\\(");

            foreach (var value in row)
            {
                stringBuilder.AppendFormat("\"{0}\",", Regex.Escape(value.ToLowerInvariant()));
            }

            stringBuilder.Remove(stringBuilder.Length - 1, 1);

            return new Regex(stringBuilder.ToString());
        }
        private static bool MatchRegexSpecialChars(string expectedParameter)
        {
            var scenarioOutline = new ScenarioOutline { Name = "This scenario contains examples with Regex-special characters" };
            var exampleRow = new[] { expectedParameter };

            var signatureBuilder = new XUnitExampleSignatureBuilder();
            var signature = signatureBuilder.Build(scenarioOutline, exampleRow);

            var matchEntry = string
                .Format(
                    "Pickles.TestHarness.xunit2.ScenariosWithSpecialCharactersFeature.ThisScenarioContainsExamplesWithRegex_SpecialCharacters(regex: \"{0}\", exampleTags: System.String[])",
                    expectedParameter)
                .ToLowerInvariant();

            return signature.IsMatch(matchEntry);
        }
   private XElement FormatExamples(ScenarioOutline scenarioOutline)
   {
 var exampleDiv = new XElement(this.xmlns + "div");
 
 foreach (var example in scenarioOutline.Examples)
 {
         exampleDiv.Add(new XElement(this.xmlns + "div",
                             new XAttribute("class", "examples"),
                             new XElement(this.xmlns + "h3", "Examples: " + example.Name),
                             this.htmlDescriptionFormatter.Format(example.Description),
                             (example.TableArgument == null) ? null : this.htmlTableFormatter.Format(example.TableArgument, scenarioOutline, testResults.SupportsExampleResults)
             ));
 }
 
 return exampleDiv;
   }
Exemple #29
0
        public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
        {
            IEnumerable<XElement> exampleElements = this.GetScenarioOutlineElements(scenarioOutline);
            int passedCount = 0;
            int failedCount = 0;
            int skippedCount = 0;

            foreach (XElement exampleElement in exampleElements)
            {
                TestResult result = this.GetResultFromElement(exampleElement);
                if (result.WasExecuted == false) skippedCount++;
                if (result.WasExecuted && result.WasSuccessful) passedCount++;
                if (result.WasExecuted && !result.WasSuccessful) failedCount++;
            }

            return GetAggregateResult(passedCount, failedCount, skippedCount);
        }
        public void ThenSingleScenarioOutlineWithStepsAddedSuccessfully()
        {
            var excelScenarioFormatter = Container.Resolve<ExcelScenarioOutlineFormatter>();
            var exampleTable = new Table();
            exampleTable.HeaderRow = new TableRow("Var1", "Var2", "Var3", "Var4");
            exampleTable.DataRows =
                new List<TableRow>(new[] {new TableRow("1", "2", "3", "4"), new TableRow("5", "6", "7", "8")});
            var example = new Example {Name = "Examples", Description = string.Empty, TableArgument = exampleTable};
      var examples = new List<Example>();
      examples.Add(example);
            var scenarioOutline = new ScenarioOutline
                                      {
                                          Name = "Test Feature",
                                          Description =
                                              "In order to test this feature,\nAs a developer\nI want to test this feature",
                                          Examples = examples
                                      };
            var given = new Step {NativeKeyword = "Given", Name = "a precondition"};
            var when = new Step {NativeKeyword = "When", Name = "an event occurs"};
            var then = new Step {NativeKeyword = "Then", Name = "a postcondition"};
            scenarioOutline.Steps = new List<Step>(new[] {given, when, then});

            using (var workbook = new XLWorkbook())
            {
                IXLWorksheet worksheet = workbook.AddWorksheet("SHEET1");
                int row = 3;
                excelScenarioFormatter.Format(worksheet, scenarioOutline, ref row);

                Check.That(worksheet.Cell("B3").Value).IsEqualTo(scenarioOutline.Name);
                Check.That(worksheet.Cell("C4").Value).IsEqualTo(scenarioOutline.Description);
                Check.That(worksheet.Cell("B9").Value).IsEqualTo("Examples");
                Check.That(worksheet.Cell("D10").Value).IsEqualTo("Var1");
                Check.That(worksheet.Cell("E10").Value).IsEqualTo("Var2");
                Check.That(worksheet.Cell("F10").Value).IsEqualTo("Var3");
                Check.That(worksheet.Cell("G10").Value).IsEqualTo("Var4");
                Check.That(worksheet.Cell("D11").Value).IsEqualTo(1.0);
                Check.That(worksheet.Cell("E11").Value).IsEqualTo(2.0);
                Check.That(worksheet.Cell("F11").Value).IsEqualTo(3.0);
                Check.That(worksheet.Cell("G11").Value).IsEqualTo(4.0);
                Check.That(worksheet.Cell("D12").Value).IsEqualTo(5.0);
                Check.That(worksheet.Cell("E12").Value).IsEqualTo(6.0);
                Check.That(worksheet.Cell("F12").Value).IsEqualTo(7.0);
                Check.That(worksheet.Cell("G12").Value).IsEqualTo(8.0);
                Check.That(row).IsEqualTo(13);
            }
        }