internal void AddKnownCombination( ScenarioCombinationType combinationType, ScenarioKey scenarioKey) { var knownCombination = new KnownCombination(combinationType, scenarioKey); this.AddKnownCombination(knownCombination); }
internal KnownCombination( ScenarioCombinationType combinationType, params ScenarioKey[] scenariosKeys) { this.CombinationType = combinationType; this.CombinationKey = string.Concat(scenariosKeys.Select(kv => kv.KeyValue)); this.ScenariosKeys = new List <ScenarioKey>(scenariosKeys); }
/// <summary> /// Add a Known Valid Scenario Combination to the <see cref="IScenariosBuilder{T}" /> /// </summary> /// <param name="scenarioCombinationConfiguration"> /// A dictionary with the builder parameters that can used to build an <see cref="ScenarioCombinationType.AlwaysValid"/> model. /// Key: Scenario Context Name /// Value: Scenario Name /// </param> /// <param name="scenarioCombinationType"> /// Indicates if the Current Scenario will be <see cref="ScenarioCombinationType.Unknown"/>, <see cref="ScenarioCombinationType.AlwaysValid"/> or <see cref="ScenarioCombinationType.AlwaysInvalid"/> /// </param> /// <returns>Returns the current instance of the <see cref="IScenariosBuilder{T}" /> (fluent interface)</returns> public IScenariosBuilder <T> KnownScenarioCombination( IDictionary <string, string> scenarioCombinationConfiguration, ScenarioCombinationType scenarioCombinationType = ScenarioCombinationType.Unknown) { this.scenarioContexts.AddKnownCombination( scenarioCombinationType, scenarioCombinationConfiguration); return(this); }
/// <summary> /// Add a new Invalid Scenario to the current Default Scenario Context /// </summary> /// <param name="action">The actions that will be executed to the Invalid Scenario</param> /// <param name="scenarioType"> /// Indicates if the Current Scenario will be <see cref="ScenarioCombinationType.Unknown"/>, <see cref="ScenarioCombinationType.AlwaysValid"/> or <see cref="ScenarioCombinationType.AlwaysInvalid"/> /// </param> /// <returns>Returns the current instance of the <see cref="IScenariosBuilder{T}" /> (fluent interface)</returns> public IScenariosBuilder <T> DefaultContextInvalidScenario( Action <IScenarioRuleSet <T> > action, ScenarioCombinationType scenarioType = ScenarioCombinationType.Unknown) { return(this.Scenario( true, Defaults.ScenarioInvalidName, scenarioType, action)); }
internal void AddKnownCombination( ScenarioCombinationType combinationType, IDictionary <string, string> scenarioCombinationConfiguration) { var knownCombination = this.ValidateKnownCombinationConfiguration( combinationType, scenarioCombinationConfiguration); this.AddKnownCombination(knownCombination); }
/// <summary> /// Add a new Scenario to the current Scenario Context /// </summary> /// <param name="scenarioName">Indicates the name of the Scenario</param> /// <param name="action">The actions that will be executed to the current Scenario</param> /// <param name="scenarioType"> /// Indicates if the Current Scenario will be <see cref="ScenarioCombinationType.Unknown"/>, <see cref="ScenarioCombinationType.AlwaysValid"/> or <see cref="ScenarioCombinationType.AlwaysInvalid"/> /// </param> /// <returns>Returns the current instance of the <see cref="IScenariosBuilder{T}" /> (fluent interface)</returns> public IScenariosBuilder <T> Scenario( string scenarioName, Action <IScenarioRuleSet <T> > action, ScenarioCombinationType scenarioType = ScenarioCombinationType.Unknown) { return(this.Scenario( false, scenarioName, scenarioType, action)); }
private KnownCombination ValidateKnownCombinationConfiguration( ScenarioCombinationType combinationType, IDictionary <string, string> scenarioCombinationConfiguration) { this.ValidateKnownCombinationConfigurationBuilder( scenarioCombinationConfiguration); this.ValidateScenarioCombinationConfigurationKeys( scenarioCombinationConfiguration); this.CurrentScenarioContext.ValidateContextCompleted(); return(this.ValidateKnownCombinationConfigurationBuilderValues( combinationType, scenarioCombinationConfiguration)); }
private KnownCombination ValidateKnownCombinationConfigurationBuilderValues( ScenarioCombinationType scenarioCombinationType, IDictionary <string, string> scenarioCombinationConfiguration) { var scenariosKeys = new List <ScenarioKey>(); var parentGroupsRegex = string.Empty; var childrenGroupsRegex = string.Empty; this.ValidateScenarioCombinationConfigurationValues( scenarioCombinationConfiguration, (builderScenarioKey) => { scenariosKeys.Add(builderScenarioKey); parentGroupsRegex += Keys.GetScenarioContextKeyValueRegexValue( builderScenarioKey.ContextIndex, builderScenarioKey.ScenarioName); childrenGroupsRegex += Keys.GetScenarioContextKeyValueRegexValue( builderScenarioKey.ContextIndex, builderScenarioKey.ScenarioName, false); }, (index) => { childrenGroupsRegex += Keys.GetScenarioContextKeyValueRegexValue( index); }); var knownCombination = new KnownCombination( scenarioCombinationType, scenariosKeys.ToArray()); this.ValidateParentKnownScenarioCombinationConfiguration( knownCombination.CombinationKey, parentGroupsRegex); if (scenarioCombinationType != ScenarioCombinationType.Unknown) { this.ValidateChildrenKnownScenarioCombinationConfiguration( childrenGroupsRegex); } return(knownCombination); }
/// <summary> /// Add a new Scenario to the current Scenario Context /// </summary> /// <param name="hasDefaultScenarioContext">Indicates if the method was called by a Default Scenario Context (true) or a Custom Scenario Context (false)</param> /// <param name="scenarioName">Indicates the name of the Scenario</param> /// <param name="scenarioType"> /// Indicates if the Current Scenario will be <see cref="ScenarioCombinationType.Unknown"/>, <see cref="ScenarioCombinationType.AlwaysValid"/> or <see cref="ScenarioCombinationType.AlwaysInvalid"/> /// </param> /// <param name="action">The actions that will be executed to the current Scenario</param> /// <returns>Returns the current instance of the <see cref="IScenariosBuilder{T}" /> (fluent interface)</returns> private ScenariosFaker <T> Scenario( bool hasDefaultScenarioContext, string scenarioName, ScenarioCombinationType scenarioType, Action <IScenarioRuleSet <T> > action) { this.ValidateAction(action); var scenarioKey = this.scenarioContexts.AddScenario( hasDefaultScenarioContext, scenarioName, scenarioType); this.scenariosActions.Add(scenarioKey.KeyValue, action); this.scenarioContexts.AddKnownCombination( scenarioType, scenarioKey); return(this); }
/// <summary> /// Validate the Scenario and returns the Scenario Key /// </summary> /// <param name="hasDefaultScenarioContext"> /// Flag that indicates if the method was called by a Default Scenario Context method (true) /// or a Custom Scenario Context method (false) /// </param> /// <param name="scenarioName">Indicates the name of the Scenario</param> /// <param name="scenarioType"> /// Indicates if the Current Scenario will be <see cref="ScenarioCombinationType.Unknown"/>, <see cref="ScenarioCombinationType.AlwaysValid"/> or <see cref="ScenarioCombinationType.AlwaysInvalid"/> /// </param> /// <returns>The Scenario Key</returns> internal ScenarioKey AddScenario( bool hasDefaultScenarioContext, string scenarioName, ScenarioCombinationType scenarioType) { var scenarioKey = this.CurrentScenarioContext.AddScenario( hasDefaultScenarioContext, scenarioName, scenarioType); if (this.CurrentScenarioContext.ScenariosCount > 1) { if (this.CurrentScenarioContext.ScenariosCount > 2) { this.CountPossibleScenariosCombinations /= (ulong)(this.CurrentScenarioContext.ScenariosCount - 1); } this.CountPossibleScenariosCombinations *= (ulong)this.CurrentScenarioContext.ScenariosCount; } return(scenarioKey); }