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)
{
var testMethod = CreateTestMethod(generationContext, scenarioOutline, exampleSetTags, variantName, exampleSetIdentifier);
AddLineDirective(testMethod.Statements, scenarioOutline);
//call test implementation with the params
var 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);
}
private static string GetCellValue(TableCell cell, ParameterSubstitution paramToIdentifier,
TableRow parametersRow)
{
try
{
var cellValue = cell.Value.Trim();
if (parametersRow == null)
{
return(cellValue);
}
if (cellValue.StartsWith("<") && cellValue.EndsWith(">") &&
paramToIdentifier.TryGetIdentifier(cellValue.Substring(1, cellValue.Length - 2), out int paramIndex))
{
cellValue = parametersRow.Cells.ElementAt(paramToIdentifier[paramIndex].Value).Value;
return(cellValue);
}
return(cellValue);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private void GenerateStep(CodeStatementCollection statements,
Step scenarioStep,
ParameterSubstitution paramToIdentifier,
TableRow row,
StepKeyword stepKeyWord,
string keyWord)
{
var specFlowStep = AsSpecFlowStep(scenarioStep);
//testRunner.Given("something");
var arguments = new List <CodeExpression>
{
GetSubstitutedString(scenarioStep.Text, paramToIdentifier, row),
GetDocStringArgExpression(scenarioStep.Argument as DocString, paramToIdentifier, row),
GetTableArgExpression(scenarioStep.Argument as DataTable, statements, paramToIdentifier, row),
new CodePrimitiveExpression(keyWord)
};
AddLineDirective(statements, scenarioStep);
statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(NamingHelper.TestRunnerVariableName),
stepKeyWord.ToString()),
arguments.ToArray())));
}
public DataTable(TableRow[] rows)
{
if (rows == null) throw new ArgumentNullException("rows");
if (rows.Length == 0) throw new ArgumentException("DataTable must have at least one row", "rows");
Location = rows[0].Location;
Rows = rows;
}
public TableRow MapToTableRow(G.TableRow tableRow)
{
if (tableRow == null)
{
return(null);
}
return(new TableRow(tableRow.Cells.Select(this.MapToString)));
}
private TableRow MapToTableRowWithTestResult(G.TableRow tableRow)
{
if (tableRow == null)
{
return(null);
}
return(new TableRowWithTestResult(tableRow.Cells.Select(this.MapToString)));
}
public Examples(Tag[] tags, Location location, string keyword, string name, string description, TableRow header, TableRow[] body)
{
Tags = tags;
Location = location;
Keyword = keyword;
Name = name;
Description = description;
TableHeader = header;
TableBody = body;
}
public void MapToTableRow_RowWithCellValues_ReturnsRowContainingThoseValues()
{
G.TableRow row = this.factory.CreateGherkinTableRow(
new[]
{
"first cell",
"second cell"
});
var mapper = new Mapper();
var result = mapper.MapToTableRow(row);
Check.That(result.Cells).ContainsExactly("first cell", "second cell");
}
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)
{
var testMethod = CreateTestMethod(generationContext, scenarioOutline, exampleSetTags, variantName, exampleSetIdentifier);
//call test implementation with the params
var argumentExpressions = row.Cells.Select(paramCell => new CodePrimitiveExpression(paramCell.Value)).Cast <CodeExpression>().ToList();
argumentExpressions.Add(_scenarioPartHelper.GetStringArrayExpression(exampleSetTags));
var statements = new List <CodeStatement>();
using (new SourceLineScope(_specFlowConfiguration, _codeDomHelper, statements, generationContext.Document.SourceFilePath, scenarioOutline.Location))
{
statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
scenatioOutlineTestMethod.Name,
argumentExpressions.ToArray())));
}
testMethod.Statements.AddRange(statements.ToArray());
//_linePragmaHandler.AddLineDirectiveHidden(testMethod.Statements);
var arguments = paramToIdentifier.Select((p2i, paramIndex) => new KeyValuePair <string, string>(p2i.Key, row.Cells.ElementAt(paramIndex).Value)).ToList();
// Use the identifier of the example set (e.g. ExampleSet0, ExampleSet1) if we have it.
// Otherwise, use the title of the example set provided by the user in the feature file.
string exampleSetName = string.IsNullOrEmpty(exampleSetIdentifier) ? exampleSetTitle : exampleSetIdentifier;
_unitTestGeneratorProvider.SetTestMethodAsRow(generationContext, testMethod, scenarioOutline.Name, exampleSetName, variantName, arguments);
}
private CodeExpression GetTableArgExpression(
DataTable tableArg,
CodeStatementCollection statements,
ParameterSubstitution paramToIdentifier,
TableRow parametersRow)
{
if (tableArg == null)
{
return(new CodeCastExpression(typeof(Table), new CodePrimitiveExpression(null)));
}
_tableCounter++;
//TODO[Gherkin3]: remove dependency on having the first row as header
var header = tableArg.Rows.First();
var body = tableArg.Rows.Skip(1).ToArray();
//Table table0 = new Table(header...);
var tableVar = new CodeVariableReferenceExpression("table" + _tableCounter);
statements.Add(
new CodeVariableDeclarationStatement(typeof(Table), tableVar.VariableName,
new CodeObjectCreateExpression(
typeof(Table),
GetStringArrayExpression(header.Cells.Select(c => c.Value), paramToIdentifier, null))));
foreach (var row in body)
{
//table0.AddRow(cells...);
statements.Add(
new CodeMethodInvokeExpression(
tableVar,
"AddRow",
GetStringArrayExpression(row.Cells.Select(cell => GetCellValue(cell, paramToIdentifier, parametersRow)), paramToIdentifier,
null)));
}
return(tableVar);
}
private Gherkin.Ast.TableRow Clone(Gherkin.Ast.TableRow row, Func <TableCell, string> getValue = null)
{
var valueExpr = getValue ?? ((c) => c.Value);
return(new Gherkin.Ast.TableRow(row.Location, row.Cells.Select(c => new TableCell(c.Location, valueExpr(c))).ToArray()));
}
public TableRow MapToTableRow(G.TableRow tableRow)
{
return(this.mapper.Map <TableRow>(tableRow));
}
private CodeExpression GetSubstitutedString(string text, ParameterSubstitution paramToIdentifier, TableRow row)
{
if (text == null)
{
return(new CodeCastExpression(typeof(string), new CodePrimitiveExpression(null)));
}
if (paramToIdentifier == null)
{
return(new CodePrimitiveExpression(text));
}
if (row == null)
{
return(new CodePrimitiveExpression(text));
}
Regex paramRe = new Regex(@"\<(?<param>[^\>]+)\>");
string formatText = text.Replace("{", "{{").Replace("}", "}}");
List <int> arguments = new List <int>();
formatText = paramRe.Replace(formatText, match =>
{
string param = match.Groups["param"].Value;
int id;
if (!paramToIdentifier.TryGetIdentifier(param, out id))
{
return(match.Value);
}
int argIndex = arguments.IndexOf(id);
if (argIndex < 0)
{
argIndex = arguments.Count;
arguments.Add(id);
}
return("{" + argIndex + "}");
});
if (arguments.Count == 0)
{
return(new CodePrimitiveExpression(text));
}
List <CodeExpression> formatArguments = new List <CodeExpression>();
formatArguments.Add(new CodePrimitiveExpression(formatText));
formatArguments.AddRange(arguments.Select(id => new CodePrimitiveExpression(row.Cells.ElementAt(id).Value)));
return(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(string)),
"Format",
formatArguments.ToArray()));
}
private CodeExpression GetDocStringArgExpression(DocString docString, ParameterSubstitution paramToIdentifier, TableRow row)
{
return(GetSubstitutedString(docString == null ? null : docString.Content, paramToIdentifier, row));
}
private CodeExpression GetStringArrayExpression(IEnumerable <string> items, ParameterSubstitution paramToIdentifier, TableRow row)
{
return(new CodeArrayCreateExpression(typeof(string[]), items.Select(item => GetSubstitutedString(item, paramToIdentifier, row)).ToArray()));
}
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, string tag = null)
{
variantName = string.IsNullOrEmpty(tag) ? variantName : $"{variantName}_{tag}";
var testMethod = CreateTestMethod(generationContext, scenarioOutline, exampleSetTags, variantName, exampleSetIdentifier);
//_codeDomHelper.AddLineDirective(scenarioOutline, testMethod.Statements, _specFlowConfiguration);
var list1 = new List <CodeExpression>();
list1.AddRange(row.Cells.Select(paramCell => new CodePrimitiveExpression(paramCell.Value)).Cast <CodeExpression>().ToList());
list1.Add(exampleSetTags.GetStringArrayExpression());
//// NEW CODE START
if (tag != null)
{
var s = new CodePrimitiveExpression(tag);
list1.Add(s);
_setVariantToContextForOutlineTest = true;
}
//// NEW CODE END
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), scenatioOutlineTestMethod.Name, list1.ToArray()));
//_codeDomHelper.AddLineDirectiveHidden(testMethod.Statements, _specFlowConfiguration);
var list2 = paramToIdentifier.Select((p2i, paramIndex) => new KeyValuePair <string, string>(p2i.Key, row.Cells.ElementAt(paramIndex).Value)).ToList();
_testGeneratorProvider.SetTestMethodAsRow(generationContext, testMethod, scenarioOutline.Name, exampleSetTitle, variantName, list2);
}
private void FormatRow(TableRow tableRow, StringBuilder result, string indent = INDENT)
{
result.Append(indent);
FormatHasLocation(tableRow, result);
foreach (var tableCell in tableRow.Cells)
{
result.Append("|");
FormatHasLocation(tableCell, result);
result.Append(tableCell.Value);
}
result.AppendLine("|");
}
protected override async Task <RunSummary> RunTestAsync()
{
var test = new XunitTest(TestCase, TestCase.DisplayName); //TODO: this is a pickle, we could use the Compiler/Pickle interfaces from the Gherkin parser
var summary = new RunSummary()
{
Total = 1
};
var output = new StringBuilder();
var gherkinDocument = await SpecFlowParserHelper.ParseSpecFlowDocumentAsync(TestCase.FeatureFile.FeatureFilePath);
Scenario scenario = null;
if (gherkinDocument.SpecFlowFeature != null)
{
if (TestCase.IsScenarioOutline)
{
var scenarioOutline = gherkinDocument.SpecFlowFeature.ScenarioDefinitions.OfType <ScenarioOutline>().FirstOrDefault(s => s.Name == TestCase.Name);
Examples example = null;
Gherkin.Ast.TableRow exampleRow = null;
if (scenarioOutline != null && SpecFlowParserHelper.GetExampleRowById(scenarioOutline, TestCase.ExampleId, out example, out exampleRow))
{
scenario = SpecFlowParserHelper.CreateScenario(scenarioOutline, example, exampleRow);
}
}
else
{
scenario = gherkinDocument.SpecFlowFeature.ScenarioDefinitions.OfType <Scenario>().FirstOrDefault(s => s.Name == TestCase.Name);
}
}
string skipReason = null;
if (scenario == null)
{
skipReason = $"Unable to find Scenario: {TestCase.DisplayName}";
}
else if (gherkinDocument.SpecFlowFeature.Tags.GetTags().Concat(scenario.Tags.GetTags()).Contains("ignore"))
{
skipReason = "Ignored";
}
if (skipReason != null)
{
summary.Skipped++;
if (!MessageBus.QueueMessage(new TestSkipped(test, skipReason)))
{
CancellationTokenSource.Cancel();
}
}
else
{
var aggregator = new ExceptionAggregator(Aggregator);
if (!aggregator.HasExceptions)
{
aggregator.Run(() => RunScenario(gherkinDocument, scenario, output));
}
var exception = aggregator.ToException();
TestResultMessage testResult;
if (exception == null)
{
testResult = new TestPassed(test, summary.Time, output.ToString());
}
else
{
testResult = new TestFailed(test, summary.Time, output.ToString(), exception);
summary.Failed++;
}
if (!CancellationTokenSource.IsCancellationRequested)
{
if (!MessageBus.QueueMessage(testResult))
{
CancellationTokenSource.Cancel();
}
}
}
if (!MessageBus.QueueMessage(new TestFinished(test, summary.Time, output.ToString())))
{
CancellationTokenSource.Cancel();
}
return(summary);
}