public IStepDefinitionBinding CreateStepBinding(StepDefinitionType type, string regexString,
IBindingMethod bindingMethod, BindingScope bindingScope)
{
if (regexString == null)
regexString = stepDefinitionRegexCalculator.CalculateRegexFromMethod(type, bindingMethod);
return new StepDefinitionBinding(type, regexString, bindingMethod, bindingScope);
}
public StepInfo(StepDefinitionType stepDefinitionType, string text, Table table, string multilineText)
{
StepDefinitionType = stepDefinitionType;
Text = text;
Table = table;
MultilineText = multilineText;
}
public void RunAction(string action, StepDefinitionType stepDefinitionType)
{
switch (stepDefinitionType)
{
case StepDefinitionType.Given:
{
_runner.Given(action);
}
break;
case StepDefinitionType.When:
{
_runner.When(action);
}
break;
case StepDefinitionType.Then:
{
_runner.Then(action);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null);
}
}
public StepDefinitionBinding(StepDefinitionType stepDefinitionType, Regex regex, IBindingMethod bindingMethod, BindingScope bindingScope)
: base(bindingMethod)
{
StepDefinitionType = stepDefinitionType;
Regex = regex;
BindingScope = bindingScope;
}
public StepDefinitionBinding(StepDefinitionType stepDefinitionType, Regex regex, IBindingMethod bindingMethod, BindingScope bindingScope)
: base(bindingMethod)
{
StepDefinitionType = stepDefinitionType;
Regex = regex;
BindingScope = bindingScope;
}
public string CalculateRegexFromMethod(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod)
{
// if method name seems to contain regex, we use it as-is
if (nonIdentifierRe.Match(bindingMethod.Name).Success)
{
return(bindingMethod.Name);
}
string stepText = bindingMethod.Name;
stepText = RemoveStepPrefix(stepDefinitionType, stepText);
var parameters = bindingMethod.Parameters.ToArray();
int processedPosition = 0;
var reBuilder = new StringBuilder("(?i)");
foreach (var paramPosition in parameters.Select((p, i) => CalculateParamPosition(stepText, p, i)).Where(pp => pp.Position >= 0).OrderBy(pp => pp.Position))
{
if (paramPosition.Position < processedPosition)
{
continue; //this is an error case -> overlapping parameters
}
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, paramPosition.Position - processedPosition)));
reBuilder.Append(CalculateParamRegex(parameters[paramPosition.ParamIndex]));
processedPosition = paramPosition.Position + paramPosition.Lenght;
}
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, stepText.Length - processedPosition)));
reBuilder.Append(@"\W*");
return(reBuilder.ToString());
}
public StepInfo(StepDefinitionType stepDefinitionType, string text, Table table, string multilineText)
{
StepDefinitionType = stepDefinitionType;
Text = text;
Table = table;
MultilineText = multilineText;
}
public string CalculateRegexFromMethod(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod)
{
// if method name seems to contain regex, we use it as-is
if (nonIdentifierRe.Match(bindingMethod.Name).Success)
{
return bindingMethod.Name;
}
string stepText = bindingMethod.Name;
stepText = RemoveStepPrefix(stepDefinitionType, stepText);
var parameters = bindingMethod.Parameters.ToArray();
int processedPosition = 0;
var reBuilder = new StringBuilder("(?i)");
foreach (var paramPosition in parameters.Select((p, i) => CalculateParamPosition(stepText, p, i)).Where(pp => pp.Position >= 0).OrderBy(pp => pp.Position))
{
if (paramPosition.Position < processedPosition)
continue; //this is an error case -> overlapping parameters
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, paramPosition.Position - processedPosition)));
reBuilder.Append(CalculateParamRegex(parameters[paramPosition.ParamIndex]));
processedPosition = paramPosition.Position + paramPosition.Length;
}
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, stepText.Length - processedPosition)));
reBuilder.Append(@"\W*");
return reBuilder.ToString();
}
public StepDefinition(StepDefinitionType type, string text, Table table, string multilineText)
{
Type = type;
Text = text;
Table = table;
MultilineText = multilineText;
}
private void GetCompletionsForBindingType(StepDefinitionType stepDefinitionType, out IEnumerable <Completion> completions, out string statusText)
{
statusText = null;
var suggestionProvider = languageService.ProjectScope.StepSuggestionProvider;
if (suggestionProvider == null)
{
completions = Enumerable.Empty <Completion>();
return;
}
if (!suggestionProvider.Populated)
{
string percentText = string.Format("({0}% completed)", suggestionProvider.GetPopulationPercent());
statusText = (!suggestionProvider.BindingsPopulated ? "step suggestion list is being populated... " : "step suggestion list from existing feature files is being populated... ") + percentText;
}
try
{
completions = suggestionProvider.GetNativeSuggestionItems(stepDefinitionType);
}
catch (Exception)
{
//fallback case
completions = Enumerable.Empty <Completion>();
}
}
public BoundStepSuggestions(StepDefinitionType stepDefinitionType, INativeSuggestionItemFactory <TNativeSuggestionItem> nativeSuggestionItemFactory)
{
StepBinding = null;
StepDefinitionType = stepDefinitionType;
NativeSuggestionItem = nativeSuggestionItemFactory.Create("[unbound steps]", "...", 0, "nb", this);
suggestions = new StepSuggestionList <TNativeSuggestionItem>(nativeSuggestionItemFactory);
}
public IStepDefinitionBinding CreateStepBinding(StepDefinitionType type, string regexString, IBindingMethod bindingMethod, BindingScope bindingScope)
{
if (regexString == null)
{
regexString = stepDefinitionRegexCalculator.CalculateRegexFromMethod(type, bindingMethod);
}
return(new StepDefinitionBinding(type, regexString, bindingMethod, bindingScope));
}
public void Step(StepDefinitionKeyword stepDefinitionKeyword, string keyword, string text, string multilineTextArg, Table tableArg)
{
StepDefinitionType stepDefinitionType = (stepDefinitionKeyword == StepDefinitionKeyword.And || stepDefinitionKeyword == StepDefinitionKeyword.But)
? GetCurrentBindingType()
: (StepDefinitionType)stepDefinitionKeyword;
ExecuteStep(new StepInstance(stepDefinitionType, stepDefinitionKeyword, keyword, text, multilineTextArg, tableArg, contextManager.GetStepContext()));
}
public StepDefinition(StepDefinitionType type, StepDefinitionKeyword stepDefinitionKeyword, string text, Table table, string multilineText, string keyword)
{
Type = type;
Text = text;
Table = table;
MultilineText = multilineText;
Action = e => e.Step(stepDefinitionKeyword, keyword, text, multilineText, table);
}
protected LateBoundStepDefinitionBindingWithSource(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod, BindingScope bindingScope, string sourceExpression, Lazy <Tuple <Regex, string> > regexProvider)
: base(bindingMethod)
{
_regexProvider = regexProvider;
StepDefinitionType = stepDefinitionType;
BindingScope = bindingScope;
SourceExpression = sourceExpression;
}
protected StepDefinitionBaseAttribute(string regex, StepDefinitionType[] types)
{
if (types == null) throw new ArgumentNullException("types");
if (types.Length == 0) throw new ArgumentException("List cannot be empty", "types");
Regex = regex;
Types = types;
}
private void RegisterStepBindings <T>(Type type, StepDefinitionType stepDefinitionType)
where T : StepDefinitionBaseAttribute
{
foreach (var(method, attribute) in GetTypeMethods <T>(type))
{
var binding = bindingFactory.CreateStepBinding(
stepDefinitionType, attribute.Regex, new RuntimeBindingMethod(method), null);
bindingRegistry.RegisterStepDefinitionBinding(binding);
}
}
public StepInstance Step(StepDefinitionKeyword stepDefinitionKeyword, string keyword, string text, string multilineTextArg, Table tableArg)
{
StepDefinitionType stepDefinitionType = (stepDefinitionKeyword == StepDefinitionKeyword.And || stepDefinitionKeyword == StepDefinitionKeyword.But)
? GetCurrentBindingType()
: (StepDefinitionType)stepDefinitionKeyword;
return(new StepInstance(stepDefinitionType, stepDefinitionKeyword, keyword, text, multilineTextArg, tableArg, new StepContext(
new FeatureInfo(new CultureInfo("en-GB"), text, "description", ProgrammingLanguage.CSharp, new string[0]),
new ScenarioInfo("title", new string[0]))));
}
public StepInstance(StepDefinitionType type, StepDefinitionKeyword stepDefinitionKeyword, string keyword, string text, string multilineTextArgument, Table tableArgument, StepContext stepContext)
{
StepDefinitionType = type;
StepDefinitionKeyword = stepDefinitionKeyword;
Text = text;
MultilineTextArgument = multilineTextArgument;
TableArgument = tableArgument;
StepContext = stepContext;
Keyword = keyword;
}
public StepInstance(StepDefinitionType type, StepDefinitionKeyword stepDefinitionKeyword, string keyword, string text, string multilineTextArgument, Table tableArgument, StepContext stepContext)
{
StepDefinitionType = type;
StepDefinitionKeyword = stepDefinitionKeyword;
Text = text;
MultilineTextArgument = multilineTextArgument;
TableArgument = tableArgument;
StepContext = stepContext;
Keyword = keyword;
}
private ExtentTest CreateScenario(StepDefinitionType stepDefinitionType)
{
var stepText = scenarioContext.StepContext.StepInfo.Text;
return(stepDefinitionType switch
{
StepDefinitionType.Given => scenario.CreateNode <Given>(stepText),
StepDefinitionType.Then => scenario.CreateNode <Then>(stepText),
StepDefinitionType.When => scenario.CreateNode <When>(stepText),
_ => throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null),
});
// aqui é um método para criar um Scenario passando o tipo de Step
private static ExtentTest CreateScenario(ExtentTest extent, StepDefinitionType stepDefinitionType, ScenarioContext scenarioContext)
{
// o SpecFlow nos permite pegar o nome do Step usando o ScenarioStepContext.Current
var scenarioStepContext = scenarioContext.StepContext.StepInfo.Text;
return(stepDefinitionType switch
{
StepDefinitionType.Given => extent.CreateNode <Given>(scenarioStepContext), // cria o nodo para Given
StepDefinitionType.Then => extent.CreateNode <Then>(scenarioStepContext), // cria o nodo para Then
StepDefinitionType.When => extent.CreateNode <When>(scenarioStepContext), // cria o nodo para When
_ => throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null),
});
private string RemoveStepPrefix(StepDefinitionType stepDefinitionType, string stepText)
{
var prefixesToRemove = GetPrefixesToRemove(stepDefinitionType);
foreach (var prefixToRemove in prefixesToRemove)
{
if (stepText.StartsWith(prefixToRemove, StringComparison.CurrentCultureIgnoreCase))
{
stepText = stepText.Substring(prefixToRemove.Length).TrimStart('_', ' ');
break; // we only stip one prefix
}
}
return stepText;
}
private static void CreateScenarioFailOrError(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
var error = ScenarioContext.Current.TestError;
if (error.InnerException == null)
{
CreateScenario(extent, stepDefinitionType).Error(error.Message);
}
else
{
CreateScenario(extent, stepDefinitionType).Fail(error.InnerException);
}
}
private string RemoveStepPrefix(StepDefinitionType stepDefinitionType, string stepText)
{
var prefixesToRemove = GetPrefixesToRemove(stepDefinitionType);
foreach (var prefixToRemove in prefixesToRemove)
{
if (stepText.StartsWith(prefixToRemove, StringComparison.CurrentCultureIgnoreCase))
{
stepText = stepText.Substring(prefixToRemove.Length).TrimStart('_', ' ');
break; // we only stip one prefix
}
}
return(stepText);
}
public BoundStepSuggestions(IStepDefinitionBinding stepBinding, INativeSuggestionItemFactory <TNativeSuggestionItem> nativeSuggestionItemFactory)
{
if (stepBinding == null)
{
throw new ArgumentNullException("stepBinding");
}
StepBinding = stepBinding;
StepDefinitionType = stepBinding.StepDefinitionType;
string suggestionText = GetSuggestionText(stepBinding);
NativeSuggestionItem = nativeSuggestionItemFactory.Create(suggestionText, GetInsertionText(StepBinding), 0, StepDefinitionType.ToString().Substring(0, 1) + "-b", this);
suggestions = new StepSuggestionList <TNativeSuggestionItem>(nativeSuggestionItemFactory);
}
// aqui temos um método para criar um novo de falha ou erro
private static void CreateScenarioFailOrError(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
var error = ScenarioContext.Current.TestError;
// se não existir exception então pega a mensagem de erro do ScenarioContext.Current
if (error.InnerException == null)
{
CreateScenario(extent, stepDefinitionType).Error(error.Message);
}
else
{
// senão cria uma falha passando a exception
CreateScenario(extent, stepDefinitionType).Fail(error.InnerException);
}
}
private Tuple <Regex, string> CreateStepBindingRegex(StepDefinitionType type, string expressionSource, IBindingMethod bindingMethod)
{
try
{
var expression = _definitionMatchExpressionConverter.CreateExpression(expressionSource, type, bindingMethod);
return(new Tuple <Regex, string>(expression.GetRegex(), null));
}
catch (Exception ex)
{
if (Assembly.GetEntryAssembly()?.FullName.StartsWith("deveroom") ?? false)
{
return(new Tuple <Regex, string>(null, ex.Message));
}
throw new CucumberExpressionException($"error: '{expressionSource}': {ex.Message}");
}
}
// Here is a method to create a new one for failure or error
private static void CreateScenarioFailOrError(ExtentTest extent, StepDefinitionType stepDefinitionType, String pathScreenshot)
{
var scenarioStepContext = ScenarioStepContext.Current.StepInfo.Text;
var error = ScenarioContext.Current.TestError;
// If there is no exception then get the error message from ScenarioContext.Current
if (error.InnerException == null)
{
CreateScenario(extent, stepDefinitionType).Error(error.Message).AddScreenCaptureFromPath(pathScreenshot, scenarioStepContext);
}
else
{
// Otherwise creates a failure passing the exception
CreateScenario(extent, stepDefinitionType).Fail(error.InnerException).AddScreenCaptureFromPath(pathScreenshot, scenarioStepContext);
}
}
private void AddStepSuggestionToMatchingItems(StepDefinitionType stepDefinitionType, IEnumerable <BoundStepSuggestions <TNativeSuggestionItem> > matchingItems,
Action <BoundStepSuggestions <TNativeSuggestionItem> > addAction)
{
bool wasMatching = false;
foreach (var item in matchingItems)
{
addAction(item);
wasMatching = true;
}
if (!wasMatching)
{
addAction(notMatchingSteps[stepDefinitionType]);
}
}
private static void CreateScenarioFailOrError(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
var error = ScenarioContext.Current.TestError;
if (error.InnerException == null)
{
_step = CreateScenario(extent, stepDefinitionType).Error(error.Message);
}
else
{
_step = CreateScenario(extent, stepDefinitionType).Fail(error.InnerException);
}
_screenshotPath = TestBase.MakeScreenshotAfterStep();
_step.AddScreenCaptureFromPath(_screenshotPath);
}
public void WhenIListMySkillForTrade(string skillTitle)
{
StepDefinitionType stepDefinitionType = _context.StepContext.StepInfo.StepDefinitionType;
ExcelData data = ExcelDataReaderUtil.FetchRowUsingKey(skillTitle);
var shareSkill = ObjectFactory.CreateInstance <ShareSkill>(data);
_context.Set(shareSkill, skillTitle);
// assumption that title is considered unique (even though it seems to have an internal ID that is not visible on page)
if (stepDefinitionType == StepDefinitionType.When)
{
SkillSharePage.EnterShareSkill(shareSkill);
}
// retrieve ID
shareSkill.Id = _helper.GetOrAdd(shareSkill);
TestHelper.GetListOfObjectsToBeRemoved(_context).Add(shareSkill);
}
public virtual void Step(StepDefinitionKeyword stepDefinitionKeyword, string keyword, string text, string multilineTextArg, Table tableArg)
{
StepDefinitionType stepDefinitionType = stepDefinitionKeyword == StepDefinitionKeyword.And || stepDefinitionKeyword == StepDefinitionKeyword.But
? GetCurrentBindingType()
: (StepDefinitionType)stepDefinitionKeyword;
_contextManager.InitializeStepContext(new StepInfo(stepDefinitionType, text, tableArg, multilineTextArg));
try
{
var stepInstance = new StepInstance(stepDefinitionType, stepDefinitionKeyword, keyword, text, multilineTextArg, tableArg, _contextManager.GetStepContext());
ExecuteStep(_contextManager, stepInstance);
}
finally
{
_contextManager.CleanupStepContext();
}
}
private static ExtentTest CreateScenario(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
var scenarioStepContext = ScenarioStepContext.Current.StepInfo.Text;
switch (stepDefinitionType)
{
case StepDefinitionType.Given:
return(extent.CreateNode <Given>(scenarioStepContext));
case StepDefinitionType.Then:
return(extent.CreateNode <Then>(scenarioStepContext));
case StepDefinitionType.When:
return(extent.CreateNode <When>(scenarioStepContext));
default:
throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null);
}
}
private IEnumerable<string> GetPrefixesToRemove(StepDefinitionType stepDefinitionType)
{
yield return stepDefinitionType.ToString();
var cultureToSearch = runtimeConfiguration.BindingCulture ?? runtimeConfiguration.FeatureLanguage;
foreach (var keyword in LanguageHelper.GetKeywords(cultureToSearch, stepDefinitionType))
{
if (keyword.Contains(' '))
{
yield return keyword.Replace(" ", "_");
yield return keyword.Replace(" ", "");
}
else
{
yield return keyword;
}
}
}
// Here is a method to create a Scenario passing the type of Step
private static ExtentTest CreateScenario(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
// SpecFlow allows us to get the name of the Step using ScenarioStepContext.Current
var scenarioStepContext = ScenarioStepContext.Current.StepInfo.Text;
switch (stepDefinitionType)
{
case StepDefinitionType.Given:
return extent.CreateNode<Given>(scenarioStepContext); // Rebuild the node for Given
case StepDefinitionType.Then:
return extent.CreateNode<Then>(scenarioStepContext); // Rebuild the node for Then
case StepDefinitionType.When:
return extent.CreateNode<When>(scenarioStepContext); // Rebuild the node for When
default:
throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null);
}
}
private IEnumerable <string> GetPrefixesToRemove(StepDefinitionType stepDefinitionType)
{
yield return(stepDefinitionType.ToString());
var cultureToSearch = runtimeConfiguration.BindingCulture ?? runtimeConfiguration.FeatureLanguage;
foreach (var keyword in LanguageHelper.GetKeywords(cultureToSearch, stepDefinitionType))
{
if (keyword.Contains(' '))
{
yield return(keyword.Replace(" ", "_"));
yield return(keyword.Replace(" ", ""));
}
else
{
yield return(keyword);
}
}
}
private static ExtentTest CreateScenario(ExtentTest extent, StepDefinitionType stepDefinitionType)
{
var stepInfo = ScenarioStepContext.Current.StepInfo;
var scenarioStepContext = GetStepInfoFormattedText(stepInfo);
switch (stepDefinitionType)
{
case StepDefinitionType.Given:
return(extent.CreateNode <Given>(scenarioStepContext)); // cria o node para Given
case StepDefinitionType.Then:
return(extent.CreateNode <Then>(scenarioStepContext)); // cria o node para Then
case StepDefinitionType.When:
return(extent.CreateNode <When>(scenarioStepContext)); // cria o node para When
default:
throw new ArgumentOutOfRangeException(nameof(stepDefinitionType), stepDefinitionType, null);
}
}
internal StepDefinitionBaseAttribute(string regex, StepDefinitionType type)
: this(regex, new[] { type })
{
}
public StepInstance(StepDefinitionType stepDefinitionType, StepDefinitionKeyword stepDefinitionKeyword, string keywordWithTrailingSpaces, string text, StepContext stepContext)
: this(stepDefinitionType, stepDefinitionKeyword, keywordWithTrailingSpaces, text, null, null, stepContext)
{
}
public static bool Equals(this ScenarioBlock block, StepDefinitionType stepDefinitionType)
{
return (int)block == (int)stepDefinitionType;
}
private void GetCompletionsForBindingType(StepDefinitionType stepDefinitionType, out IEnumerable<Completion> completions, out string statusText)
{
statusText = null;
var suggestionProvider = languageService.ProjectScope.StepSuggestionProvider;
if (suggestionProvider == null)
{
completions = Enumerable.Empty<Completion>();
return;
}
if (!suggestionProvider.Populated)
{
string percentText = string.Format("({0}% completed)", suggestionProvider.GetPopulationPercent());
statusText = (!suggestionProvider.BindingsPopulated ? "step suggestion list is being populated... " : "step suggestion list from existing feature files is being populated... ") + percentText;
}
try
{
completions = suggestionProvider.GetNativeSuggestionItems(stepDefinitionType);
}
catch(Exception)
{
//fallback case
completions = Enumerable.Empty<Completion>();
}
}
public GherkinStep(StepDefinitionType stepDefinitionType, StepDefinitionKeyword stepDefinitionKeyword, string stepText, StepContext stepContext, string keyword, int blockRelativeLine)
: base(stepDefinitionType, stepDefinitionKeyword, keyword, stepText, stepContext)
{
BlockRelativeLine = blockRelativeLine;
BindingStatus = BindingStatus.UnknownBindingStatus;
}
/// <summary>
/// Creates a <see cref="StepInfo" /> instance, with the specified text and optional step definition type.
/// </summary>
/// <param name="text">The text of the step.</param>
/// <param name="stepDefinitionType">The type of the step definition. Default value is StepDefinitionType.Given</param>
/// <returns>A new instance of the <see cref="StepInfo"/> class.</returns>
private StepInfo CreateStepInfo(string text, StepDefinitionType stepDefinitionType = StepDefinitionType.Given)
{
return new StepInfo(stepDefinitionType, text, null, string.Empty);
}
private StepDefinitionBinding GetBingingFromAttribute(CodeAttribute2 codeAttribute, CodeFunction codeFunction, StepDefinitionType stepDefinitionType, BindingScope bindingScope)
{
try
{
if (codeAttribute.FullName.Equals(string.Format("TechTalk.SpecFlow.{0}Attribute", stepDefinitionType)))
return CreateStepBinding(codeAttribute, codeFunction, stepDefinitionType, bindingScope);
return null;
}
catch(Exception)
{
return null;
}
}
public StepDefinitionBinding(StepDefinitionType stepDefinitionType, string regexString, IBindingMethod bindingMethod, BindingScope bindingScope)
: this(stepDefinitionType, RegexFactory.Create(regexString), bindingMethod, bindingScope)
{
}
public IEnumerable<IStepDefinitionBinding> GetConsideredStepDefinitions(StepDefinitionType stepDefinitionType, string stepText)
{
//TODO: later optimize to return step definitions that has a chance to match to stepText
return stepDefinitions.Where(sd => sd.StepDefinitionType == stepDefinitionType);
}
private StepDefinitionBinding CreateStepBinding(CodeAttribute2 attr, CodeFunction codeFunction, StepDefinitionType stepDefinitionType, BindingScope bindingScope)
{
try
{
IBindingMethod bindingMethod = bindingReflectionFactory.CreateBindingMethod(codeFunction);
var regexArg = attr.Arguments.Cast<CodeAttributeArgument>().FirstOrDefault();
if (regexArg == null)
return null;
var regexString = VsxHelper.ParseCodeStringValue(regexArg.Value, regexArg.Language);
return new StepDefinitionBinding(stepDefinitionType, regexString, bindingMethod, bindingScope);
}
catch(Exception)
{
return null;
}
}
public StepInfo(StepDefinitionType stepDefinitionType, string text)
{
this.StepDefinitionType = stepDefinitionType;
this.Text = text;
}
