public GenerateStepDefinitionSkeletonForm(string featureTitle, StepInstance[] steps, Project specFlowProject, StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle, ProgrammingLanguage defaultLanguage, DTE dte)
{
this.dte = dte;
InitializeComponent();
stepsList.BeginUpdate();
stepsList.Items.Clear();
foreach (var step in steps)
{
stepsList.Items.Add(new ListItem(step), true);
}
stepsList.EndUpdate();
classNameTextBox.Text = string.Format("{0} Steps", featureTitle).ToIdentifier();
styleComboBox.BeginUpdate();
var styles = Enum.GetValues(typeof (StepDefinitionSkeletonStyle)).Cast<StepDefinitionSkeletonStyle>()
.Where(value => value != StepDefinitionSkeletonStyle.MethodNameRegex || defaultLanguage == ProgrammingLanguage.FSharp)
.ToArray();
styleComboBox.Items.Clear();
styleComboBox.Items.AddRange(styles.Select(s => new StyleItem(s)).ToArray<object>());
int selectedIndex = Array.IndexOf(styles, stepDefinitionSkeletonStyle);
styleComboBox.SelectedIndex = selectedIndex < 0 ? 0 : selectedIndex;
styleComboBox.EndUpdate();
defaultFolder = Path.Combine(VsxHelper.GetProjectFolder(specFlowProject), "StepDefinitions");
if (!Directory.Exists(defaultFolder))
defaultFolder = VsxHelper.GetProjectFolder(specFlowProject);
}
public string GetBindingClassSkeleton(ProgrammingLanguage language, StepInstance[] stepInstances, string namespaceName, string className, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var template = templateProvider.GetStepDefinitionClassTemplate(language);
var bindings = string.Join(Environment.NewLine, GetOrderedSteps(stepInstances)
.Select(si => GetStepDefinitionSkeleton(language, si, style, bindingCulture)).Distinct().ToArray()).TrimEnd();
if (bindings.Length > 0)
bindings = bindings.Indent(METHOD_INDENT);
//{namespace}/{className}/{bindings}
return ApplyTemplate(template, new { @namespace = namespaceName, className, bindings});
}
public override string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
if (getSkeleton != null)
return getSkeleton(stepInstance);
if (usageIndex < stepDefinitionSkeletons.Length)
{
return stepDefinitionSkeletons[usageIndex++];
}
return stepDefinitionSkeletons[stepDefinitionSkeletons.Length - 1];
}
public virtual string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var withRegex = style == StepDefinitionSkeletonStyle.RegexAttribute;
var template = templateProvider.GetStepDefinitionTemplate(language, withRegex);
var analyzedStepText = Analyze(stepInstance, bindingCulture);
//{attribute}/{regex}/{methodName}/{parameters}
return ApplyTemplate(template, new
{
attribute = stepInstance.StepDefinitionType,
regex = withRegex ? GetRegex(analyzedStepText) : "",
methodName = GetMethodName(stepInstance, analyzedStepText, style, language),
parameters = string.Join(", ", analyzedStepText.Parameters.Select(p => ToDeclaration(language, p)).ToArray())
});
}
private string GetMethodName(StepInstance stepInstance, AnalyzedStepText analyzedStepText, StepDefinitionSkeletonStyle style, ProgrammingLanguage language)
{
var keyword = LanguageHelper.GetDefaultKeyword(stepInstance.StepContext.Language, stepInstance.StepDefinitionType);
switch (style)
{
case StepDefinitionSkeletonStyle.RegexAttribute:
return keyword.ToIdentifier() + string.Concat(analyzedStepText.TextParts.ToArray()).ToIdentifier();
case StepDefinitionSkeletonStyle.MethodNameUnderscores:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsUnderscored, "_{0}");
case StepDefinitionSkeletonStyle.MethodNamePascalCase:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsPascalCase, "_{0}_");
case StepDefinitionSkeletonStyle.MethodNameRegex:
if (language != ProgrammingLanguage.FSharp)
goto case StepDefinitionSkeletonStyle.MethodNameUnderscores;
return "``" + GetRegex(analyzedStepText) + "``";
default:
throw new NotSupportedException();
}
}
public SpecFlowConfiguration(ConfigSource configSource,
ContainerRegistrationCollection customDependencies,
ContainerRegistrationCollection generatorCustomDependencies,
CultureInfo featureLanguage,
CultureInfo bindingCulture,
string unitTestProvider,
bool stopAtFirstError,
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome,
bool traceSuccessfulSteps,
bool traceTimings,
TimeSpan minTracedDuration,
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle,
List <string> additionalStepAssemblies,
List <PluginDescriptor> pluginDescriptors,
bool allowDebugGeneratedFiles,
bool allowRowTests,
bool markFeaturesParallelizable,
string[] skipParallelizableMarkerForTags)
{
ConfigSource = configSource;
CustomDependencies = customDependencies;
GeneratorCustomDependencies = generatorCustomDependencies;
FeatureLanguage = featureLanguage;
BindingCulture = bindingCulture;
UnitTestProvider = unitTestProvider;
StopAtFirstError = stopAtFirstError;
MissingOrPendingStepsOutcome = missingOrPendingStepsOutcome;
TraceSuccessfulSteps = traceSuccessfulSteps;
TraceTimings = traceTimings;
MinTracedDuration = minTracedDuration;
StepDefinitionSkeletonStyle = stepDefinitionSkeletonStyle;
AdditionalStepAssemblies = additionalStepAssemblies;
Plugins = pluginDescriptors;
AllowDebugGeneratedFiles = allowDebugGeneratedFiles;
AllowRowTests = allowRowTests;
MarkFeaturesParallelizable = markFeaturesParallelizable;
SkipParallelizableMarkerForTags = skipParallelizableMarkerForTags;
}
public SpecFlowConfiguration(ConfigSource configSource,
ContainerRegistrationCollection customDependencies,
ContainerRegistrationCollection generatorCustomDependencies,
CultureInfo featureLanguage,
CultureInfo bindingCulture,
bool stopAtFirstError,
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome,
bool traceSuccessfulSteps,
bool traceTimings,
TimeSpan minTracedDuration,
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle,
List <string> additionalStepAssemblies,
bool allowDebugGeneratedFiles,
bool allowRowTests,
string[] addNonParallelizableMarkerForTags,
ObsoleteBehavior obsoleteBehavior,
CucumberMessagesConfiguration cucumberMessagesConfiguration)
{
CucumberMessagesConfiguration = cucumberMessagesConfiguration;
ConfigSource = configSource;
CustomDependencies = customDependencies;
GeneratorCustomDependencies = generatorCustomDependencies;
FeatureLanguage = featureLanguage;
BindingCulture = bindingCulture;
StopAtFirstError = stopAtFirstError;
MissingOrPendingStepsOutcome = missingOrPendingStepsOutcome;
TraceSuccessfulSteps = traceSuccessfulSteps;
TraceTimings = traceTimings;
MinTracedDuration = minTracedDuration;
StepDefinitionSkeletonStyle = stepDefinitionSkeletonStyle;
AdditionalStepAssemblies = additionalStepAssemblies;
AllowDebugGeneratedFiles = allowDebugGeneratedFiles;
AllowRowTests = allowRowTests;
AddNonParallelizableMarkerForTags = addNonParallelizableMarkerForTags;
ObsoleteBehavior = obsoleteBehavior;
}
public string GetBindingClassSkeleton(ProgrammingLanguage language, StepInstance[] stepInstances, string namespaceName, string className, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var template = templateProvider.GetStepDefinitionClassTemplate(language);
var bindings = string.Join(Environment.NewLine, GetOrderedSteps(stepInstances)
.Select(si => GetStepDefinitionSkeleton(language, si, style, bindingCulture)).Distinct().ToArray()).TrimEnd();
if (bindings.Length > 0)
{
bindings = bindings.Indent(METHOD_INDENT);
}
//{namespace}/{className}/{bindings}
return(ApplyTemplate(template, new { @namespace = namespaceName, className, bindings }));
}
protected bool Equals(RuntimeConfiguration other)
{
return(Equals(FeatureLanguage, other.FeatureLanguage) && Equals(ToolLanguage, other.ToolLanguage) && Equals(BindingCulture, other.BindingCulture) && string.Equals(RuntimeUnitTestProvider, other.RuntimeUnitTestProvider) && DetectAmbiguousMatches.Equals(other.DetectAmbiguousMatches) && StopAtFirstError.Equals(other.StopAtFirstError) && MissingOrPendingStepsOutcome.Equals(other.MissingOrPendingStepsOutcome) && TraceSuccessfulSteps.Equals(other.TraceSuccessfulSteps) && TraceTimings.Equals(other.TraceTimings) && MinTracedDuration.Equals(other.MinTracedDuration) && StepDefinitionSkeletonStyle.Equals(other.StepDefinitionSkeletonStyle) &&
(AdditionalStepAssemblies ?? new List <string>()).SequenceEqual(other.AdditionalStepAssemblies ?? new List <string>()));
}
public StyleItem(StepDefinitionSkeletonStyle style)
{
Style = style;
}
public GenerateStepDefinitionSkeletonForm(string featureTitle, StepInstance[] steps, Project specFlowProject, StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle, ProgrammingLanguage defaultLanguage, DTE dte)
{
this.dte = dte;
InitializeComponent();
stepsList.BeginUpdate();
stepsList.Items.Clear();
foreach (var step in steps)
{
stepsList.Items.Add(new ListItem(step), true);
}
stepsList.EndUpdate();
classNameTextBox.Text = string.Format("{0} Steps", featureTitle).ToIdentifier();
styleComboBox.BeginUpdate();
var styles = Enum.GetValues(typeof(StepDefinitionSkeletonStyle)).Cast <StepDefinitionSkeletonStyle>()
.Where(value => value != StepDefinitionSkeletonStyle.MethodNameRegex || defaultLanguage == ProgrammingLanguage.FSharp)
.ToArray();
styleComboBox.Items.Clear();
styleComboBox.Items.AddRange(styles.Select(s => new StyleItem(s)).ToArray <object>());
int selectedIndex = Array.IndexOf(styles, stepDefinitionSkeletonStyle);
styleComboBox.SelectedIndex = selectedIndex < 0 ? 0 : selectedIndex;
styleComboBox.EndUpdate();
defaultFolder = Path.Combine(VsxHelper.GetProjectFolder(specFlowProject), "StepDefinitions");
if (!Directory.Exists(defaultFolder))
{
var currentFeatureFilePath = dte.ActiveDocument.FullName;
defaultFolder = Path.GetDirectoryName(currentFeatureFilePath);
}
}
public SpecFlowConfiguration LoadJson(SpecFlowConfiguration specFlowConfiguration, string jsonContent)
{
if (String.IsNullOrWhiteSpace(jsonContent))
{
throw new ArgumentNullException(nameof(jsonContent));
}
var jsonConfig = JsonSerializer.Deserialize <JsonConfig>(jsonContent);
ContainerRegistrationCollection containerRegistrationCollection = specFlowConfiguration.CustomDependencies;
ContainerRegistrationCollection generatorContainerRegistrationCollection = specFlowConfiguration.GeneratorCustomDependencies;
CultureInfo featureLanguage = specFlowConfiguration.FeatureLanguage;
CultureInfo bindingCulture = specFlowConfiguration.BindingCulture;
bool stopAtFirstError = specFlowConfiguration.StopAtFirstError;
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome = specFlowConfiguration.MissingOrPendingStepsOutcome;
bool traceSuccessfulSteps = specFlowConfiguration.TraceSuccessfulSteps;
bool traceTimings = specFlowConfiguration.TraceTimings;
TimeSpan minTracedDuration = specFlowConfiguration.MinTracedDuration;
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle = specFlowConfiguration.StepDefinitionSkeletonStyle;
List <string> additionalStepAssemblies = specFlowConfiguration.AdditionalStepAssemblies;
bool allowRowTests = specFlowConfiguration.AllowRowTests;
bool allowDebugGeneratedFiles = specFlowConfiguration.AllowDebugGeneratedFiles;
bool markFeaturesParallelizable = specFlowConfiguration.MarkFeaturesParallelizable;
string[] skipParallelizableMarkerForTags = specFlowConfiguration.SkipParallelizableMarkerForTags;
ObsoleteBehavior obsoleteBehavior = specFlowConfiguration.ObsoleteBehavior;
if (jsonConfig.Language != null)
{
if (jsonConfig.Language.Feature.IsNotNullOrWhiteSpace())
{
featureLanguage = CultureInfo.GetCultureInfo(jsonConfig.Language.Feature);
}
}
if (jsonConfig.BindingCulture != null)
{
if (jsonConfig.BindingCulture.Name.IsNotNullOrWhiteSpace())
{
bindingCulture = CultureInfo.GetCultureInfo(jsonConfig.BindingCulture.Name);
}
}
if (jsonConfig.Runtime != null)
{
missingOrPendingStepsOutcome = jsonConfig.Runtime.MissingOrPendingStepsOutcome;
stopAtFirstError = jsonConfig.Runtime.StopAtFirstError;
obsoleteBehavior = jsonConfig.Runtime.ObsoleteBehavior;
if (jsonConfig.Runtime.Dependencies != null)
{
foreach (var runtimeDependency in jsonConfig.Runtime.Dependencies)
{
containerRegistrationCollection.Add(runtimeDependency.ImplementationType, runtimeDependency.InterfaceType);
}
}
}
if (jsonConfig.Generator != null)
{
allowDebugGeneratedFiles = jsonConfig.Generator.AllowDebugGeneratedFiles;
allowRowTests = jsonConfig.Generator.AllowRowTests;
markFeaturesParallelizable = jsonConfig.Generator.MarkFeaturesParallelizable;
skipParallelizableMarkerForTags = jsonConfig.Generator.SkipParallelizableMarkerForTags?.ToArray();
}
if (jsonConfig.Trace != null)
{
traceSuccessfulSteps = jsonConfig.Trace.TraceSuccessfulSteps;
traceTimings = jsonConfig.Trace.TraceTimings;
minTracedDuration = jsonConfig.Trace.MinTracedDuration;
stepDefinitionSkeletonStyle = jsonConfig.Trace.StepDefinitionSkeletonStyle;
}
if (jsonConfig.StepAssemblies != null)
{
foreach (var stepAssemblyEntry in jsonConfig.StepAssemblies)
{
additionalStepAssemblies.Add(stepAssemblyEntry.Assembly);
}
}
return(new SpecFlowConfiguration(ConfigSource.Json,
containerRegistrationCollection,
generatorContainerRegistrationCollection,
featureLanguage,
bindingCulture,
stopAtFirstError,
missingOrPendingStepsOutcome,
traceSuccessfulSteps,
traceTimings,
minTracedDuration,
stepDefinitionSkeletonStyle,
additionalStepAssemblies,
allowDebugGeneratedFiles,
allowRowTests,
markFeaturesParallelizable,
skipParallelizableMarkerForTags,
obsoleteBehavior));
}
public StyleItem(StepDefinitionSkeletonStyle style)
{
Style = style;
}
private string GetMethodName(StepInstance stepInstance, AnalyzedStepText analyzedStepText, StepDefinitionSkeletonStyle style, ProgrammingLanguage language)
{
var keyword = LanguageHelper.GetDefaultKeyword(stepInstance.StepContext.Language, stepInstance.StepDefinitionType);
switch (style)
{
case StepDefinitionSkeletonStyle.RegexAttribute:
return(keyword.ToIdentifier() + string.Concat(analyzedStepText.TextParts.ToArray()).ToIdentifier());
case StepDefinitionSkeletonStyle.MethodNameUnderscores:
return(GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsUnderscored, "_{0}"));
case StepDefinitionSkeletonStyle.MethodNamePascalCase:
return(GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsPascalCase, "_{0}_"));
case StepDefinitionSkeletonStyle.MethodNameRegex:
if (language != ProgrammingLanguage.FSharp)
{
goto case StepDefinitionSkeletonStyle.MethodNameUnderscores;
}
return("``" + GetRegex(analyzedStepText) + "``");
default:
throw new NotSupportedException();
}
}
public Configuration.SpecFlowConfiguration LoadAppConfig(Configuration.SpecFlowConfiguration specFlowConfiguration, ConfigurationSectionHandler configSection)
{
if (configSection == null)
{
throw new ArgumentNullException(nameof(configSection));
}
ContainerRegistrationCollection runtimeContainerRegistrationCollection = specFlowConfiguration.CustomDependencies;
ContainerRegistrationCollection generatorContainerRegistrationCollection = specFlowConfiguration.GeneratorCustomDependencies;
CultureInfo featureLanguage = specFlowConfiguration.FeatureLanguage;
CultureInfo bindingCulture = specFlowConfiguration.BindingCulture;
bool stopAtFirstError = specFlowConfiguration.StopAtFirstError;
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome = specFlowConfiguration.MissingOrPendingStepsOutcome;
bool traceSuccessfulSteps = specFlowConfiguration.TraceSuccessfulSteps;
bool traceTimings = specFlowConfiguration.TraceTimings;
TimeSpan minTracedDuration = specFlowConfiguration.MinTracedDuration;
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle = specFlowConfiguration.StepDefinitionSkeletonStyle;
List <string> additionalStepAssemblies = specFlowConfiguration.AdditionalStepAssemblies;
ObsoleteBehavior obsoleteBehavior = specFlowConfiguration.ObsoleteBehavior;
bool allowRowTests = specFlowConfiguration.AllowRowTests;
bool allowDebugGeneratedFiles = specFlowConfiguration.AllowDebugGeneratedFiles;
bool markFeaturesParallelizable = specFlowConfiguration.MarkFeaturesParallelizable;
string[] skipParallelizableMarkerForTags = specFlowConfiguration.SkipParallelizableMarkerForTags;
CucumberMessagesConfiguration cucumberMessagesConfiguration = specFlowConfiguration.CucumberMessagesConfiguration;
if (IsSpecified(configSection.Language))
{
featureLanguage = CultureInfo.GetCultureInfo(configSection.Language.Feature);
}
if (IsSpecified(configSection.BindingCulture))
{
bindingCulture = CultureInfo.GetCultureInfo(configSection.BindingCulture.Name);
}
if (IsSpecified(configSection.Runtime))
{
stopAtFirstError = configSection.Runtime.StopAtFirstError;
missingOrPendingStepsOutcome = configSection.Runtime.MissingOrPendingStepsOutcome;
obsoleteBehavior = configSection.Runtime.ObsoleteBehavior;
if (IsSpecified(configSection.Runtime.Dependencies))
{
runtimeContainerRegistrationCollection = configSection.Runtime.Dependencies;
}
}
if (IsSpecified((configSection.Generator)))
{
allowDebugGeneratedFiles = configSection.Generator.AllowDebugGeneratedFiles;
allowRowTests = configSection.Generator.AllowRowTests;
markFeaturesParallelizable = configSection.Generator.MarkFeaturesParallelizable;
if (IsSpecified(configSection.Generator.SkipParallelizableMarkerForTags))
{
skipParallelizableMarkerForTags = configSection.Generator.SkipParallelizableMarkerForTags.Select(i => i.Value).ToArray();
}
if (IsSpecified(configSection.Generator.Dependencies))
{
generatorContainerRegistrationCollection = configSection.Generator.Dependencies;
}
}
if (IsSpecified(configSection.Trace))
{
if (!string.IsNullOrEmpty(configSection.Trace.Listener)) // backwards compatibility
{
runtimeContainerRegistrationCollection.Add(configSection.Trace.Listener, typeof(ITraceListener).AssemblyQualifiedName);
}
traceSuccessfulSteps = configSection.Trace.TraceSuccessfulSteps;
traceTimings = configSection.Trace.TraceTimings;
minTracedDuration = configSection.Trace.MinTracedDuration;
stepDefinitionSkeletonStyle = configSection.Trace.StepDefinitionSkeletonStyle;
}
foreach (var element in configSection.StepAssemblies)
{
var assemblyName = ((StepAssemblyConfigElement)element).Assembly;
additionalStepAssemblies.Add(assemblyName);
}
if (IsSpecified(configSection.CucumberMessages))
{
cucumberMessagesConfiguration.Enabled = configSection.CucumberMessages.Enabled;
foreach (CucumberMessageSinkElement cucumberMessagesSink in configSection.CucumberMessages.Sinks)
{
cucumberMessagesConfiguration.Sinks.Add(new CucumberMessagesSink(cucumberMessagesSink.Type, cucumberMessagesSink.Path));
}
}
return(new SpecFlowConfiguration(ConfigSource.AppConfig,
runtimeContainerRegistrationCollection,
generatorContainerRegistrationCollection,
featureLanguage,
bindingCulture,
stopAtFirstError,
missingOrPendingStepsOutcome,
traceSuccessfulSteps,
traceTimings,
minTracedDuration,
stepDefinitionSkeletonStyle,
additionalStepAssemblies,
allowDebugGeneratedFiles,
allowRowTests,
markFeaturesParallelizable,
skipParallelizableMarkerForTags,
obsoleteBehavior,
cucumberMessagesConfiguration
));
}
public SpecFlowConfiguration LoadJson(SpecFlowConfiguration specFlowConfiguration, string jsonContent)
{
if (String.IsNullOrWhiteSpace(jsonContent))
{
throw new ArgumentNullException(nameof(jsonContent));
}
var jsonConfig = JsonConvert.DeserializeObject <JsonConfig>(jsonContent);
ContainerRegistrationCollection containerRegistrationCollection = specFlowConfiguration.CustomDependencies;
ContainerRegistrationCollection generatorContainerRegistrationCollection = specFlowConfiguration.GeneratorCustomDependencies;
CultureInfo featureLanguage = specFlowConfiguration.FeatureLanguage;
CultureInfo bindingCulture = specFlowConfiguration.BindingCulture;
string unitTestProvider = specFlowConfiguration.UnitTestProvider;
bool stopAtFirstError = specFlowConfiguration.StopAtFirstError;
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome = specFlowConfiguration.MissingOrPendingStepsOutcome;
bool traceSuccessfulSteps = specFlowConfiguration.TraceSuccessfulSteps;
bool traceTimings = specFlowConfiguration.TraceTimings;
TimeSpan minTracedDuration = specFlowConfiguration.MinTracedDuration;
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle = specFlowConfiguration.StepDefinitionSkeletonStyle;
List <string> additionalStepAssemblies = specFlowConfiguration.AdditionalStepAssemblies;
List <PluginDescriptor> pluginDescriptors = specFlowConfiguration.Plugins;
bool allowRowTests = specFlowConfiguration.AllowRowTests;
bool allowDebugGeneratedFiles = specFlowConfiguration.AllowDebugGeneratedFiles;
bool markFeaturesParallelizable = specFlowConfiguration.MarkFeaturesParallelizable;
string[] skipParallelizableMarkerForTags = specFlowConfiguration.SkipParallelizableMarkerForTags;
var specFlowElement = jsonConfig.SpecFlow;
if (specFlowElement.Language != null)
{
if (specFlowElement.Language.Feature.IsNotNullOrWhiteSpace())
{
featureLanguage = CultureInfo.GetCultureInfo(specFlowElement.Language.Feature);
}
}
if (specFlowElement.BindingCulture != null)
{
if (specFlowElement.BindingCulture.Name.IsNotNullOrWhiteSpace())
{
bindingCulture = CultureInfo.GetCultureInfo(specFlowElement.BindingCulture.Name);
}
}
if (specFlowElement.UnitTestProvider != null)
{
if (specFlowElement.UnitTestProvider.Name.IsNotNullOrWhiteSpace())
{
unitTestProvider = specFlowElement.UnitTestProvider.Name;
}
}
if (specFlowElement.Runtime != null)
{
missingOrPendingStepsOutcome = specFlowElement.Runtime.MissingOrPendingStepsOutcome;
stopAtFirstError = specFlowElement.Runtime.StopAtFirstError;
}
if (specFlowElement.Generator != null)
{
allowDebugGeneratedFiles = specFlowElement.Generator.AllowDebugGeneratedFiles;
allowRowTests = specFlowElement.Generator.AllowRowTests;
markFeaturesParallelizable = specFlowElement.Generator.MarkFeaturesParallelizable;
skipParallelizableMarkerForTags = specFlowElement.Generator.SkipParallelizableMarkerForTags.ToArray();
}
if (specFlowElement.Trace != null)
{
traceSuccessfulSteps = specFlowElement.Trace.TraceSuccessfulSteps;
traceTimings = specFlowElement.Trace.TraceTimings;
minTracedDuration = specFlowElement.Trace.MinTracedDuration;
stepDefinitionSkeletonStyle = specFlowElement.Trace.StepDefinitionSkeletonStyle;
}
if (specFlowElement.StepAssemblies != null)
{
foreach (var stepAssemblyEntry in specFlowElement.StepAssemblies)
{
additionalStepAssemblies.Add(stepAssemblyEntry.Assembly);
}
}
if (specFlowElement.Plugins != null)
{
foreach (var pluginEntry in specFlowElement.Plugins)
{
pluginDescriptors.Add(new PluginDescriptor(pluginEntry.Name, pluginEntry.Path, pluginEntry.Type, pluginEntry.Parameters));
}
}
return(new SpecFlowConfiguration(ConfigSource.Json,
containerRegistrationCollection,
generatorContainerRegistrationCollection,
featureLanguage,
bindingCulture,
unitTestProvider,
stopAtFirstError,
missingOrPendingStepsOutcome,
traceSuccessfulSteps,
traceTimings,
minTracedDuration,
stepDefinitionSkeletonStyle,
additionalStepAssemblies,
pluginDescriptors,
allowDebugGeneratedFiles,
allowRowTests,
markFeaturesParallelizable,
skipParallelizableMarkerForTags));
}
public Configuration.SpecFlowConfiguration LoadAppConfig(Configuration.SpecFlowConfiguration specFlowConfiguration, ConfigurationSectionHandler configSection)
{
if (configSection == null)
{
throw new ArgumentNullException(nameof(configSection));
}
ContainerRegistrationCollection runtimeContainerRegistrationCollection = specFlowConfiguration.CustomDependencies;
ContainerRegistrationCollection generatorContainerRegistrationCollection = specFlowConfiguration.GeneratorCustomDependencies;
CultureInfo featureLanguage = specFlowConfiguration.FeatureLanguage;
CultureInfo bindingCulture = specFlowConfiguration.BindingCulture;
string runtimeUnitTestProvider = specFlowConfiguration.UnitTestProvider;
bool stopAtFirstError = specFlowConfiguration.StopAtFirstError;
MissingOrPendingStepsOutcome missingOrPendingStepsOutcome = specFlowConfiguration.MissingOrPendingStepsOutcome;
bool traceSuccessfulSteps = specFlowConfiguration.TraceSuccessfulSteps;
bool traceTimings = specFlowConfiguration.TraceTimings;
TimeSpan minTracedDuration = specFlowConfiguration.MinTracedDuration;
StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle = specFlowConfiguration.StepDefinitionSkeletonStyle;
List <string> additionalStepAssemblies = specFlowConfiguration.AdditionalStepAssemblies;
List <PluginDescriptor> pluginDescriptors = specFlowConfiguration.Plugins;
bool allowRowTests = specFlowConfiguration.AllowRowTests;
bool allowDebugGeneratedFiles = specFlowConfiguration.AllowDebugGeneratedFiles;
bool markFeaturesParallelizable = specFlowConfiguration.MarkFeaturesParallelizable;
string[] skipParallelizableMarkerForTags = specFlowConfiguration.SkipParallelizableMarkerForTags;
if (IsSpecified(configSection.Language))
{
featureLanguage = CultureInfo.GetCultureInfo(configSection.Language.Feature);
}
if (IsSpecified(configSection.BindingCulture))
{
bindingCulture = CultureInfo.GetCultureInfo(configSection.BindingCulture.Name);
}
if (IsSpecified(configSection.Runtime))
{
stopAtFirstError = configSection.Runtime.StopAtFirstError;
missingOrPendingStepsOutcome = configSection.Runtime.MissingOrPendingStepsOutcome;
if (IsSpecified(configSection.Runtime.Dependencies))
{
runtimeContainerRegistrationCollection = configSection.Runtime.Dependencies;
}
}
if (IsSpecified((configSection.Generator)))
{
allowDebugGeneratedFiles = configSection.Generator.AllowDebugGeneratedFiles;
allowRowTests = configSection.Generator.AllowRowTests;
markFeaturesParallelizable = configSection.Generator.MarkFeaturesParallelizable;
if (IsSpecified(configSection.Generator.SkipParallelizableMarkerForTags))
{
skipParallelizableMarkerForTags = configSection.Generator.SkipParallelizableMarkerForTags.Select(i => i.Value).ToArray();
}
if (IsSpecified(configSection.Generator.Dependencies))
{
generatorContainerRegistrationCollection = configSection.Generator.Dependencies;
}
}
if (IsSpecified(configSection.UnitTestProvider))
{
if (!string.IsNullOrEmpty(configSection.UnitTestProvider.RuntimeProvider))
{
//compatibility mode, we simulate a custom dependency
runtimeUnitTestProvider = "custom";
runtimeContainerRegistrationCollection.Add(configSection.UnitTestProvider.RuntimeProvider, typeof(IUnitTestRuntimeProvider).AssemblyQualifiedName, runtimeUnitTestProvider);
}
else
{
runtimeUnitTestProvider = configSection.UnitTestProvider.Name;
}
}
if (IsSpecified(configSection.Trace))
{
if (!string.IsNullOrEmpty(configSection.Trace.Listener)) // backwards compatibility
{
runtimeContainerRegistrationCollection.Add(configSection.Trace.Listener, typeof(ITraceListener).AssemblyQualifiedName);
}
traceSuccessfulSteps = configSection.Trace.TraceSuccessfulSteps;
traceTimings = configSection.Trace.TraceTimings;
minTracedDuration = configSection.Trace.MinTracedDuration;
stepDefinitionSkeletonStyle = configSection.Trace.StepDefinitionSkeletonStyle;
}
foreach (var element in configSection.StepAssemblies)
{
var assemblyName = ((StepAssemblyConfigElement)element).Assembly;
additionalStepAssemblies.Add(assemblyName);
}
var pluginNames = pluginDescriptors.Select(m => m.Name).ToList();
foreach (PluginConfigElement plugin in configSection.Plugins)
{
var pluginDescriptor = plugin.ToPluginDescriptor();
if (pluginNames.Contains(pluginDescriptor.Name))
{
continue;
}
pluginDescriptors.Add(pluginDescriptor);
pluginNames.Add(plugin.Name);
}
return(new SpecFlowConfiguration(ConfigSource.AppConfig,
runtimeContainerRegistrationCollection,
generatorContainerRegistrationCollection,
featureLanguage,
bindingCulture,
runtimeUnitTestProvider,
stopAtFirstError,
missingOrPendingStepsOutcome,
traceSuccessfulSteps,
traceTimings,
minTracedDuration,
stepDefinitionSkeletonStyle,
additionalStepAssemblies,
pluginDescriptors,
allowDebugGeneratedFiles,
allowRowTests,
markFeaturesParallelizable,
skipParallelizableMarkerForTags
));
}
public override string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
if (getSkeleton != null)
{
return(getSkeleton(stepInstance));
}
if (usageIndex < stepDefinitionSkeletons.Length)
{
return(stepDefinitionSkeletons[usageIndex++]);
}
return(stepDefinitionSkeletons[stepDefinitionSkeletons.Length - 1]);
}
public virtual string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var withRegex = style == StepDefinitionSkeletonStyle.RegexAttribute;
var template = templateProvider.GetStepDefinitionTemplate(language, withRegex);
var analyzedStepText = Analyze(stepInstance, bindingCulture);
//{attribute}/{regex}/{methodName}/{parameters}
return(ApplyTemplate(template, new
{
attribute = stepInstance.StepDefinitionType,
regex = withRegex ? GetRegex(analyzedStepText) : "",
methodName = GetMethodName(stepInstance, analyzedStepText, style, language),
parameters = string.Join(", ", analyzedStepText.Parameters.Select(p => ToDeclaration(language, p)).ToArray())
}));
}
