public void ThenCanFormatMarkdownTableExtensions() { 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 with tables | Table Header 1 | Table Header 2 | | -------------- | -------------- | | Cell value 1 | Cell value 2 | | Cell value 3 | | | Cell value 4 | Cell value 5 | " }; var htmlFeatureFormatter = Container.Resolve<HtmlFeatureFormatter>(); XElement featureElement = htmlFeatureFormatter.Format(feature); XElement description = featureElement.Elements().FirstOrDefault(element => element.Name.LocalName == "div"); Check.That(description).IsNotNull(); Check.That(description).IsNamed("div"); Check.That(description).IsInNamespace("http://www.w3.org/1999/xhtml"); Check.That(description).HasAttribute("class", "description"); XElement table = description.Descendants().FirstOrDefault(el => el.Name.LocalName == "table"); Check.That(table).IsNotNull(); }
public void Then_feature_without_background_adds_first_scenario_on_correct_row() { 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", }; var scenario = new Scenario { Name = "Test Scenario", Description = "In order to test this scenario,\nAs a developer\nI want to test this scenario" }; var given = new Step { NativeKeyword = "Given", Name = "a precondition" }; scenario.Steps = new List<Step>(new[] { given }); feature.AddFeatureElement(scenario); using (var workbook = new XLWorkbook()) { IXLWorksheet worksheet = workbook.AddWorksheet("SHEET1"); excelFeatureFormatter.Format(worksheet, feature); Check.That(worksheet.Cell("B4").Value).IsEqualTo(scenario.Name); Check.That(worksheet.Cell("C5").Value).IsEqualTo(scenario.Description); Check.That(worksheet.Cell("D6").Value).IsEqualTo(given.Name); } }
public FeatureNode(FileSystemInfoBase location, string relativePathFromRoot, Feature feature) { this.OriginalLocation = location; this.OriginalLocationUrl = location.ToUri(); this.RelativePathFromRoot = relativePathFromRoot; this.Feature = feature; }
public JsonFeature Map(Feature feature) { if (feature == null) { return null; } var result = new JsonFeature { Name = feature.Name, Description = feature.Description, Result = this.resultMapper.Map(feature.Result), Tags = feature.Tags.ToArray().ToList(), }; result.FeatureElements.AddRange(feature.FeatureElements.Select(this.MapFeatureElement).ToList()); result.Background = this.scenarioMapper.Map(feature.Background); if (result.Background != null) { result.Background.Feature = result; } foreach (var featureElement in result.FeatureElements) { featureElement.Feature = result; } return result; }
public void Then_feature_with_background_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", }; var background = new Scenario { Name = "Test Background Scenario", Description = "In order to test this background,\nAs a developer\nI want to test this background" }; var given = new Step { NativeKeyword = "Given", Name = "a precondition" }; background.Steps = new List<Step>(new[] { given }); feature.AddBackground(background); using (var workbook = new XLWorkbook()) { IXLWorksheet worksheet = workbook.AddWorksheet("SHEET1"); excelFeatureFormatter.Format(worksheet, feature); Check.That(worksheet.Cell("B4").Value).IsEqualTo(background.Name); Check.That(worksheet.Cell("C5").Value).IsEqualTo(background.Description); Check.That(worksheet.Cell("D6").Value).IsEqualTo(given.Name); } }
protected override 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 void Setup() { this.testFeature = new Feature { Name = "Test" }; this.featureFileInfo = this.FileSystem.FileInfo.FromFileName(FileSystem.Path.Combine(RootPath, FeaturePath)); this.featureDirectoryNode = new FeatureNode(this.featureFileInfo, RelativePath, this.testFeature); this.featureWithMeta = new JsonFeatureWithMetaInfo(this.featureDirectoryNode); }
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); }
/// <summary> /// Retrieves all UnitTest XElements that belong to the specified feature. /// </summary> /// <param name="feature">The feature for which to retrieve the unit tests.</param> /// <returns>A sequence of <see cref="XElement" /> instances that are called "UnitTest" /// that belong to the specified feature.</returns> private IEnumerable<XElement> GetScenariosForFeature(Feature feature) { var scenarios = from scenario in this.resultsDocument.AllScenarios() where scenario.HasPropertyFeatureTitle(feature.Name) select scenario; return scenarios; }
public TestResult GetFeatureResult(Feature feature) { var featureElement = this.GetFeatureElement(feature); int passedCount = featureElement.passed; int failedCount = featureElement.failed; int skippedCount = featureElement.skipped; return GetAggregateResult(passedCount, failedCount, skippedCount); }
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); }
public void Map_FeatureWithDescription_ReturnsDescription() { var feature = new Feature { Description = "As a math idiot" }; var mapper = CreateMapper(); var actual = mapper.Map(feature); Check.That(actual.Description).IsEqualTo("As a math idiot"); }
public override TestResult GetFeatureResult(Feature feature) { var scenarios = this.GetScenariosForFeature(feature); var featureExecutionIds = scenarios.ExecutionIdElements(); TestResult result = this.GetExecutionResult(featureExecutionIds); return result; }
public void Map_FeatureWithName_ReturnsName() { var feature = new Feature { Name = "Name of the Feature" }; var mapper = CreateMapper(); var actual = mapper.Map(feature); Check.That(actual.Name).IsEqualTo("Name of the Feature"); }
public void Map_SomeFeature_ReturnsJsonFeature() { var feature = new Feature(); var mapper = CreateMapper(); var actual = mapper.Map(feature); Check.That(actual).IsNotNull(); }
public XElement Format(Feature feature) { if (this.configuration.HasTestResults) { TestResult scenarioResult = this.results.GetFeatureResult(feature); return this.BuildImageElement(scenarioResult); } return null; }
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(); }
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 != TestResult.Inconclusive) { worksheet.Cell("A1").Style.Fill.SetBackgroundColor(results == TestResult.Passed ? XLColor.AppleGreen : XLColor.CandyAppleRed); } var featureElementsToRender = new List<IFeatureElement>(); if (feature.Background != null) { featureElementsToRender.Add(feature.Background); } featureElementsToRender.AddRange(feature.FeatureElements); var row = 4; foreach (var featureElement in featureElementsToRender) { 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++; } }
public void ThenCanFormatDescriptionAsMarkdown() { 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"); Check.That(description).IsNotNull(); Check.That(description).IsNamed("div"); Check.That(description).IsInNamespace("http://www.w3.org/1999/xhtml"); Check.That(description).HasAttribute("class", "description"); Check.That(description.Elements().Count()).IsEqualTo(9); Check.That(description.Elements().ElementAt(0)).IsNamed("p"); Check.That(description.Elements().ElementAt(1)).IsNamed("h1"); Check.That(description.Elements().ElementAt(2)).IsNamed("p"); Check.That(description.Elements().ElementAt(3)).IsNamed("h2"); Check.That(description.Elements().ElementAt(4)).IsNamed("blockquote"); Check.That(description.Elements().ElementAt(5)).IsNamed("p"); Check.That(description.Elements().ElementAt(6)).IsNamed("ul"); Check.That(description.Elements().ElementAt(7)).IsNamed("p"); Check.That(description.Elements().ElementAt(8)).IsNamed("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); } Check.That(name).IsEqualTo("THISISAREALLYREALLYLONGFEATUREN"); }
private static string RemoveUnnecessaryAndIllegalCharacters(Feature feature) { return feature.Name .Replace(" ", string.Empty) .Replace("\t", string.Empty) .Replace(":", string.Empty) .Replace(@"\", string.Empty) .Replace("/", string.Empty) .Replace("?", string.Empty) .Replace("*", string.Empty) .Replace("[", string.Empty) .Replace("]", string.Empty); }
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(); }
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); } Check.That(name).IsEqualTo("ASHORTFEATURENAME"); }
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 TestResult GetFeatureResult(Feature feature) { var featureExecutionIds = from scenario in this.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 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_OnePassingOneInconclusive_ReturnsPassed() { var feature = new Feature(); var testResults1 = SetupStubForGetFeatureResult(feature, TestResult.Passed); var testResults2 = SetupStubForGetFeatureResult(feature, TestResult.Inconclusive); ITestResults multipleTestResults = CreateMultipleTestResults(testResults1.Object, testResults2.Object); var result = multipleTestResults.GetFeatureResult(feature); Check.That(result).IsEqualTo(TestResult.Passed); }
public void TestResultsFileIsMessingElementsForAFeature_ShouldReturnInconclusive() { var results = ParseResultsFile(); var feature = new Feature { Name = "Feature That Has No Scenarios In The Test Run" }; var scenarioWithoutElements = new Scenario { Name = "Ignored scenario", Feature = feature }; var result = results.GetScenarioResult(scenarioWithoutElements); Check.That(result).IsEqualTo(TestResult.Inconclusive); }
public void Process(Feature feature) { feature.Description = Process(feature.Description); foreach (var featureElement in feature.FeatureElements) { featureElement.Description = Process(featureElement.Description); } if (feature.Background != null) { feature.Background.Description = Process(feature.Background.Description); } }
public override TestResult GetFeatureResult(Feature feature) { var specRunFeature = this.FindSpecRunFeature(feature); if (specRunFeature == null) { return TestResult.Inconclusive; } TestResult result = specRunFeature.Scenarios.Select(specRunScenario => StringToTestResult(specRunScenario.Result)).Merge(); return result; }
public override TestResult GetFeatureResult(Feature feature) { XElement featureElement = this.GetFeatureElement(feature); if (featureElement == null) { return TestResult.Inconclusive; } 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 this.GetAggregateResult(passedCount, failedCount, skippedCount); }