public virtual void SetRowTest(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string scenarioTitle)
{
CodeDomHelper.AddAttribute(testMethod, THEORY_ATTRIBUTE);
SetProperty(testMethod, FEATURE_TITLE_PROPERTY_NAME, generationContext.Feature.Title);
SetDescription(testMethod, scenarioTitle);
}
public void SetRow(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> arguments, IEnumerable<string> tags, bool isIgnored)
{
var args = arguments.Select(arg => new CodeAttributeArgument(new CodePrimitiveExpression(arg))).ToList();
// addressing ReSharper bug: TestCase attribute with empty string[] param causes inconclusive result - https://github.com/techtalk/SpecFlow/issues/116
var exampleTagExpressionList = tags.Select(t => new CodePrimitiveExpression(t)).ToArray();
CodeExpression exampleTagsExpression = exampleTagExpressionList.Length == 0 ? (CodeExpression)new CodePrimitiveExpression(null) : new CodeArrayCreateExpression(typeof(string[]), exampleTagExpressionList);
args.Add(new CodeAttributeArgument(exampleTagsExpression));
if (isIgnored)
{
args.Add(new CodeAttributeArgument("Ignored", new CodePrimitiveExpression(true)));
}
if (this.enableSauceLabs)
{
this.SetSauceAttributes(testMethod, args);
}
else
{
this.codeDomHelper.AddAttribute(testMethod, RowAttr, args.ToArray());
}
}
/// <summary>
/// Sets the test class.
/// </summary>
/// <param name="generationContext">The generation context.</param>
/// <param name="featureTitle">The feature title.</param>
/// <param name="featureDescription">The feature description.</param>
public override void SetTestClass(TestClassGenerationContext generationContext, string featureTitle, string featureDescription)
{
base.SetTestClass(generationContext, featureTitle, featureDescription);
// Get the driver assembly name.
var providerName = this.configurationProvider.GetBrowserDriverType();
// Only generate Coded UI attribute if using the Coded UI provider.
if (string.Equals(Constants.CodedUiDriverAssembly, providerName, StringComparison.OrdinalIgnoreCase))
{
foreach (var customAttribute in generationContext.TestClass.CustomAttributes
.Cast<CodeAttributeDeclaration>()
.Where(customAttribute => string.Equals(customAttribute.Name, TestClassAttribute)))
{
generationContext.TestClass.CustomAttributes.Remove(customAttribute);
break;
}
generationContext.TestClass.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(CodedUiTestClassAttribute)));
}
// Add deployment item in each test for the driver.
generationContext.TestClass.CustomAttributes.Add(
new CodeAttributeDeclaration(
new CodeTypeReference(DeploymentItemAttribute),
new CodeAttributeArgument(new CodePrimitiveExpression(providerName))));
}
public void SetTestClassInitializeMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
this.codeDomHelper.AddAttribute(generationContext.TestClassInitializeMethod, TESTFIXTURESETUP_ATTR);
generationContext.TestClassInitializeMethod.Statements.Add(new CodeSnippetStatement(" var builder = new ContainerBuilder();"));
generationContext.TestClassInitializeMethod.Statements.Add(new CodeSnippetStatement(" builder.RegisterModule(new ConfigurationSettingsReader());"));
generationContext.TestClassInitializeMethod.Statements.Add(new CodeSnippetStatement(" this.container = builder.Build();"));
}
public override void SetTestMethodAsRow(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string scenarioTitle, string exampleSetName, string variantName, IEnumerable<KeyValuePair<string, string>> arguments)
{
base.SetTestMethodAsRow(generationContext, testMethod, scenarioTitle, exampleSetName, variantName, arguments);
// change memberMethodName
testMethod.Name = GetMethodName(scenarioTitle, exampleSetName, arguments);
newTitles.Add(testMethod.Name);
}
public void FinalizeTestClass(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
// Can't be move to SetTestCleanupMethod, as the code at that point misses the .OnScenarioEnd() call.
// Make sure this code is at the end!
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" try { System.Threading.Thread.Sleep(50); this.driver.Quit(); } catch (System.Exception) {}"));
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" this.driver = null;"));
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Remove(\"Driver\");"));
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Remove(\"Container\");"));
}
private static void CreateInitializeSeleniumMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
var initializeSelenium = new CodeMemberMethod();
initializeSelenium.Name = "InitializeSelenium";
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "browser"));
initializeSelenium.Statements.Add(new CodeSnippetStatement(" this.driver = this.container.ResolveNamed<OpenQA.Selenium.IWebDriver>(browser);"));
generationContext.TestClass.Members.Add(initializeSelenium);
}
public override void SetTestMethodCategories(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> scenarioCategories)
{
base.SetTestMethodCategories(generationContext, testMethod, scenarioCategories);
var count = GetRetryCount(scenarioCategories);
if (count <= 1) return;
var existingAttribute = testMethod.CustomAttributes.OfType<CodeAttributeDeclaration>().SingleOrDefault(s => s.Name == "Xunit.RetryAttribute");
if (existingAttribute != null) testMethod.CustomAttributes.Remove(existingAttribute);
existingAttribute = testMethod.CustomAttributes.OfType<CodeAttributeDeclaration>().SingleOrDefault(s => s.Name == "Xunit.FactAttribute");
if (existingAttribute != null) testMethod.CustomAttributes.Remove(existingAttribute);
CodeDomHelper.AddAttribute(testMethod, "Xunit.RetryAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(count)));
}
/// <summary>
/// The decorate from.
/// </summary>
/// <param name="tagName">The tag name.</param>
/// <param name="generationContext">The generation context.</param>
public void DecorateFrom(string tagName, TestClassGenerationContext generationContext)
{
if (tagName == LiveTestTag)
{
string baseClassName = this.GetLiveTestBaseClassName(generationContext.Feature);
this.InheritFromIntegrationTestBase(generationContext.TestClass, baseClassName);
}
this.DecorateWithDiscoveredTagMappings(generationContext.Feature.SourceFile, tagName, generationContext.TestClass);
}
public virtual void FinalizeTestClass(TestClassGenerationContext generationContext)
{
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Add(\"Test\", this);"));
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" StartDriver();"));
// From SeleniumNunit + BBTest changes
// Can't be move to SetTestCleanupMethod, as the code at that point misses the .OnScenarioEnd() call.
// Make sure this code is at the end!
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" SaveChromeArtifacts(IsPass());"));
generationContext.TestCleanupMethod.Statements.Add(new CodeSnippetStatement(" StopDriver();"));
}
public override void SetTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string scenarioTitle)
{
SetProperty(testMethod, FEATURE_TITLE_PROPERTY_NAME, generationContext.Feature.Title);
SetDescription(testMethod, scenarioTitle);
var count = !generationContext.CustomData.ContainsKey("featureRetryCount") ? 1 : Convert.ToInt32(generationContext.CustomData["featureRetryCount"]);
if (count > 1)
CodeDomHelper.AddAttribute(testMethod, "Xunit.RetryAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(count)));
else
CodeDomHelper.AddAttribute(testMethod, FACT_ATTRIBUTE);
}
public void SetTestClass(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, string featureTitle, string featureDescription)
{
codeDomHelper.AddAttribute(generationContext.TestClass, TESTFIXTURE_ATTR);
codeDomHelper.AddAttribute(generationContext.TestClass, DESCRIPTION_ATTR, featureTitle);
generationContext.Namespace.Imports.Add(new CodeNamespaceImport("Autofac"));
generationContext.Namespace.Imports.Add(new CodeNamespaceImport("Autofac.Configuration"));
generationContext.TestClass.Members.Add(new CodeMemberField("OpenQA.Selenium.IWebDriver", "driver"));
generationContext.TestClass.Members.Add(new CodeMemberField("IContainer", "container"));
CreateInitializeSeleniumMethod(generationContext);
}
public void SetRow(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, IEnumerable <string> arguments, IEnumerable <string> tags, bool isIgnored)
{
var args = arguments.Select(
arg => new CodeAttributeArgument(new CodePrimitiveExpression(arg))).ToList();
// addressing ReSharper bug: TestCase attribute with empty string[] param causes inconclusive result - https://github.com/techtalk/SpecFlow/issues/116
var exampleTagExpressionList = tags.Select(t => new CodePrimitiveExpression(t)).ToArray();
CodeExpression exampleTagsExpression = exampleTagExpressionList.Length == 0 ?
(CodeExpression) new CodePrimitiveExpression(null) :
new CodeArrayCreateExpression(typeof(string[]), exampleTagExpressionList);
args.Add(new CodeAttributeArgument(exampleTagsExpression));
if (isIgnored)
{
args.Add(new CodeAttributeArgument("Ignored", new CodePrimitiveExpression(true)));
}
var browsers = testMethod.UserData.Keys.OfType <string>()
.Where(key => key.StartsWith("Browser:"))
.Select(key => (string)testMethod.UserData[key]).ToArray();
if (browsers.Any())
{
foreach (var codeAttributeDeclaration in testMethod.CustomAttributes.Cast <CodeAttributeDeclaration>().Where(attr => attr.Name == ROW_ATTR && attr.Arguments.Count == 3).ToList())
{
testMethod.CustomAttributes.Remove(codeAttributeDeclaration);
}
foreach (var browser in browsers)
{
var argsString = string.Concat(args.Take(args.Count - 1).Select(arg => string.Format("\"{0}\" ,", ((CodePrimitiveExpression)arg.Value).Value)));
argsString = argsString.TrimEnd(' ', ',');
var withBrowserArgs = new[] { new CodeAttributeArgument(new CodePrimitiveExpression(browser)) }
.Concat(args)
.Concat(new [] {
new CodeAttributeArgument("Category", new CodePrimitiveExpression(browser)),
new CodeAttributeArgument("TestName", new CodePrimitiveExpression(string.Format("{0} on {1} with: {2}", testMethod.Name, browser, argsString)))
})
.ToArray();
this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, withBrowserArgs);
}
}
else
{
this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, args.ToArray());
}
}
public override void SetTestClass(TestClassGenerationContext generationContext, string featureTitle, string featureDescription)
{
base.SetTestClass(generationContext, featureTitle, featureDescription);
foreach (CodeAttributeDeclaration customAttribute in generationContext.TestClass.CustomAttributes)
{
if (customAttribute.Name == "Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute")
{
generationContext.TestClass.CustomAttributes.Remove(customAttribute);
break;
}
}
generationContext.TestClass.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference("Microsoft.VisualStudio.TestTools.UITesting.CodedUITestAttribute")));
}
public void DecorateFrom(string tagName, TestClassGenerationContext generationContext, CodeMemberMethod testMethod)
{
var testCase = tagName.Substring(TagPrefix.Length);
testMethod.Statements.Insert(0,
new CodeExpressionStatement
(
new CodeMethodInvokeExpression
(
new CodeTypeReferenceExpression(typeof(Console)),
"WriteLine",
new CodePrimitiveExpression(string.Format("Running test case '{0}'", testCase))
)
)
);
}
public virtual void SetRow(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> arguments, IEnumerable<string> tags, bool isIgnored)
{
//TODO: better handle "ignored"
if (isIgnored)
return;
var args = arguments.Select(
arg => new CodeAttributeArgument(new CodePrimitiveExpression(arg))).ToList();
args.Add(
new CodeAttributeArgument(
new CodeArrayCreateExpression(typeof(string[]), tags.Select(t => new CodePrimitiveExpression(t)).ToArray())));
CodeDomHelper.AddAttribute(testMethod, INLINEDATA_ATTRIBUTE, args.ToArray());
}
// Retrieve the test methods, duplicate them for each driver, then replace the originals.
public override void FinalizeTestClass(TestClassGenerationContext generationContext)
{
test.Selenium.DriverConfiguration.ConfigurationSectionHandler webDriverConfig = test.Selenium.DriverConfiguration.ConfigurationReader.GetConfigurationFromFeatureFile(generationContext.Feature.SourceFile);
// Loop through all TestMethods and add the ScnearionContext["CurrentStep"] statement so our tests can know what step they are on.
List<CodeMemberMethod> allTestMethods = GetAllTestMethods(generationContext);
foreach (var testMethod in allTestMethods)
{
var testRunnerStatements = GetTestRunnerStatements(testMethod.Statements);
foreach (var testRunnerStatement in testRunnerStatements)
{
testMethod.Statements.Insert(testRunnerStatement.Key, new CodeSnippetStatement(String.Format(UpdateScenarioCurrentStep, testRunnerStatement.Value)));
}
}
// Look for all Selenium TestMethods (@Selenium tag) and create a _With_<browserKey> TestMethod for each desired browserKey
List<CodeMemberMethod> seleniumTestMethods = GetSeleniumTestMethods(allTestMethods);
List<CodeMemberMethod> webDriverTestMethods = CreateWebDriverTestMethods(seleniumTestMethods, generationContext, webDriverConfig);
seleniumTestMethods.ForEach(method => generationContext.TestClass.Members.Remove(method));
webDriverTestMethods.ForEach(method => generationContext.TestClass.Members.Add(method));
base.FinalizeTestClass(generationContext);
}
public void SetTestMethodCategories(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, IEnumerable <string> scenarioCategories)
{
this.codeDomHelper.AddAttributeForEachValue(testMethod, CATEGORY_ATTR, scenarioCategories.Where(cat => !cat.StartsWith("Browser:")));
bool hasBrowser = false;
foreach (var browser in scenarioCategories.Where(cat => cat.StartsWith("Browser:")).Select(cat => cat.Replace("Browser:", "")))
{
testMethod.UserData.Add("Browser:" + browser, browser);
var withBrowserArgs = new[] { new CodeAttributeArgument(new CodePrimitiveExpression(browser)) }
.Concat(new[] {
new CodeAttributeArgument("Category", new CodePrimitiveExpression(browser)),
new CodeAttributeArgument("TestName", new CodePrimitiveExpression(string.Format("{0} on {1}", testMethod.Name, browser)))
})
.ToArray();
this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, withBrowserArgs);
hasBrowser = true;
}
if (hasBrowser)
{
if (!scenarioSetupMethodsAdded)
{
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" if(this.driver != null)"));
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Add(\"Driver\", this.driver);"));
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" if(this.container != null)"));
generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Add(\"Container\", this.container);"));
scenarioSetupMethodsAdded = true;
}
testMethod.Statements.Insert(0, new CodeSnippetStatement(" InitializeSelenium(browser);"));
testMethod.Parameters.Insert(0, new System.CodeDom.CodeParameterDeclarationExpression("System.string", "browser"));
}
}
private static void UpdateSauceLabsStatus(TestClassGenerationContext generationContext)
{
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" bool passed = true;"));
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" if (ScenarioContext.Current.TestError != null) { passed = false; }"));
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" UpdateSauceLabsStatus(passed);"));
}
public override void FinalizeTestClass(TestClassGenerationContext generationContext)
{
base.FinalizeTestClass(generationContext);
// change namespace
generationContext.Namespace.Name = DefaultNameSpace;
}
public void SetTestMethodIgnore(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod)
{
this.codeDomHelper.AddAttribute(testMethod, IGNORE_ATTR);
}
public void SetTestMethodAsRow(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle, string exampleSetName, string variantName, IEnumerable <KeyValuePair <string, string> > arguments)
{
}
private static void CreateUpdateSauceLabsStatusMethod(TestClassGenerationContext generationContext)
{
var updateSauceLabsStatus = new CodeMemberMethod
{
Name = "UpdateSauceLabsStatus"
};
updateSauceLabsStatus.Parameters.Add(new CodeParameterDeclarationExpression("System.Boolean", "passed"));
updateSauceLabsStatus.Statements.Add(new CodeSnippetStatement(" var jobId = this.driver.GetSessionId();"));
updateSauceLabsStatus.Statements.Add(new CodeSnippetStatement(" if(passed) this.sauceRest.SetJobPassed(jobId);"));
updateSauceLabsStatus.Statements.Add(new CodeSnippetStatement(" else this.sauceRest.SetJobFailed(jobId);"));
generationContext.TestClass.Members.Add(updateSauceLabsStatus);
}
public void SetTestInitializeMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
this.codeDomHelper.AddAttribute(generationContext.TestInitializeMethod, TESTSETUP_ATTR);
}
private void GenerateScenarioOutlineExamplesAsIndividualMethods(ScenarioOutline scenarioOutline, TestClassGenerationContext generationContext, CodeMemberMethod scenatioOutlineTestMethod,
ParameterSubstitution paramToIdentifier)
{
int exampleSetIndex = 0;
foreach (var exampleSet in scenarioOutline.Examples)
{
bool useFirstColumnAsName = CanUseFirstColumnAsName(exampleSet.TableBody);
string exampleSetIdentifier = string.IsNullOrEmpty(exampleSet.Name)
? scenarioOutline.Examples.Count(es => string.IsNullOrEmpty(es.Name)) > 1
? string.Format("ExampleSet {0}", exampleSetIndex).ToIdentifier()
: null
: exampleSet.Name.ToIdentifier();
foreach (var example in exampleSet.TableBody.Select((r, i) => new { Row = r, Index = i }))
{
string variantName = useFirstColumnAsName ? example.Row.Cells.First().Value : string.Format("Variant {0}", example.Index);
GenerateScenarioOutlineTestVariant(generationContext, scenarioOutline, scenatioOutlineTestMethod, paramToIdentifier, exampleSet.Name ?? "", exampleSetIdentifier, example.Row,
exampleSet.Tags, variantName);
}
exampleSetIndex++;
}
}
public void SetTestClassCategories(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, IEnumerable <string> featureCategories)
{
this.codeDomHelper.AddAttributeForEachValue(generationContext.TestClass, CATEGORY_ATTR, featureCategories);
}
public virtual void SetTestCleanupMethod(TestClassGenerationContext generationContext)
{
// xUnit supports test tear down through the IDisposable interface
generationContext.TestClass.BaseTypes.Add(typeof(IDisposable));
// void IDisposable.Dispose() { <memberMethod>(); }
CodeMemberMethod disposeMethod = new CodeMemberMethod();
disposeMethod.PrivateImplementationType = new CodeTypeReference(typeof(IDisposable));
disposeMethod.Name = "Dispose";
generationContext.TestClass.Members.Add(disposeMethod);
disposeMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.TestCleanupMethod.Name));
}
public virtual void SetTestInitializeMethod(TestClassGenerationContext generationContext)
{
// xUnit uses a parameterless constructor
// public <_currentTestTypeDeclaration>() { <memberMethod>(); }
CodeConstructor ctorMethod = new CodeConstructor();
ctorMethod.Attributes = MemberAttributes.Public;
generationContext.TestClass.Members.Add(ctorMethod);
ctorMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.TestInitializeMethod.Name));
}
public virtual void SetTestClassInitializeMethod(TestClassGenerationContext generationContext)
{
// xUnit uses IUseFixture<T> on the class
generationContext.TestClassInitializeMethod.Attributes |= MemberAttributes.Static;
_currentFixtureDataTypeDeclaration = CodeDomHelper.CreateGeneratedTypeDeclaration("FixtureData");
generationContext.TestClass.Members.Add(_currentFixtureDataTypeDeclaration);
var fixtureDataType =
CodeDomHelper.CreateNestedTypeReference(generationContext.TestClass, _currentFixtureDataTypeDeclaration.Name);
var useFixtureType = new CodeTypeReference(IUSEFIXTURE_INTERFACE, fixtureDataType);
CodeDomHelper.SetTypeReferenceAsInterface(useFixtureType);
generationContext.TestClass.BaseTypes.Add(useFixtureType);
// public void SetFixture(T) { } // explicit interface implementation for generic interfaces does not work with codedom
CodeMemberMethod setFixtureMethod = new CodeMemberMethod();
setFixtureMethod.Attributes = MemberAttributes.Public;
setFixtureMethod.Name = "SetFixture";
setFixtureMethod.Parameters.Add(new CodeParameterDeclarationExpression(fixtureDataType, "fixtureData"));
setFixtureMethod.ImplementationTypes.Add(useFixtureType);
generationContext.TestClass.Members.Add(setFixtureMethod);
// public <_currentFixtureTypeDeclaration>() { <fixtureSetupMethod>(); }
CodeConstructor ctorMethod = new CodeConstructor();
ctorMethod.Attributes = MemberAttributes.Public;
_currentFixtureDataTypeDeclaration.Members.Add(ctorMethod);
ctorMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(generationContext.TestClass.Name)),
generationContext.TestClassInitializeMethod.Name));
}
public virtual void SetTestClassIgnore(TestClassGenerationContext generationContext)
{
//TODO: how to do class level ignore?
}
public void SetTestClass(TestClassGenerationContext generationContext, string featureTitle, string featureDescription)
{
this.codeDomHelper.AddAttribute(generationContext.TestClass, TestfixtureAttr);
this.codeDomHelper.AddAttribute(generationContext.TestClass, DescriptionAttr, featureTitle);
if (generationContext.Feature.Tags != null)
{
this.enableSauceLabs = generationContext.Feature.Tags.Any(x => x.Name == "EnableSauceLabs");
}
if (this.enableSauceLabs)
{
this.sauceLabSettings = this.GetSauceLabsConfiguration();
generationContext.Namespace.Imports.Add(new CodeNamespaceImport("Endjin.Selenium.SpecFlowPlugin"));
generationContext.TestClass.Members.Add(new CodeMemberField("Endjin.Selenium.SpecFlowPlugin.RemoteWebDriver", "driver"));
generationContext.TestClass.Members.Add(new CodeMemberField("Endjin.Selenium.SpecFlowPlugin.SauceRest", "sauceRest"));
CreateInitializeSeleniumMethod(generationContext);
CreateInitializeSeleniumOverloadMethod(generationContext);
CreateUpdateSauceLabsStatusMethod(generationContext);
UpdateSauceLabsStatus(generationContext);
CleanUpSeleniumContext(generationContext);
}
}
private void GenerateTest(TestClassGenerationContext generationContext, Scenario scenario, SpecFlowFeature feature)
{
var testMethod = CreateTestMethod(generationContext, scenario, null);
GenerateTestBody(generationContext, scenario, testMethod, feature);
}
private void GenerateTestBody(TestClassGenerationContext generationContext, Scenario scenario, CodeMemberMethod testMethod, CodeExpression additionalTagsExpression = null, ParameterSubstitution paramToIdentifier = null)
{
//call test setup
//ScenarioInfo scenarioInfo = new ScenarioInfo("xxxx", tags...);
CodeExpression tagsExpression;
if (additionalTagsExpression == null)
{
tagsExpression = GetStringArrayExpression(scenario.Tags);
}
else if (scenario.Tags == null)
{
tagsExpression = additionalTagsExpression;
}
else
{
// merge tags list
// var tags = tags1
// if (tags2 != null)
// tags = Enumerable.ToArray(Enumerable.Concat(tags1, tags1));
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(string[]), "__tags", GetStringArrayExpression(scenario.Tags)));
tagsExpression = new CodeVariableReferenceExpression("__tags");
testMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
additionalTagsExpression,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeAssignStatement(
tagsExpression,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"ToArray",
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"Concat",
tagsExpression,
additionalTagsExpression)))));
}
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(ScenarioInfo), "scenarioInfo",
new CodeObjectCreateExpression(typeof(ScenarioInfo),
new CodePrimitiveExpression(scenario.Title),
tagsExpression)));
AddLineDirective(testMethod.Statements, scenario);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioInitializeMethod.Name,
new CodeVariableReferenceExpression("scenarioInfo")));
if (HasFeatureBackground(generationContext.Feature))
{
AddLineDirective(testMethod.Statements, generationContext.Feature.Background);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.FeatureBackgroundMethod.Name));
}
foreach (var scenarioStep in scenario.Steps)
{
GenerateStep(testMethod, scenarioStep, paramToIdentifier);
}
AddLineDirectiveHidden(testMethod.Statements);
// call scenario cleanup
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioCleanupMethod.Name));
}
public virtual void SetTestMethodCategories(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> scenarioCategories)
{
// xUnit does not support caregories
}
public void SetTestMethodCategories(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> scenarioCategories)
{
this.codeDomHelper.AddAttributeForEachValue(testMethod, CategoryAttr, scenarioCategories);
}
public void SetTestClassIgnore(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
this.codeDomHelper.AddAttribute(generationContext.TestClass, IGNORE_ATTR);
}
public virtual void SetTestMethodIgnore(TestClassGenerationContext generationContext, CodeMemberMethod testMethod)
{
var factAttr = testMethod.CustomAttributes.OfType<CodeAttributeDeclaration>()
.FirstOrDefault(codeAttributeDeclaration => codeAttributeDeclaration.Name == FACT_ATTRIBUTE);
if (factAttr != null)
{
// set [FactAttribute(Skip="reason")]
factAttr.Arguments.Add
(
new CodeAttributeArgument(FACT_ATTRIBUTE_SKIP_PROPERTY_NAME, new CodePrimitiveExpression(SKIP_REASON))
);
}
}
public void SetTestCleanupMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext)
{
this.codeDomHelper.AddAttribute(generationContext.TestCleanupMethod, TESTTEARDOWN_ATTR);
}
public virtual void FinalizeTestClass(TestClassGenerationContext generationContext)
{
// by default, doing nothing to the final generated code
}
public void SetTestMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle)
{
this.codeDomHelper.AddAttribute(testMethod, TEST_ATTR);
this.codeDomHelper.AddAttribute(testMethod, DESCRIPTION_ATTR, scenarioTitle);
}
private static void CreateInitializeSeleniumOverloadMethod(TestClassGenerationContext generationContext)
{
var initializeSelenium = new CodeMemberMethod
{
Name = "InitializeSeleniumSauce"
};
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "browser"));
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "version"));
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "platform"));
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "testName"));
initializeSelenium.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "url"));
initializeSelenium.Statements.Add(new CodeSnippetStatement(" this.driver = new Endjin.Selenium.SpecFlowPlugin.RemoteWebDriver(url, browser, version, platform, testName, true);"));
generationContext.TestClass.Members.Add(initializeSelenium);
}
public void SetRowTest(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle)
{
this.SetTestMethod(generationContext, testMethod, scenarioTitle);
}
public virtual void SetTestClass(TestClassGenerationContext generationContext, string featureTitle, string featureDescription)
{
// xUnit does not use an attribute for the TestFixture, all public classes are potential fixtures
}
private void GenerateTest(TestClassGenerationContext generationContext, Scenario scenario)
{
CodeMemberMethod testMethod = CreateTestMethod(generationContext, scenario, null);
GenerateTestBody(generationContext, scenario, testMethod);
}
public virtual void SetTestClassCategories(TestClassGenerationContext generationContext, IEnumerable<string> featureCategories)
{
// xUnit does not support caregories
}
private void GenerateScenarioOutlineExamplesAsIndividualMethods(ScenarioOutline scenarioOutline, TestClassGenerationContext generationContext, CodeMemberMethod scenatioOutlineTestMethod, ParameterSubstitution paramToIdentifier)
{
int exampleSetIndex = 0;
foreach (var exampleSet in scenarioOutline.Examples.ExampleSets)
{
bool useFirstColumnAsName = CanUseFirstColumnAsName(exampleSet.Table);
string exampleSetIdentifier = string.IsNullOrEmpty(exampleSet.Title)
? scenarioOutline.Examples.ExampleSets.Count(es => string.IsNullOrEmpty(es.Title)) > 1
? string.Format("ExampleSet {0}", exampleSetIndex).ToIdentifier()
: null
: exampleSet.Title.ToIdentifier();
for (int rowIndex = 0; rowIndex < exampleSet.Table.Body.Length; rowIndex++)
{
var row = exampleSet.Table.Body[rowIndex];
string variantName = useFirstColumnAsName ? row.Cells[0].Value : string.Format("Variant {0}", rowIndex);
GenerateScenarioOutlineTestVariant(generationContext, scenarioOutline, scenatioOutlineTestMethod, paramToIdentifier, exampleSet.Title ?? "", exampleSetIdentifier, row, exampleSet.Tags, variantName);
}
exampleSetIndex++;
}
}
public virtual void SetTestClassCleanupMethod(TestClassGenerationContext generationContext)
{
// xUnit uses IUseFixture<T> on the class
generationContext.TestClassCleanupMethod.Attributes |= MemberAttributes.Static;
_currentFixtureDataTypeDeclaration.BaseTypes.Add(typeof(IDisposable));
// void IDisposable.Dispose() { <fixtureTearDownMethod>(); }
CodeMemberMethod disposeMethod = new CodeMemberMethod();
disposeMethod.PrivateImplementationType = new CodeTypeReference(typeof(IDisposable));
disposeMethod.Name = "Dispose";
_currentFixtureDataTypeDeclaration.Members.Add(disposeMethod);
disposeMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(generationContext.TestClass.Name)),
generationContext.TestClassCleanupMethod.Name));
}
public virtual void SetTestMethodAsRow(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string scenarioTitle, string exampleSetName, string variantName, IEnumerable<KeyValuePair<string, string>> arguments)
{
// doing nothing since we support RowTest
}
private static void CleanUpSeleniumContext(TestClassGenerationContext generationContext)
{
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" try { System.Threading.Thread.Sleep(50); this.driver.Quit(); } catch (System.Exception) {}"));
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" this.driver = null;"));
generationContext.ScenarioCleanupMethod.Statements.Add(new CodeSnippetStatement(" ScenarioContext.Current.Remove(\"Driver\");"));
}