private IEnumerable <StepDefinitionType> GetStepDefinitionTypes(BindingSourceAttribute stepDefinitionAttribute)
{
if (typeof(GivenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Given }
}
;
if (typeof(WhenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.When }
}
;
if (typeof(ThenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Then }
}
;
if (typeof(StepDefinitionAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Given, StepDefinitionType.When, StepDefinitionType.Then }
}
;
return(new StepDefinitionType[0]);
}
private HookType?TryGetHookType(BindingSourceAttribute hookAttribute)
{
string typeName = hookAttribute.AttributeType.Name;
if (typeName == typeof(BeforeAttribute).Name)
{
return(HookType.BeforeScenario);
}
if (typeName == typeof(AfterAttribute).Name)
{
return(HookType.AfterScenario);
}
const string attributePostfix = "Attribute";
if (!typeName.EndsWith(attributePostfix))
{
return(null);
}
string name = typeName.Substring(0, typeName.Length - attributePostfix.Length);
if (!hookNames.Contains(name))
{
return(null);
}
return((HookType)Enum.Parse(typeof(HookType), name, false));
}
private bool IsHookAttribute(BindingSourceAttribute attribute)
{
// ReSharper disable AssignNullToNotNullAttribute
return(attribute.AttributeType.FullName.StartsWith(typeof(BeforeScenarioAttribute).Namespace) &&
TryGetHookType(attribute) != null);
// ReSharper restore AssignNullToNotNullAttribute
}
private IEnumerable <StepDefinitionType> GetStepDefinitionTypes(BindingSourceAttribute stepDefinitionAttribute)
{
//Note: the Visual Studio Extension resolves the BindingSourceAttribute from the step definition source code without the Types property.
//The Types property is only available at runtime when a StepDefinitionBaseAttribute can be reflected.
//Please do not remove the checks for the sub-classes.
if (typeof(GivenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Given }
}
;
if (typeof(WhenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.When }
}
;
if (typeof(ThenAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Then }
}
;
if (typeof(StepDefinitionAttribute).IsAssignableFrom(stepDefinitionAttribute.AttributeType))
{
return new[] { StepDefinitionType.Given, StepDefinitionType.When, StepDefinitionType.Then }
}
;
return(stepDefinitionAttribute.NamedAttributeValues["Types"].GetValue <IEnumerable <StepDefinitionType> >());
}
private bool IsStepDefinitionAttribute(BindingSourceAttribute attribute)
{
return
(attribute.AttributeType.TypeEquals(typeof(GivenAttribute)) ||
attribute.AttributeType.TypeEquals(typeof(WhenAttribute)) ||
attribute.AttributeType.TypeEquals(typeof(ThenAttribute)) ||
attribute.AttributeType.TypeEquals(typeof(StepDefinitionAttribute)));
}
private bool IsStepDefinitionAttribute(BindingSourceAttribute attribute)
{
return
(typeof(GivenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(WhenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(ThenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(StepDefinitionAttribute).IsAssignableFrom(attribute.AttributeType));
}
private HookType GetHookType(BindingSourceAttribute hookAttribute)
{
var hookType = TryGetHookType(hookAttribute);
if (hookType == null)
{
throw new SpecFlowException("Invalid hook attribute: " + hookAttribute);
}
return(hookType.Value);
}
private bool IsStepDefinitionAttribute(BindingSourceAttribute attribute)
{
//NOTE: the IsAssignableFrom calls below are not the built-in ones from the Type system but custom extension methods.
//The IBindingType based IsAssignableFrom does not support polymorphism if the IBindingType is not IPolymorphicBindingType (e.g. RuntimeBindingType)
//The Visual Studio Extension uses a source code based IBindingType that cannot support IPolymorphicBindingType.
//Please do not remove the checks for the sub-classes.
return
(typeof(GivenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(WhenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(ThenAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(StepDefinitionAttribute).IsAssignableFrom(attribute.AttributeType) ||
typeof(StepDefinitionBaseAttribute).IsAssignableFrom(attribute.AttributeType));
}
private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute hookAttribute, BindingScope scope)
{
HookType hookType = GetHookType(hookAttribute);
if (!ValidateHook(bindingSourceMethod, hookAttribute, hookType))
{
return;
}
var hookBinding = bindingFactory.CreateHookBinding(bindingSourceMethod.BindingMethod, hookType, scope);
ProcessHookBinding(hookBinding);
}
protected virtual bool ValidateHook(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute hookAttribute, HookType hookType)
{
if (!ValidateMethod(bindingSourceMethod))
{
return(false);
}
if (!IsScenarioSpecificHook(hookType) && !bindingSourceMethod.IsStatic &&
OnValidationError("The binding methods for before/after feature and before/after test run events must be static! {0}", bindingSourceMethod))
{
return(false);
}
return(true);
}
private void ProcessStepArgumentTransformationAttribute(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute stepArgumentTransformationAttribute)
{
string regex = stepArgumentTransformationAttribute.TryGetAttributeValue <string>(0) ?? stepArgumentTransformationAttribute.TryGetAttributeValue <string>("Regex");
if (!ValidateStepArgumentTransformation(bindingSourceMethod, stepArgumentTransformationAttribute))
{
return;
}
var stepArgumentTransformationBinding = bindingFactory.CreateStepArgumentTransformation(regex, bindingSourceMethod.BindingMethod);
ProcessStepArgumentTransformationBinding(stepArgumentTransformationBinding);
}
protected override bool ValidateHook(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute hookAttribute, HookType hookType)
{
//TODO: this call will be refactored when binding error detecttion will be improved in v2 - currently implemented here for backwards compatibility
if (!IsScenarioSpecificHook(hookType) &&
!bindingSourceMethod.IsStatic)
{
throw errorProvider.GetNonStaticEventError(bindingSourceMethod.BindingMethod);
}
return(base.ValidateHook(bindingSourceMethod, hookAttribute, hookType));
}
private void ProcessStepDefinitionAttribute(BindingSourceMethod bindingSourceMethod, BindingScope[] methodScopes, BindingSourceAttribute stepDefinitionAttribute)
{
ApplyForScope(methodScopes, scope => ProcessStepDefinitionAttribute(bindingSourceMethod, stepDefinitionAttribute, scope));
}
private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, BindingScope[] methodScopes, BindingSourceAttribute hookAttribute)
{
var scopes = methodScopes.AsEnumerable();
// HACK: Currently on mono to compile we have to pass the optional parameter to TryGetParamsAttributeValue
string[] tags = hookAttribute.TryGetParamsAttributeValue <string>(0, null);
if (tags != null)
{
scopes = scopes.Concat(tags.Select(t => new BindingScope(t, null, null)));
}
ApplyForScope(scopes.ToArray(), scope => ProcessHookAttribute(bindingSourceMethod, hookAttribute, scope));
}
private void ProcessStepDefinitionAttribute(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute stepDefinitionAttribute, BindingScope scope)
{
var stepDefinitionTypes = GetStepDefinitionTypes(stepDefinitionAttribute);
string regex = stepDefinitionAttribute.TryGetAttributeValue <string>(0);
if (!ValidateStepDefinition(bindingSourceMethod, stepDefinitionAttribute))
{
return;
}
foreach (var stepDefinitionType in stepDefinitionTypes)
{
var stepDefinitionBinding = bindingFactory.CreateStepBinding(stepDefinitionType, regex, bindingSourceMethod.BindingMethod, scope);
ProcessStepDefinitionBinding(stepDefinitionBinding);
}
}
protected virtual bool ValidateStepDefinition(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute stepDefinitionAttribute)
{
if (!ValidateMethod(bindingSourceMethod))
{
return(false);
}
return(true);
}
private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, BindingScope[] methodScopes, BindingSourceAttribute hookAttribute)
{
var scopes = methodScopes.AsEnumerable();
string[] tags = GetTagsDefinedOnBindingAttribute(hookAttribute);
if (tags != null)
{
scopes = scopes.Concat(tags.Select(t => new BindingScope(t, null, null)));
}
ApplyForScope(scopes.ToArray(), scope => ProcessHookAttribute(bindingSourceMethod, hookAttribute, scope));
}
protected virtual bool ValidateStepArgumentTransformation(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute stepArgumentTransformationAttribute)
{
if (!ValidateMethod(bindingSourceMethod))
{
return(false);
}
return(true);
}
private static string[] GetTagsDefinedOnBindingAttribute(BindingSourceAttribute hookAttribute)
{
return(TagsFromConstructor(hookAttribute));
}
private static string[] TagsFromConstructor(BindingSourceAttribute hookAttribute)
{
// HACK: Currently on mono to compile we have to pass the optional parameter to TryGetParamsAttributeValue
return(hookAttribute.TryGetParamsAttributeValue <string>(0, null));
}
private int GetHookOrder(BindingSourceAttribute hookAttribute)
{
return(hookAttribute.TryGetAttributeValue("Order", 10000));
}
private bool IsStepArgumentTransformationAttribute(BindingSourceAttribute attribute)
{
return(attribute.AttributeType.TypeEquals(typeof(StepArgumentTransformationAttribute)));
}
private IEnumerable <StepDefinitionType> GetStepDefinitionTypes(BindingSourceAttribute stepDefinitionAttribute)
{
return(stepDefinitionAttribute.NamedAttributeValues["Types"].GetValue <IEnumerable <StepDefinitionType> >());
}
