Exemple #1
0
        public FeatureFile(string fileName, Folder folder, Feature feature, IFileSystem fileSystem)
            : base(fileName, folder, fileSystem)
        {
            if (feature == null) throw new ArgumentNullException("feature");

            this.mContent = feature;
        }
        public void Format(IXLWorksheet worksheet, Feature feature)
        {
            worksheet.Cell("A1").Style.Font.SetBold();
            worksheet.Cell("A1").Value = feature.Name;
            worksheet.Cell("B2").Value = feature.Description;
            worksheet.Cell("B2").Style.Alignment.WrapText = false;

            var results = this.testResults.GetFeatureResult(feature);

            if (this.configuration.HasTestResults && results.WasExecuted)
            {
                worksheet.Cell("A1").Style.Fill.SetBackgroundColor(results.WasSuccessful
                                                                       ? XLColor.AppleGreen
                                                                       : XLColor.CandyAppleRed);
            }

            int row = 4;
            foreach (IFeatureElement featureElement in feature.FeatureElements)
            {
                var scenario = featureElement as Scenario;
                if (scenario != null)
                {
                    this.excelScenarioFormatter.Format(worksheet, scenario, ref row);
                }

                var scenarioOutline = featureElement as ScenarioOutline;
                if (scenarioOutline != null)
                {
                    this.excelScenarioOutlineFormatter.Format(worksheet, scenarioOutline, ref row);
                }

                row++;
            }
        }
Exemple #3
0
 public FeatureNode(FileSystemInfoBase location, string relativePathFromRoot, Feature feature)
 {
     this.OriginalLocation = location;
     this.OriginalLocationUrl = location.ToUri();
     this.RelativePathFromRoot = relativePathFromRoot;
     this.Feature = feature;
 }
        public void ThenCanReadScenarioOutlineResultSuccessfully()
        {
            // Write out the embedded test results file
          using (var input = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("PicklesDoc.Pickles.Test." + RESULTS_FILE_NAME)))
            using (var output = new StreamWriter(RESULTS_FILE_NAME))
            {
                output.Write(input.ReadToEnd());
            }

            var configuration = Container.Resolve<Configuration>();
            configuration.TestResultsFile = new FileInfo(RESULTS_FILE_NAME);

            var results = Container.Resolve<NUnitResults>();

            var feature = new Feature {Name = "Addition"};

            var scenarioOutline = new ScenarioOutline {Name = "Adding several numbers", Feature = feature};
            TestResult result = results.GetScenarioOutlineResult(scenarioOutline);

            result.WasExecuted.ShouldBeTrue();
            result.WasSuccessful.ShouldBeTrue();

            TestResult exampleResult1 = results.GetExampleResult(scenarioOutline, new[] {"40", "50", "90"});
            exampleResult1.WasExecuted.ShouldBeTrue();
            exampleResult1.WasSuccessful.ShouldBeTrue();

            TestResult exampleResult2 = results.GetExampleResult(scenarioOutline, new[] {"60", "70", "130"});
            exampleResult2.WasExecuted.ShouldBeTrue();
            exampleResult2.WasSuccessful.ShouldBeTrue();
        }
        public void ThenCanReadScenarioResultSuccessfully()
        {
            // Write out the embedded test results file
          using (var input = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("PicklesDoc.Pickles.Test." + RESULTS_FILE_NAME)))
            using (var output = new StreamWriter(RESULTS_FILE_NAME))
            {
                output.Write(input.ReadToEnd());
            }

            var configuration = Container.Resolve<Configuration>();
            configuration.TestResultsFile = new FileInfo(RESULTS_FILE_NAME);

            var results = Container.Resolve<NUnitResults>();

            var feature = new Feature {Name = "Addition"};

            var scenario1 = new Scenario {Name = "Add two numbers", Feature = feature};
            TestResult result1 = results.GetScenarioResult(scenario1);

            result1.WasExecuted.ShouldBeTrue();
            result1.WasSuccessful.ShouldBeTrue();

            var scenario2 = new Scenario {Name = "Fail to add two numbers", Feature = feature};
            TestResult result2 = results.GetScenarioResult(scenario2);

            result2.WasExecuted.ShouldBeTrue();
            result2.WasSuccessful.ShouldBeFalse();
        }
        public void Constructor_WithFeature_SetsContentProperty()
        {
            var feature = new Feature();

            var featureFile = new FeatureFile("filename.ext", parentFolder, feature);

            featureFile.Content.ShouldEqual(feature);
        }
        public void Setup()
        {
            this._testFeature = new Feature { Name = "Test" };
            this._featureFileInfo = this.FileSystem.FileInfo.FromFileName(FileSystem.Path.Combine(ROOT_PATH, FEATURE_PATH));
            this._featureDirectoryNode = new FeatureNode(this._featureFileInfo, RELATIVE_PATH, this._testFeature);

            this._featureWithMeta = new FeatureWithMetaInfo(this._featureDirectoryNode);
        }
Exemple #8
0
        public TestResult GetFeatureResult(Feature feature)
        {
            var featureElement = this.GetFeatureElement(feature);

            var results = featureElement.Descendants("test-case")
                .Select(GetResultFromElement);

            return results.Merge();
        }
Exemple #9
0
        public TestResult GetFeatureResult(Feature feature)
        {
            XElement featureElement = this.GetFeatureElement(feature);
            int passedCount = int.Parse(featureElement.Attribute("passed").Value);
            int failedCount = int.Parse(featureElement.Attribute("failed").Value);
            int skippedCount = int.Parse(featureElement.Attribute("skipped").Value);

            return GetAggregateResult(passedCount, failedCount, skippedCount);
        }
Exemple #10
0
 public void feature(string keyword, string name, string description, int line)
 {
     this.isInExample = false;
     this.isFeatureFound = true;
     this.theFeature = new Feature();
     this.theFeature.Name = name;
     this.theFeature.Description = description;
     this.theFeature.Tags = new List<string>(this.featureTags);
     this.featureTags.Clear();
 }
        public void ThenCanFormatDescriptionAsMarkdown()
        {
            var configuration = Container.Resolve<Configuration>();
              configuration.TestResultsFiles = null;

              var feature = new Feature
              {
            Name = "A feature",
            Description =
            @"In order to see the description as nice HTML
            As a Pickles user
            I want to see the descriptions written in markdown rendered as HTML

            Introduction
            ============

            This feature should have some markdown elements that get displayed properly

            Context
            -------

            > I really like blockquotes to describe
            > to describe text

            I also enjoy using lists as well, here are the reasons

            - Lists are easy to read
            - Lists make my life easier

            I also enjoy ordering things

            1. This is the first reason
            2. This is the second reason"
              };

              var htmlFeatureFormatter = Container.Resolve<HtmlFeatureFormatter>();
              XElement featureElement = htmlFeatureFormatter.Format(feature);
              XElement description = featureElement.Elements().FirstOrDefault(element => element.Name.LocalName == "div");

              Assert.NotNull(description);
              description.ShouldBeNamed("div");
              description.ShouldBeInInNamespace("http://www.w3.org/1999/xhtml");
              description.ShouldHaveAttribute("class", "description");
              Assert.AreEqual(9, description.Elements().Count());

              description.Elements().ElementAt(0).ShouldBeNamed("p");
              description.Elements().ElementAt(1).ShouldBeNamed("h1");
              description.Elements().ElementAt(2).ShouldBeNamed("p");
              description.Elements().ElementAt(3).ShouldBeNamed("h2");
              description.Elements().ElementAt(4).ShouldBeNamed("blockquote");
              description.Elements().ElementAt(5).ShouldBeNamed("p");
              description.Elements().ElementAt(6).ShouldBeNamed("ul");
              description.Elements().ElementAt(7).ShouldBeNamed("p");
              description.Elements().ElementAt(8).ShouldBeNamed("ol");
        }
        public void ThenCanShortenLongNameSuccessfully()
        {
            var excelSheetNameGenerator = Container.Resolve<ExcelSheetNameGenerator>();
            var feature = new Feature {Name = "This is a really really long feature name that needs to be shortened"};

            string name;
            using (var wb = new XLWorkbook())
            {
                name = excelSheetNameGenerator.GenerateSheetName(wb, feature);
            }

            name.ShouldEqual("THISISAREALLYREALLYLONGFEATUREN");
        }
        public void GetFeatureResult_OnePassingOneFailed_ReturnsPassed()
        {
            var feature = new Feature();

              var testResults1 = SetupStubForGetFeatureResult(feature, TestResult.Passed);
              var testResults2 = SetupStubForGetFeatureResult(feature, TestResult.Failed);

              ITestResults multipleTestResults = CreateMultipleTestResults(testResults1.Object, testResults2.Object);

              var result = multipleTestResults.GetFeatureResult(feature);

              result.ShouldEqual(TestResult.Failed);
        }
        public void GetFeatureResult_TwoInconclusive_ReturnsInconclusive()
        {
            var feature = new Feature();

              var testResults1 = SetupStubForGetFeatureResult(feature, TestResult.Inconclusive);
              var testResults2 = SetupStubForGetFeatureResult(feature, TestResult.Inconclusive);

              ITestResults multipleTestResults = CreateMultipleTestResults(testResults1.Object, testResults2.Object);

              var result = multipleTestResults.GetFeatureResult(feature);

              result.ShouldEqual(TestResult.Inconclusive);
        }
        public void ThenCanCreateSimpleNameSuccessfully()
        {
            var excelSheetNameGenerator = Container.Resolve<ExcelSheetNameGenerator>();
            var feature = new Feature {Name = "A short feature name"};

            string name;
            using (var wb = new XLWorkbook())
            {
                name = excelSheetNameGenerator.GenerateSheetName(wb, feature);
            }

            name.ShouldEqual("ASHORTFEATURENAME");
        }
        public TestResult GetFeatureResult(Feature feature)
        {
            var featureElement = this.GetFeatureElement(feature);

              if (featureElement == null)
              {
            return TestResult.Inconclusive;
              }
              var results = featureElement.Descendants("test-case")
            .Select(GetResultFromElement);

              return results.Merge();
        }
Exemple #17
0
        public TestResult GetFeatureResult(Feature feature)
        {
            var featureExecutionIds =
                from scenario in AllScenariosInResultFile()
                let properties = PropertiesOf(scenario)
                where properties != null
                where FeatureNamePropertyExistsWith(feature.Name, among: properties)
                select ScenarioExecutionIdOf(scenario);

            TestResult result = featureExecutionIds.Select(this.GetExecutionResult).Merge();

            return result;
        }
        public void ThenCanShortenLongDuplicatedNameSuccessfully()
        {
            var excelSheetNameGenerator = Container.Resolve<ExcelSheetNameGenerator>();
            var feature1 = new Feature {Name = "This is a really really long feature name that needs to be shortened A"};
            var feature2 = new Feature {Name = "This is a really really long feature name that needs to be shortened B"};

            string name1;
            string name2;
            using (var wb = new XLWorkbook())
            {
                name1 = excelSheetNameGenerator.GenerateSheetName(wb, feature1);
                wb.AddWorksheet(name1);
                name2 = excelSheetNameGenerator.GenerateSheetName(wb, feature2);
            }

            name2.ShouldEqual("THISISAREALLYREALLYLONGFEATU(1)");
        }
        public XElement Format(Feature feature)
        {
            var div = new XElement(this.xmlns + "div",
                                   new XAttribute("id", "feature"),
                                   this.htmlImageResultFormatter.Format(feature),
                                   new XElement(this.xmlns + "h1", feature.Name));

            var tags = RetrieveTags(feature);
            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"));
              div.Add(paragraph);
            }

            div.Add(this.htmlDescriptionFormatter.Format(feature.Description));


            var scenarios = new XElement(this.xmlns + "ul", new XAttribute("id", "scenarios"));
            int id = 0;

            if (feature.Background != null)
            {
                scenarios.Add(this.htmlScenarioFormatter.Format(feature.Background, id++));
            }

            foreach (IFeatureElement featureElement in feature.FeatureElements)
            {
                var scenario = featureElement as Scenario;
                if (scenario != null)
                {
                    scenarios.Add(this.htmlScenarioFormatter.Format(scenario, id++));
                }

                var scenarioOutline = featureElement as ScenarioOutline;
                if (scenarioOutline != null)
                {
                    scenarios.Add(this.htmlScenarioOutlineFormatter.Format(scenarioOutline, id++));
                }
            }

            div.Add(scenarios);

            return div;
        }
        public void Format(IXLWorksheet worksheet, Feature feature)
        {
            worksheet.Cell("A1").Style.Font.SetBold();
              worksheet.Cell("A1").Value = feature.Name;

              if (feature.Description.Length <= short.MaxValue)
              {
            worksheet.Cell("B2").Value = feature.Description;
              }
              else
              {
            var description = feature.Description.Substring(0, short.MaxValue);
            log.Warn("The description of feature {0} was truncated because of cell size limitations in Excel.", feature.Name);
            worksheet.Cell("B2").Value = description;
              }

              worksheet.Cell("B2").Style.Alignment.WrapText = false;

              var results = this.testResults.GetFeatureResult(feature);

              if (this.configuration.HasTestResults && results.WasExecuted)
              {
            worksheet.Cell("A1").Style.Fill.SetBackgroundColor(results.WasSuccessful
                                                               ? XLColor.AppleGreen
                                                               : XLColor.CandyAppleRed);
              }

              int row = 4;
              foreach (IFeatureElement featureElement in feature.FeatureElements)
              {
            var scenario = featureElement as Scenario;
            if (scenario != null)
            {
              this.excelScenarioFormatter.Format(worksheet, scenario, ref row);
            }

            var scenarioOutline = featureElement as ScenarioOutline;
            if (scenarioOutline != null)
            {
              this.excelScenarioOutlineFormatter.Format(worksheet, scenarioOutline, ref row);
            }

            row++;
              }
        }
Exemple #21
0
        public TestResult GetFeatureResult(Gherkin.Feature feature)
        {
            if (this.specRunFeatures == null)
            {
                return(TestResult.Inconclusive);
            }

            var specRunFeature = this.FindSpecRunFeature(feature);

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

            TestResult result = specRunFeature.Scenarios.Select(specRunScenario => StringToTestResult(specRunScenario.Result)).Merge();

            return(result);
        }
        public void Then_feature_is_added_successfully()
        {
            var excelFeatureFormatter = Container.Resolve<ExcelFeatureFormatter>();
            var feature = new Feature
                              {
                                  Name = "Test Feature",
                                  Description =
                                      "In order to test this feature,\nAs a developer\nI want to test this feature"
                              };

            using (var workbook = new XLWorkbook())
            {
                IXLWorksheet worksheet = workbook.AddWorksheet("SHEET1");
                excelFeatureFormatter.Format(worksheet, feature);

                worksheet.Cell("A1").Value.ShouldEqual(feature.Name);
                worksheet.Cell("B2").Value.ShouldEqual(feature.Description);
            }
        }
        public void ThenCanReadFeatureResultSuccesfully()
        {
            // Write out the embedded test results file
            using (var input = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("PicklesDoc.Pickles.Test." + RESULTS_FILE_NAME)))
            using (var output = new StreamWriter(RESULTS_FILE_NAME))
            {
                output.Write(input.ReadToEnd());
            }

            var configuration = Container.Resolve<Configuration>();
            configuration.TestResultsFile = new FileInfo(RESULTS_FILE_NAME);

            var results = Container.Resolve<CucumberJsonResults>();

            var feature = new Feature { Name = "Test Feature" };
            TestResult result = results.GetFeatureResult(feature);

            result.WasExecuted.ShouldBeTrue();
            result.WasSuccessful.ShouldBeFalse();
        }
        public void FeatureTagsAreAddedToScenarioTags()
        {
            var feature = new Feature
              {
            Name = "A Scenario with Tags",
            FeatureElements =
              {
                new Scenario
                  {
                    Name = "A Scenario",
                    Description = @"This scenario has tags",
                    Tags = { "scenarioTag1", "scenarioTag2" }
                  }
              },
            Tags = { "featureTag1", "featureTag2" }
              };

              feature.FeatureElements[0].Feature = feature;

              var htmlFeatureFormatter = Container.Resolve<HtmlFeatureFormatter>();
              XElement featureElement = htmlFeatureFormatter.Format(feature);

              var header = featureElement.Descendants().First(n => n.Attributes().Any(a => a.Name == "class" && a.Value == "scenario-heading"));

              Assert.AreEqual(3, header.Elements().Count());

              header.Elements().ElementAt(0).ShouldBeNamed("h2");
              header.Elements().ElementAt(1).ShouldBeNamed("p");
              header.Elements().ElementAt(2).ShouldBeNamed("div");

              var tagsParagraph = header.Elements().ElementAt(1);

              Assert.AreEqual(
            @"<p class=""tags"" xmlns=""http://www.w3.org/1999/xhtml"">Tags: <span>featureTag1</span>, <span>featureTag2</span>, <span>scenarioTag1</span>, <span>scenarioTag2</span></p>",
            tagsParagraph.ToString());
        }
Exemple #25
0
        public TestResult GetFeatureResult(Feature feature)
        {
            var featureExecutionIds =
                from unitTest in this.resultsDocument.Root.Descendants(ns + "UnitTest")
                let properties = unitTest.Element(ns + "Properties")
                where properties != null
                let property = properties.Element(ns + "Property")
                let key = property.Element(ns + "Key")
                let value = property.Element(ns + "Value")
                where key.Value == "FeatureTitle" && value.Value == feature.Name
                select new Guid(unitTest.Element(ns + "Execution").Attribute("id").Value);

            TestResult result = featureExecutionIds.Select(this.GetExecutionResult).Merge();

            return result;
        }
        public void ThenItWillRemoveUnnecessaryAndInvalidCharacters()
        {
            var excelSheetNameGenerator = Container.Resolve<ExcelSheetNameGenerator>();
            var feature = new Feature { Name = @"This Had invalid characters: :\/?*[]" };
            
            string name;
            using (var wb = new XLWorkbook())
            {
                name = excelSheetNameGenerator.GenerateSheetName(wb, feature);
            }

            name.ShouldEqual("THISHADINVALIDCHARACTERS");
        }
Exemple #27
0
 public TestResult GetFeatureResult(Feature feature)
 {
     return new TestResult();
 }
        private static string[] RetrieveTags(Feature feature)
        {
          if (feature == null) return new string[0];

          return feature.Tags.ToArray();
        }
Exemple #29
0
        private XElement GetFeatureElement(Feature feature)
        {
            IEnumerable<XElement> featureQuery =
                from clazz in this.resultsDocument.Root.Descendants("class")
                from test in clazz.Descendants("test")
                from trait in clazz.Descendants("traits").Descendants("trait")
                where trait.Attribute("name").Value == "FeatureTitle" && trait.Attribute("value").Value == feature.Name
                select clazz;

            return featureQuery.FirstOrDefault();
        }
Exemple #30
0
 private SpecRun.Feature FindSpecRunFeature(Gherkin.Feature feature)
 {
     return(this.specRunFeatures.FirstOrDefault(specRunFeature => specRunFeature.Title == feature.Name));
 }
 private XElement GetFeatureElement(Feature feature)
 {
     return this.resultsDocument
     .Descendants("test-suite")
     .Where(x => x.Attribute("description") != null)
     .FirstOrDefault(x => x.Attribute("description").Value == feature.Name);
 }
        public TestResult GetFeatureResult(Feature feature)
        {
            var results = this.TestResults.Select(tr => tr.GetFeatureResult(feature)).ToArray();

              return EvaluateTestResults(results);
        }