public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
if (this.specRunFeatures == null)
{
return TestResult.Inconclusive;
}
var specRunFeature = this.FindSpecRunFeature(scenarioOutline.Feature);
if (specRunFeature == null)
{
return TestResult.Inconclusive;
}
SpecRun.Scenario[] specRunScenarios = FindSpecRunScenarios(scenarioOutline, specRunFeature);
if (specRunScenarios.Length == 0)
{
return TestResult.Inconclusive;
}
TestResult result = StringsToTestResult(specRunScenarios.Select(srs => srs.Result));
return result;
}
public void Format(XElement parentElement, ScenarioOutline scenario)
{
var section = new XElement("section",
new XElement("title", scenario.Name));
if (!string.IsNullOrEmpty(scenario.Description))
{
section.Add(new XElement("p", scenario.Description));
}
if (this.configuration.HasTestResults)
{
TestResult testResult = this.nunitResults.GetScenarioOutlineResult(scenario);
if (testResult.WasExecuted && testResult.WasSuccessful)
{
section.Add(new XElement("note", "This scenario passed"));
}
else if (testResult.WasExecuted && !testResult.WasSuccessful)
{
section.Add(new XElement("note", "This scenario failed"));
}
}
foreach (Step step in scenario.Steps)
{
this.ditaStepFormatter.Format(section, step);
}
parentElement.Add(section);
}
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.WasExecuted)
{
worksheet.Cell(originalRow, "B").Style.Fill.SetBackgroundColor(results.WasSuccessful
? 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 void ThenCanFormatScenarioOutlineWithMissingNameCorrectly()
{
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
{
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 void ThenCanFormatScenarioOutlineWithMissingDescriptionCorrectly()
{
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",
Examples = examples
};
var htmlScenarioOutlineFormatter = Container.Resolve<HtmlScenarioOutlineFormatter>();
var output = htmlScenarioOutlineFormatter.Format(scenarioOutline, 0);
output.ShouldContainGherkinScenario();
output.ShouldContainGherkinTable();
}
public void Format(Body body, ScenarioOutline scenarioOutline)
{
if (this.configuration.HasTestResults)
{
TestResult testResult = this.testResults.GetScenarioOutlineResult(scenarioOutline);
if (testResult.WasExecuted && testResult.WasSuccessful)
{
body.GenerateParagraph("Passed", "Passed");
}
else if (testResult.WasExecuted && !testResult.WasSuccessful)
{
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);
}
}
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);
signature.IsMatch("Pickles.TestHarness.AdditionFeature.AddingSeveralNumbers(\"40\",\"50\",\"90\",System.String[])".ToLowerInvariant()).ShouldBeTrue();
}
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);
worksheet.Cell("B3").Value.ShouldEqual(scenarioOutline.Name);
worksheet.Cell("C4").Value.ShouldEqual(scenarioOutline.Description);
worksheet.Cell("B9").Value.ShouldEqual("Examples");
worksheet.Cell("D10").Value.ShouldEqual("Var1");
worksheet.Cell("E10").Value.ShouldEqual("Var2");
worksheet.Cell("F10").Value.ShouldEqual("Var3");
worksheet.Cell("G10").Value.ShouldEqual("Var4");
worksheet.Cell("D11").Value.ShouldEqual(1.0);
worksheet.Cell("E11").Value.ShouldEqual(2.0);
worksheet.Cell("F11").Value.ShouldEqual(3.0);
worksheet.Cell("G11").Value.ShouldEqual(4.0);
worksheet.Cell("D12").Value.ShouldEqual(5.0);
worksheet.Cell("E12").Value.ShouldEqual(6.0);
worksheet.Cell("F12").Value.ShouldEqual(7.0);
worksheet.Cell("G12").Value.ShouldEqual(8.0);
row.ShouldEqual(13);
}
}
public void ThenSingleScenarioOutlineAddedSuccessfully()
{
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
};
using (var workbook = new XLWorkbook())
{
IXLWorksheet worksheet = workbook.AddWorksheet("SHEET1");
int row = 3;
excelScenarioFormatter.Format(worksheet, scenarioOutline, ref row);
worksheet.Cell("B3").Value.ShouldEqual(scenarioOutline.Name);
worksheet.Cell("C4").Value.ShouldEqual(scenarioOutline.Description);
worksheet.Cell("B6").Value.ShouldEqual("Examples");
worksheet.Cell("D7").Value.ShouldEqual("Var1");
worksheet.Cell("E7").Value.ShouldEqual("Var2");
worksheet.Cell("F7").Value.ShouldEqual("Var3");
worksheet.Cell("G7").Value.ShouldEqual("Var4");
worksheet.Cell("D8").Value.ShouldEqual(1.0);
worksheet.Cell("E8").Value.ShouldEqual(2.0);
worksheet.Cell("F8").Value.ShouldEqual(3.0);
worksheet.Cell("G8").Value.ShouldEqual(4.0);
worksheet.Cell("D9").Value.ShouldEqual(5.0);
worksheet.Cell("E9").Value.ShouldEqual(6.0);
worksheet.Cell("F9").Value.ShouldEqual(7.0);
worksheet.Cell("G9").Value.ShouldEqual(8.0);
row.ShouldEqual(10);
}
}
public TestResult GetExampleResult(ScenarioOutline scenario, string[] exampleValues)
{
throw new NotSupportedException();
}
public override TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
IEnumerable <TestResult> exampleElements = this.GetScenarioOutlineElements(scenarioOutline).Select(this.GetResultFromElement);
return(this.DetermineAggregateResult(exampleElements));
}
public void ThenCanFormatScenarioOutlineWithMissingTableFromExampleCorrectly()
{
var example = new Example { Name = "Some examples", Description = "An example" };
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).Not.ContainsGherkinTable();
}
public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
var results = this.TestResults.Select(tr => tr.GetScenarioOutlineResult(scenarioOutline)).ToArray();
return(EvaluateTestResults(results));
}
public void ThenCanFormatScenarioOutlineWithMissingExampleCorrectly()
{
var scenarioOutline = new ScenarioOutline
{
Name = "Testing a scenario outline",
Description = "We need to make sure that scenario outlines work properly",
Examples = new List<Example>()
};
var htmlScenarioOutlineFormatter = Container.Resolve<HtmlScenarioOutlineFormatter>();
var output = htmlScenarioOutlineFormatter.Format(scenarioOutline, 0);
output.ShouldContainGherkinScenario();
output.ShouldNotContainGherkinTable();
}
public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
return new TestResult();
}
protected abstract XElement GetExamplesElement(ScenarioOutline scenarioOutline, string[] values);
private CodeMemberMethod CreateScenatioOutlineTestMethod(TestClassGenerationContext generationContext, ScenarioOutline scenarioOutline, ParameterSubstitution paramToIdentifier)
{
CodeMemberMethod testMethod = CreateMethod(generationContext.TestClass);
testMethod.Attributes = MemberAttributes.Public;
testMethod.Name = string.Format(TEST_NAME_FORMAT, scenarioOutline.Name.ToIdentifier());
foreach (var pair in paramToIdentifier)
{
testMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), pair.Value));
}
testMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string[]), SCENARIO_OUTLINE_EXAMPLE_TAGS_PARAMETER));
return(testMethod);
}
public XElement Format(ScenarioOutline scenarioOutline, params string[] exampleValues)
{
if (this.configuration.HasTestResults && this.results.SupportsExampleResults)
{
TestResult exampleResult = this.results.GetExampleResult(scenarioOutline, exampleValues);
return this.BuildImageElement(exampleResult);
}
return null;
}
public abstract TestResult GetExampleResult(ScenarioOutline scenario, string[] exampleValues);
public XElement Format(ScenarioOutline scenarioOutline)
{
if (this.configuration.HasTestResults)
{
TestResult scenarioResult = this.results.GetScenarioOutlineResult(scenarioOutline);
return this.BuildImageElement(scenarioResult);
}
return null;
}
public TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] exampleValues)
{
return new TestResult();
}
public void GetScenarioOutlineResult_TwoInconclusive_ReturnsInconclusive()
{
var scenarioOutline = new ScenarioOutline();
var testResults1 = SetupStubForGetScenarioOutlineResult(TestResult.Inconclusive);
var testResults2 = SetupStubForGetScenarioOutlineResult(TestResult.Inconclusive);
ITestResults multipleTestResults = CreateMultipleTestResults(testResults1.Object, testResults2.Object);
var result = multipleTestResults.GetScenarioOutlineResult(scenarioOutline);
result.ShouldEqual(TestResult.Inconclusive);
}
private void GenerateScenarioOutlineTestVariant(CodeTypeDeclaration testType, ScenarioOutline scenarioOutline, string testMethodName, List <KeyValuePair <string, string> > paramToIdentifier, string exampleSetTitle, Row row, Tags exampleSetTags, string variantName, ExampleSet exampleSet)
{
CodeMemberMethod testMethod = GetTestMethodDeclaration(testType, scenarioOutline, exampleSetTags);
testMethod.Name = string.IsNullOrEmpty(exampleSetTitle)
? string.Format("{0}_{1}", testMethod.Name, variantName)
: string.Format("{0}_{1}_{2}", testMethod.Name, exampleSetTitle, variantName);
//call test implementation with the params
List <CodeExpression> argumentExpressions = new List <CodeExpression>();
foreach (var paramCell in row.Cells)
{
argumentExpressions.Add(new CodePrimitiveExpression(paramCell.Value));
}
argumentExpressions.Add(GetStringArrayExpression(exampleSetTags));
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
testMethodName,
argumentExpressions.ToArray()));
List <KeyValuePair <string, string> > arguments = new List <KeyValuePair <string, string> >();
for (int rowIndex = 0; rowIndex < exampleSet.Table.Body.Length; rowIndex++)
{
arguments.Add(new KeyValuePair <string, string>(exampleSet.Table.Header.Cells[rowIndex].Value, row.Cells[rowIndex].Value));
}
testGeneratorProvider.SetTestVariant(testMethod, scenarioOutline.Title, exampleSetTitle, arguments);
}
public override TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] exampleValues)
{
var examplesElement = this.GetExamplesElement(scenarioOutline, exampleValues);
return(this.GetResultFromElement(examplesElement));
}
private void GenerateScenarioOutlineTest(TestClassGenerationContext generationContext, ScenarioOutline scenarioOutline)
{
ValidateExampleSetConsistency(scenarioOutline);
ParameterSubstitution paramToIdentifier = CreateParamToIdentifierMapping(scenarioOutline);
var scenatioOutlineTestMethod = CreateScenatioOutlineTestMethod(generationContext, scenarioOutline, paramToIdentifier);
var exampleTagsParam = new CodeVariableReferenceExpression(SCENARIO_OUTLINE_EXAMPLE_TAGS_PARAMETER);
if (generationContext.GenerateRowTests)
{
GenerateScenarioOutlineExamplesAsRowTests(generationContext, scenarioOutline, scenatioOutlineTestMethod);
}
else
{
GenerateScenarioOutlineExamplesAsIndividualMethods(scenarioOutline, generationContext, scenatioOutlineTestMethod, paramToIdentifier);
}
GenerateTestBody(generationContext, scenarioOutline, scenatioOutlineTestMethod, exampleTagsParam, paramToIdentifier);
}
public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
// Not applicable
return(new TestResult());
}
public override TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] arguments)
{
var results = TestResults.OfType <NUnitSingleResults>().Select(tr => tr.GetExampleResult(scenarioOutline, arguments)).ToArray();
return(EvaluateTestResults(results));
}
public void GetScenarioOutlineResult_OnePassingOneFailing_ReturnsFailed()
{
var scenarioOutline = new ScenarioOutline();
var testResults1 = SetupStubForGetScenarioOutlineResult(TestResult.Passed);
var testResults2 = SetupStubForGetScenarioOutlineResult(TestResult.Failed);
ITestResults multipleTestResults = CreateMultipleTestResults(testResults1.Object, testResults2.Object);
var result = multipleTestResults.GetScenarioOutlineResult(scenarioOutline);
result.ShouldEqual(TestResult.Failed);
}
protected abstract XElement GetScenarioOutlineElement(ScenarioOutline scenarioOutline);
public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
//Not applicable
return new TestResult();
}
public override TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
var scenarioOutlineElement = this.GetScenarioOutlineElement(scenarioOutline);
return(this.DetermineScenarioOutlineResult(scenarioOutlineElement));
}
public override TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] arguments)
{
var results = TestResults.OfType<NUnitSingleResults>().Select(tr => tr.GetExampleResult(scenarioOutline, arguments)).ToArray();
return EvaluateTestResults(results);
}
private void Add(ScenarioOutline scenarioOutline) => activeScenarioOutlinesList.Add(scenarioOutline);
private static SpecRun.Scenario[] FindSpecRunScenarios(ScenarioOutline scenarioOutline, SpecRun.Feature specRunFeature)
{
return specRunFeature.Scenarios.Where(d => d.Title.StartsWith(scenarioOutline.Name + ", ")).ToArray();
}
public void CreateScenarios(BusinessFlow BF)
{
string FileName = string.Empty;
if (BF.ExternalID != null)
{
FileName = BF.ExternalID.Replace(@"~", WorkSpace.Instance.Solution.Folder);
}
if (!System.IO.File.Exists(FileName))
{
// General
Reporter.ToUser(eUserMsgKey.GherkinFileNotFound, FileName);
return;
}
Parser parser = new Parser();
GherkinDocument gherkinDocument = parser.Parse(FileName);
mBizFlow = BF;
ClearGeneretedActivites(mBizFlow);
ClearOptimizedScenariosVariables(mBizFlow);
//Add Tags to BF
foreach (var t in gherkinDocument.Feature.Tags)
{
Guid TagGuid = GetOrCreateTagInSolution(t.Name);
mBizFlow.Tags.Add(TagGuid);
}
foreach (Gherkin.Ast.ScenarioDefinition sc in gherkinDocument.Feature.Children)
{
IEnumerable <Examples> examples = null;
// In case of Scenario Outline we need to generate new BF per each line in the table of examples
if (sc.Keyword == "Scenario Outline")
{
ScenarioOutline so = (ScenarioOutline)sc;
examples = so.Examples;
}
// Create new BF per each scenario
if (examples == null)
{
CreateScenario(sc);
}
else
{
int i = 0;
ValuesDict = new Dictionary <string, List <OptionalValue> >();
//TODO: handle case of more than one example table - check what is Gherking expected todo: all combinations!!??
foreach (Examples x in examples)
{
foreach (Gherkin.Ast.TableRow tr in x.TableBody)
{
i++;
ActivitiesGroup AG = CreateScenario(sc, i);
// Now the we have the flow created with activities, we update the activities var replacing <param> with value from table
var activities = from z in BF.Activities where z.ActivitiesGroupID == AG.Name select z;
foreach (Activity a in activities)
{
while (true)
{
string ColName = General.GetStringBetween(a.ActivityName, "<", ">");
if (string.IsNullOrEmpty(ColName))
{
break;
}
string val = GetExampleValue(x.TableHeader, tr, ColName);
a.ActivityName = a.ActivityName.Replace("<" + ColName + ">", "\"" + val + "\"");
VariableBase v = a.Variables.Where(y => y.Name == ColName).FirstOrDefault();
OptionalValue ov = new OptionalValue(val);
if (ValuesDict.ContainsKey(ColName))
{
ValuesDict[ColName].Add(ov);
}
else
{
List <OptionalValue> newList = new List <OptionalValue>();
newList.Add(ov);
ValuesDict.Add(ColName, newList);
}
((VariableSelectionList)v).OptionalValuesList.Add(ov);
((VariableSelectionList)v).SelectedValue = val;
}
}
}
}
foreach (Activity a in BF.Activities)
{
foreach (VariableBase vb in a.Variables)
{
if (vb is VariableSelectionList)
{
if (ValuesDict.ContainsKey(vb.Name))
{
foreach (OptionalValue ov in ValuesDict[vb.Name])
{
OptionalValue ExistedOV = ((VariableSelectionList)vb).OptionalValuesList.Where(y => y.Value == ov.Value).FirstOrDefault();
if (ExistedOV == null)
{
((VariableSelectionList)vb).OptionalValuesList.Add(ov);
}
}
}
}
}
}
}
}
if (!string.IsNullOrEmpty(NotFoundItems))
{
Reporter.ToUser(eUserMsgKey.GherkinColumnNotExist, NotFoundItems);
}
}
public ScenarioTestCase(SpecFlowFeatureTestClass featureTestClass, ScenarioOutline scenario, string[] featureTags, Dictionary <string, string> scenarioOutlineParameters, string exampleId, Location exampleLocation)
: this(featureTestClass, scenario, featureTags, exampleLocation)
{
ScenarioOutlineParameters = scenarioOutlineParameters;
ExampleId = exampleId;
}
protected virtual void CompileScenarioOutline(List <Pickle> pickles, IEnumerable <PickleStep> backgroundSteps, ScenarioOutline scenarioOutline, IEnumerable <Tag> featureTags, string language)
{
foreach (var examples in scenarioOutline.Examples)
{
if (examples.TableHeader == null)
{
continue;
}
var variableCells = examples.TableHeader.Cells;
foreach (var values in examples.TableBody)
{
var valueCells = values.Cells;
var steps = new List <PickleStep>();
if (scenarioOutline.Steps.Any())
{
steps.AddRange(backgroundSteps);
}
var tags = new List <Tag>();
tags.AddRange(featureTags);
tags.AddRange(scenarioOutline.Tags);
tags.AddRange(examples.Tags);
foreach (var scenarioOutlineStep in scenarioOutline.Steps)
{
string stepText = Interpolate(scenarioOutlineStep.Text, variableCells, valueCells);
// TODO: Use an Array of location in DataTable/DocString as well.
// If the Gherkin AST classes supported
// a list of locations, we could just reuse the same classes
PickleStep pickleStep = CreatePickleStep(
scenarioOutlineStep,
stepText,
CreatePickleArguments(scenarioOutlineStep.Argument, variableCells, valueCells),
new[] {
PickleLocation(values.Location),
PickleStepLocation(scenarioOutlineStep)
}
);
steps.Add(pickleStep);
}
Pickle pickle = new Pickle(
Interpolate(scenarioOutline.Name, variableCells, valueCells),
language,
steps,
PickleTags(tags),
new[] {
PickleLocation(values.Location),
PickleLocation(scenarioOutline.Location)
}
);
pickles.Add(pickle);
}
}
}
public TestResult GetScenarioOutlineResult(ScenarioOutline scenarioOutline)
{
var results = this.TestResults.Select(tr => tr.GetScenarioOutlineResult(scenarioOutline)).ToArray();
return EvaluateTestResults(results);
}
public bool IsMatch(ScenarioOutline scenarioOutline, string[] exampleValues, object scenarioElement)
{
return(false);
}
void AssertThatExamplesAreGiven(ScenarioOutline outline, string fileName)
{
if (outline.Examples.Count == 0)
{
throw new GherkinParseException(fileName, "In a scenario outline, a table of examples should be given");
}
}
public abstract TestResult GetExampleResult(ScenarioOutline scenario, string[] exampleValues);
void AssertThatPlaceholdersCanBeResolvedWithThisTable(ScenarioOutline scenario, string fileName)
{
var placeholderMatcher = new Regex("<(.)*>");
var matches = scenario.Steps.SelectMany(s => placeholderMatcher.Matches(s.Text).Cast<Match>());
foreach(var match in matches.Select(m => m.Value.Substring(1, m.Value.Length - 2)))
{
var key = match;
if (!scenario.Examples.Any(d => d.ContainsKey(key)))
{
throw new GherkinParseException(fileName, "The placeholder '{0}' has no matching column in the table of examples", key);
}
}
}
private static SpecRun.Scenario[] FindSpecRunScenarios(ScenarioOutline scenarioOutline, SpecRun.Feature specRunFeature)
{
return(specRunFeature.Scenarios.Where(d => d.Title.StartsWith(scenarioOutline.Name + ", ")).ToArray());
}
///<summary>
/// Call this function to parse a piece of text, specifying its file origin (which will generate better error messages).
///</summary>
///<param name="fileName">Name of file origin of the Gherkin-text</param>
///<param name="text">Gherkin-text to parse</param>
///<returns>A parse result including the AST</returns>
public ParseResult Parse(string fileName, string text)
{
var features = new List<Feature>();
using (var reader = new StringReader(text))
{
var accumulatedTags = new List<string>();
string line;
Feature currentFeature = null;
Scenario currentScenario = null;
StepType? mostRecentStepType = null;
var tableColumnNames = new List<string>();
var parsingExamples = false;
var parsingBackground = false;
var lineNumber = 0;
while ((line = reader.ReadLine()) != null)
{
line = line.Trim();
lineNumber++;
if (ShouldBeIgnored(line))
{
continue;
}
if (line.StartsWith("@"))
{
var tokens = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var invalidTag = tokens.FirstOrDefault(t => !t.StartsWith("@"));
if (invalidTag != null)
{
throw new GherkinParseException(fileName, lineNumber, line,
"'{0}' is not a valid tag - tags must begin with '@', e.g. '@important'",
invalidTag);
}
var tags = tokens.Select(t => t.TrimStart('@'));
accumulatedTags.AddRange(tags);
continue;
}
if (line.StartsWith(FeatureIntroduction, Comparison))
{
var featureText = line.Substring(FeatureIntroduction.Length).Trim();
currentFeature = new Feature(featureText, accumulatedTags);
accumulatedTags.Clear();
features.Add(currentFeature);
currentScenario = null;
mostRecentStepType = null;
continue;
}
if (currentFeature == null)
{
currentFeature = Feature.NewAnonymousFeature(accumulatedTags);
accumulatedTags.Clear();
features.Add(currentFeature);
}
if (line.StartsWith("Background:", Comparison) )
{
parsingBackground = true;
continue;
}
if (line.StartsWith(ScenarioIntroduction, Comparison))
{
var scenarioText = line.Substring(line.IndexOf(":") + 1).Trim();
currentScenario = new ExecutableScenario(scenarioText, accumulatedTags.Concat(currentFeature.Tags));
accumulatedTags.Clear();
tableColumnNames.Clear();
currentFeature.Scenarios.Add(currentScenario);
mostRecentStepType = null;
parsingExamples = parsingBackground = false;
continue;
}
if (line.StartsWith(ScenarioOutlineIntroduction, Comparison))
{
var scenarioText = line.Substring(line.IndexOf(":") + 1).Trim();
currentScenario = new ScenarioOutline(scenarioText, accumulatedTags.Concat(currentFeature.Tags));
accumulatedTags.Clear();
tableColumnNames.Clear();
currentFeature.Scenarios.Add(currentScenario);
mostRecentStepType = null;
parsingExamples = parsingBackground = false;
continue;
}
if (line.StartsWith(ExamplesIntroduction, Comparison))
{
if (!(currentScenario is ScenarioOutline))
{
throw new GherkinParseException(fileName, lineNumber, line, "Cannot specify examples in an ordinary scenario. Please use the 'Scenario outline:' introduction if you mean to specify examples");
}
parsingExamples = true;
continue;
}
if (parsingBackground)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
if (line.StartsWith("and", Comparison))
{
if (mostRecentStepType == null)
{
throw new GherkinParseException(fileName, lineNumber, line,
@"Lines can only be introduced with ""and"" when it's preceded by either ""given"", ""when"", or ""then"".");
}
currentFeature.BackgroundSteps.Add(Step.And(line.Substring("and".Length).Trim(),
mostRecentStepType.Value));
}
else if (line.StartsWith("given", Comparison))
{
currentFeature.BackgroundSteps.Add(Step.Given(line.Substring("given".Length).Trim()));
mostRecentStepType = StepType.Given;
tableColumnNames.Clear();
}
else if (line.StartsWith("|"))
{
var tokens = line.Split('|').Select(s => s.Trim()).ToArray();
if (!tableColumnNames.Any())
{
tableColumnNames.AddRange(tokens);
}
else
{
var dict = new Dictionary<string, string>();
for (var index = 0; index < tokens.Length; index++)
{
var key = tableColumnNames[index];
if (string.IsNullOrEmpty(key)) continue;
dict[key] = tokens[index];
}
currentFeature.BackgroundSteps.Last().Parameters.Add(dict);
}
}
else
{
throw new GherkinParseException(fileName, lineNumber, line,
@"Expected line to start with either ""given"", or ""|"". Please note that ""when"" or ""then"" steps may not appear inside the background element.");
}
continue;
}
if (currentScenario != null)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
if (line.StartsWith("and", Comparison))
{
if (mostRecentStepType == null)
{
throw new GherkinParseException(fileName, lineNumber, line,
@"Lines can only be introduced with ""and"" when it's preceded by either ""given"", ""when"", ""then"", or ""|"".");
}
currentScenario.Steps.Add(Step.And(line.Substring("and".Length).Trim(),
mostRecentStepType.Value));
tableColumnNames.Clear();
}
else if (line.StartsWith("given", Comparison))
{
currentScenario.Steps.Add(Step.Given(line.Substring("given".Length).Trim()));
mostRecentStepType = StepType.Given;
tableColumnNames.Clear();
}
else if (line.StartsWith("when", Comparison))
{
currentScenario.Steps.Add(Step.When(line.Substring("when".Length).Trim()));
mostRecentStepType = StepType.When;
tableColumnNames.Clear();
}
else if (line.StartsWith("then", Comparison))
{
currentScenario.Steps.Add(Step.Then(line.Substring("then".Length).Trim()));
mostRecentStepType = StepType.Then;
tableColumnNames.Clear();
}
else if (line.StartsWith("|"))
{
var tokens = line.Split('|').Select(s => s.Trim()).ToArray();
if (!tableColumnNames.Any())
{
tableColumnNames.AddRange(tokens);
}
else
{
var dict = new Dictionary<string, string>();
for(var index = 0; index < tokens.Length; index++)
{
var key = tableColumnNames[index];
if (string.IsNullOrEmpty(key)) continue;
dict[key] = tokens[index];
}
if (parsingExamples)
{
((ScenarioOutline)currentScenario).Examples.Add(dict);
}
else
{
currentScenario.Steps.Last().Parameters.Add(dict);
}
}
}
else
{
throw new GherkinParseException(fileName, lineNumber, line,
@"Expected line to start with either ""given"", ""when"", or ""then"".");
}
continue;
}
currentFeature.AddText(line);
continue;
}
}
features.ForEach(feature => AssertConsistency(feature, fileName));
return new ParseResult(features);
}
private IEnumerable <assembliesAssemblyCollectionTest> GetScenarioOutlineElements(ScenarioOutline scenario)
{
var featureElement = this.GetFeatureElement(scenario.Feature);
if (featureElement == null)
{
return(Enumerable.Empty <assembliesAssemblyCollectionTest>());
}
var query = from test in featureElement.test
where HasDescriptionTrait(test, scenario.Name)
select test;
return(query);
}
private void GenerateScenarioOutlineTestVariant(CodeTypeDeclaration testType, ScenarioOutline scenarioOutline, string testMethodName,
IEnumerable <KeyValuePair <string, string> > paramToIdentifier, string exampleSetTitle, string exampleSetIdentifier,
Row row, Tags exampleSetTags, string variantName)
{
var variantNameIdentifier = variantName.ToIdentifier().TrimStart('_');
CodeMemberMethod testMethod = GetTestMethodDeclaration(testType, scenarioOutline, exampleSetTags);
testMethod.Name = string.IsNullOrEmpty(exampleSetIdentifier)
? string.Format("{0}_{1}", testMethod.Name, variantNameIdentifier)
: string.Format("{0}_{1}_{2}", testMethod.Name, exampleSetIdentifier, variantNameIdentifier);
//call test implementation with the params
List <CodeExpression> argumentExpressions = row.Cells.Select(paramCell => new CodePrimitiveExpression(paramCell.Value)).Cast <CodeExpression>().ToList();
argumentExpressions.Add(GetStringArrayExpression(exampleSetTags));
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
testMethodName,
argumentExpressions.ToArray()));
var arguments = paramToIdentifier.Select((p2i, paramIndex) => new KeyValuePair <string, string>(p2i.Key, row.Cells[paramIndex].Value)).ToList();
testGeneratorProvider.SetTestVariant(testMethod, scenarioOutline.Title, exampleSetTitle, variantName, arguments);
}
private void GenerateScenarioOutlineTest(CodeTypeDeclaration testType, CodeMemberMethod testSetup, ScenarioOutline scenarioOutline, Feature feature)
{
string testMethodName = string.Format(TEST_FORMAT, scenarioOutline.Title.ToIdentifier());
ParameterSubstitution paramToIdentifier = new ParameterSubstitution();
foreach (var param in scenarioOutline.Examples.ExampleSets[0].Table.Header.Cells)
{
paramToIdentifier.Add(param.Value, param.Value.ToIdentifierCamelCase());
}
if (scenarioOutline.Examples.ExampleSets.Length > 1)
{
//TODO: check params
}
var testMethod = GenerateScenarioOutlineBody(feature, scenarioOutline, paramToIdentifier, testType, testMethodName, testSetup);
if (testGeneratorProvider.SupportsRowTests && this.allowRowTests)
{
SetTestMethodDeclaration(testMethod, scenarioOutline, null, rowTest: true);
foreach (var exampleSet in scenarioOutline.Examples.ExampleSets)
{
for (int rowIndex = 0; rowIndex < exampleSet.Table.Body.Length; rowIndex++)
{
IEnumerable <string> arguments = exampleSet.Table.Body[rowIndex].Cells.Select(c => c.Value);
testGeneratorProvider.SetRow(testMethod, arguments, GetNonIgnoreTags(exampleSet.Tags), HasIgnoreTag(exampleSet.Tags));
}
}
}
else
{
int exampleSetIndex = 0;
foreach (var exampleSet in scenarioOutline.Examples.ExampleSets)
{
string exampleSetTitle = exampleSet.Title == null
? string.Format("Scenarios{0}", exampleSetIndex + 1)
: exampleSet.Title.ToIdentifier();
bool useFirstColumnAsName = CanUseFirstColumnAsName(exampleSet.Table);
for (int rowIndex = 0; rowIndex < exampleSet.Table.Body.Length; rowIndex++)
{
string variantName = useFirstColumnAsName ? exampleSet.Table.Body[rowIndex].Cells[0].Value.ToIdentifierPart() :
string.Format("Variant{0}", rowIndex);
GenerateScenarioOutlineTestVariant(testType, scenarioOutline, testMethodName, paramToIdentifier, exampleSetTitle, exampleSet.Table.Body[rowIndex], exampleSet.Tags, variantName, exampleSet);
}
exampleSetIndex++;
}
}
}
public bool IsMatch(ScenarioOutline scenarioOutline, string[] exampleValues, object scenarioElement)
{
var build = this.signatureBuilder.Build(scenarioOutline, exampleValues);
return(ScenarioOutlineExampleIsMatch((assembliesAssemblyCollectionTest)scenarioElement, build));
}
public Regex Build(ScenarioOutline scenarioOutline, string[] row)
{
// We don't actually need this regex-based thing for VsTest results.
// It sucks that we have to provide one.
return(new Regex(string.Empty));
}
public TestResult GetExampleResult(ScenarioOutline scenarioOutline, string[] arguments)
{
var results = TestResults.Select(tr => tr.GetExampleResult(scenarioOutline, arguments)).ToArray();
return(EvaluateTestResults(results));
}
private void GenerateScenarioOutlineExamplesAsRowTests(TestClassGenerationContext generationContext, ScenarioOutline scenarioOutline, CodeMemberMethod scenatioOutlineTestMethod)
{
SetupTestMethod(generationContext, scenatioOutlineTestMethod, scenarioOutline, null, null, null, rowTest: true);
foreach (var examples in scenarioOutline.Examples)
{
foreach (var row in examples.TableBody)
{
var arguments = row.Cells.Select(c => c.Value);
testGeneratorProvider.SetRow(generationContext, scenatioOutlineTestMethod, arguments, GetNonIgnoreTags(examples.Tags), HasIgnoreTag(examples.Tags));
}
}
}
public static IList <TableRow> GetExamplesTableBody(this ScenarioOutline scenario)
{
return(scenario.Examples.First().TableBody.ToList());
}
private void GenerateScenarioOutlineTestVariant(TestClassGenerationContext generationContext, ScenarioOutline scenarioOutline, CodeMemberMethod scenatioOutlineTestMethod,
IEnumerable <KeyValuePair <string, string> > paramToIdentifier, string exampleSetTitle, string exampleSetIdentifier,
Gherkin.Ast.TableRow row, IEnumerable <Tag> exampleSetTags, string variantName)
{
CodeMemberMethod testMethod = CreateTestMethod(generationContext, scenarioOutline, exampleSetTags, variantName, exampleSetIdentifier);
AddLineDirective(testMethod.Statements, scenarioOutline);
//call test implementation with the params
List <CodeExpression> argumentExpressions = row.Cells.Select(paramCell => new CodePrimitiveExpression(paramCell.Value)).Cast <CodeExpression>().ToList();
argumentExpressions.Add(GetStringArrayExpression(exampleSetTags));
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
scenatioOutlineTestMethod.Name,
argumentExpressions.ToArray()));
AddLineDirectiveHidden(testMethod.Statements);
var arguments = paramToIdentifier.Select((p2i, paramIndex) => new KeyValuePair <string, string>(p2i.Key, row.Cells.ElementAt(paramIndex).Value)).ToList();
testGeneratorProvider.SetTestMethodAsRow(generationContext, testMethod, scenarioOutline.Name, exampleSetTitle, variantName, arguments);
}
public static IList <TableCell> GetExamplesTableHeaders(this ScenarioOutline scenario)
{
return(scenario.Examples.First().TableHeader.Cells.ToList());
}
public override TestResult GetExampleResult(ScenarioOutline scenario, string[] exampleValues)
{
throw new NotSupportedException();
}
internal static bool BelongsToScenarioOutline(this XElement xmlScenario, ScenarioOutline scenarioOutline)
{
return(xmlScenario.Name().ToUpperInvariant().StartsWith(TransformName(scenarioOutline.Name)));
}
