protected override Faker <T> AddRule(string propertyOrField, Func <Faker, T, object> invoker)
{
if (initialRules is null)
{
base.AddRule(propertyOrField, invoker);
return(this);
}
var rule = new PopulateAction <T>
{
Action = invoker,
RuleSet = currentRuleSet,
PropertyName = propertyOrField,
};
if (reorderActions.TryGetValue(currentRuleSet, out var currentActions) &&
currentActions.Contains(propertyOrField))
{
currentActions.Remove(propertyOrField);
}
AddOrderedRule(reorderActions, currentRuleSet, propertyOrField, rule);
return(this);
}
private void PopulateProperty(T instance, PopulateAction <T> action)
{
var valueFactory = action.Action;
if (valueFactory is null)
{
return; // An .Ignore() rule.
}
var value = valueFactory(FakerHub, instance);
if (SetterCache.TryGetValue(action.PropertyName, out var setter))
{
setter(instance, value);
return;
}
if (!TypeProperties.TryGetValue(action.PropertyName, out var member))
{
return;
}
if (member == null)
{
return; // Member would be null if this was a .Rules()
}
// The valueFactory is already invoked
// which does not select a property or field.
lock (_setterCreateLock)
{
if (SetterCache.TryGetValue(action.PropertyName, out setter))
{
setter(instance, value);
return;
}
if (member is PropertyInfo prop)
{
setter = prop.CreateSetter <T>();
}
// TODO FieldInfo will need to rely on ILEmit to create a delegate
else if (member is FieldInfo field)
{
setter = (i, v) => field?.SetValue(i, v);
}
if (setter == null)
{
return;
}
SetterCache.Add(action.PropertyName, setter);
setter(instance, value);
}
}
protected virtual Faker <T> AddRule(string propertyOrField, Func <Faker, T, object> invoker)
{
var rule = new PopulateAction <T>
{
Action = invoker,
RuleSet = currentRuleSet,
PropertyName = propertyOrField,
};
this.Actions.Add(currentRuleSet, propertyOrField, rule);
return(this);
}
protected virtual RowGeneratorOptions <T> AddRule(string propertyOrField, Func <RowGenerator <T>, T, object> invoker)
{
Check.NotNull(propertyOrField, nameof(propertyOrField));
var rule = new PopulateAction <RowGenerator <T>, T>
{
Action = invoker,
PropertyName = propertyOrField,
};
this.Actions[propertyOrField] = rule;
return(this);
}
private Faker <T> RuleFor <TProperty>(string propertyOrField, Func <Faker, TProperty> setter)
{
Func <Faker, T, object> invoker = (f, t) => setter(f);
var rule = new PopulateAction <T>
{
Action = invoker,
RuleSet = currentRuleSet,
PropertyName = propertyOrField,
};
this.Actions.Add(currentRuleSet, propertyOrField, rule);
return(this);
}
/// <summary>
/// Creates a rule for a compound property and providing access to the instance being generated.
/// </summary>
public Faker <T> RuleFor <TProperty>(Expression <Func <T, TProperty> > property, Func <Faker, T, TProperty> setter)
{
var propName = PropertyName.For(property);
Func <Faker, T, object> invoker = (f, t) => setter(f, t);
var rule = new PopulateAction <T>
{
Action = invoker,
RuleSet = currentRuleSet,
PropertyName = propName
};
this.Actions.Add(currentRuleSet, propName, rule);
return(this);
}
/// <summary>
/// Gives you a way to specify multiple rules inside an action
/// without having to call RuleFor multiple times. Note: StrictMode
/// must be false since property rules cannot be individually checked.
/// </summary>
public Faker <T> Rules(Action <Faker, T> setActions)
{
Func <Faker, T, object> invoker = (f, t) =>
{
setActions(f, t);
return(null);
};
var guid = Guid.NewGuid().ToString();
var rule = new PopulateAction <T>()
{
Action = invoker,
RuleSet = currentRuleSet,
PropertyName = guid,
ProhibtInStrictMode = true
};
this.Actions.Add(currentRuleSet, guid, rule);
return(this);
}
/// <summary>
/// Ignores a property or field when <seealso cref="StrictMode"/> is enabled.
/// Used in advanced scenarios to ignore hidden properties or fields.
/// </summary>
/// <param name="propertyOrFieldName">The property name or field name of the member to create a rule for.</param>
public virtual Faker <T> Ignore(string propertyOrFieldName)
{
EnsureMemberExists(propertyOrFieldName,
$"The property or field {propertyOrFieldName} was not found on {typeof(T)}. " +
$"Can't ignore member {typeof(T)}.{propertyOrFieldName} when {propertyOrFieldName} " +
$"cannot be found. Try creating a custom IBinder for Faker<T> with the appropriate " +
$"System.Reflection.BindingFlags that allows deeper reflection into {typeof(T)}.");
var rule = new PopulateAction <T>
{
Action = null,
RuleSet = currentRuleSet,
PropertyName = propertyOrFieldName
};
this.Actions.Add(currentRuleSet, propertyOrFieldName, rule);
return(this);
}
/// <summary>
/// Ignores a property or field when <seealso cref="StrictMode"/> is enabled.
/// </summary>
public virtual Faker <T> Ignore <TPropertyOrField>(Expression <Func <T, TPropertyOrField> > propertyOrField)
{
var propNameOrField = PropertyName.For(propertyOrField);
if (!this.TypeProperties.TryGetValue(propNameOrField, out MemberInfo mi))
{
throw new ArgumentException(
$"The property or field {propNameOrField} was not found on {typeof(T)} during the binding discovery of T. Can't ignore something that doesn't exist.");
}
var rule = new PopulateAction <T>
{
Action = null,
RuleSet = currentRuleSet,
PropertyName = propNameOrField
};
this.Actions.Add(currentRuleSet, propNameOrField, rule);
return(this);
}
public static void AddOrderedRule(Dictionary <string, OrderedDictionary> ruleSets, string currentRuleSet, string propertyOrField, PopulateAction <T> populateAction)
{
if (ruleSets.TryGetValue(currentRuleSet, out var currentActions))
{
currentActions.Add(propertyOrField, populateAction);
}
else
{
var newActionSet = new OrderedDictionary
{
{ propertyOrField, populateAction }
};
ruleSets.Add(currentRuleSet, newActionSet);
}
}
