public void Should_AddMemberScope_When_Member()
{
Predicate <string> isValid = c => true;
var args = new[] { Arg.Text("test", "test123") };
MemberSpecification <MemberClass, string> memberSpecification = c => c.Valid(isValid, "message", args);
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Member(m => m.MemberField, memberSpecification)
);
Assert.IsType <MemberScope <MemberClass, string> >(validator.Scopes.Single());
var memberScope = (MemberScope <MemberClass, string>)validator.Scopes.Single();
Assert.Null(memberScope.RuleSingleError);
Assert.Equal("MemberField", memberScope.MemberPropertyInfo.Name);
Assert.Equal(typeof(string), memberScope.MemberPropertyInfo.PropertyType);
Assert.IsType <ValidRule <string> >(memberScope.MemberValidator.Rules.Single());
var memberRule = (ValidRule <string>)memberScope.MemberValidator.Rules.Single();
Assert.Same(isValid, memberRule.IsValid);
Assert.Equal("message", memberRule.Error.Message);
Assert.Same(args, memberRule.Error.Arguments);
Assert.Null(memberRule.RuleSingleError);
}
public void Should_PassModelToPredicate_When_AsRelative(ValidationStrategy validationStrategy)
{
var executed = false;
var model = new object();
MemberSpecification <object, int> memberSpecification = be => be.AsRelative(m =>
{
Assert.Same(model, m);
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
model,
1230,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
public void Should_PassMemberToPredicate_When_Validate(ValidationStrategy validationStrategy)
{
var executed = false;
int?member = 1230;
MemberSpecification <object, int> memberSpecification = be => be.Valid(m =>
{
Assert.Equal(member.Value, m);
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
public void Should_Add_AsCollectionRule_When_AsCollection_And_List()
{
var builder = new MemberSpecificationBuilder <object, List <int> >();
var itemSpecification = new MemberSpecification <object, int>(x => x);
builder.AsCollection(itemSpecification);
AssertCollectionRuleAdded(builder.Commands, itemSpecification);
}
void Verify()
{
var properties = new MemberSpecification <PropertyInfo>(AllowPrivateSetters.Default);
var specification = new MetadataSpecification(properties, DefaultMetadataSpecification.Field);
var extensions = new DefaultExtensions(specification, DeclaredMemberNames.Default, DefaultMemberOrder.Default).ToArray();
var container = new ConfigurationContainer(extensions).Create().ForTesting();
var subject = new PrivateSettablePropertySubject("Hello World!");
container.Cycle(subject).ShouldBeEquivalentTo(subject);
}
void Verify()
{
var properties = new MemberSpecification <PropertyInfo>(AllowPrivateSetters.Default);
var specification = new MetadataSpecification(properties, DefaultMetadataSpecification.Field);
var extensions =
new DefaultExtensions(specification, DeclaredMemberNames.Default, DefaultMemberOrder.Default).ToArray();
var support = new ConfigurationContainer(extensions).ForTesting();
var instance = new Dto();
instance.Names.Add("Hello");
instance.Names.Add("World");
support.Cycle(instance).Should().BeEquivalentTo(instance);
}
public void Should_AddAsNullableRule_When_AsNullable()
{
MemberSpecification <object, int> memberSpecification = c => c;
var validator = MemberValidatorCreator.Create <object, int?>(b => b
.AsNullable(memberSpecification)
);
Assert.IsType <AsNullableRule <object, int> >(validator.Rules.Single());
var asNullableRule = (AsNullableRule <object, int>)validator.Rules.Single();
Assert.Same(memberSpecification, asNullableRule.MemberSpecification);
}
public void Should_AddAsCollectionRule_When_AsCollection()
{
MemberSpecification <object, MemberClass> itemSpecification = c => c;
var validator = MemberValidatorCreator.Create <object, IEnumerable <MemberClass> >(b => b
.AsCollection <object, IEnumerable <MemberClass>, MemberClass>(itemSpecification)
);
Assert.IsType <AsCollectionRule <object, MemberClass> >(validator.Rules.Single());
var validCollectionRule = (AsCollectionRule <object, MemberClass>)validator.Rules.Single();
Assert.Equal(itemSpecification, validCollectionRule.ItemSpecification);
}
public static IMemberValidator Create <TModel, TMember>(MemberSpecification <TModel, TMember> memberSpecification, out IReadOnlyCollection <ICommand> commands)
where TModel : class
{
var builder = new MemberSpecificationBuilder <TModel, TMember>();
var processedBuilder = memberSpecification(builder);
if (!ReferenceEquals(builder, processedBuilder))
{
throw new InvalidProcessedReferenceException(typeof(MemberSpecificationBuilder <TModel, TMember>));
}
commands = (processedBuilder as MemberSpecificationBuilder <TModel, TMember>)?.Commands;
return(ConvertCommands(commands));
}
public void Should_Add_AsNullableRule_When_AsNullable()
{
var builder = new MemberSpecificationBuilder <object, int?>();
var memberSpecification = new MemberSpecification <object, int>(x => x);
builder.AsNullable(memberSpecification);
Assert.Single(builder.Commands);
Assert.IsType <AsNullableRule <object, int> >(builder.Commands.Single());
var command = (AsNullableRule <object, int>)builder.Commands.Single();
Assert.Equal("AsNullable", command.Name);
Assert.Null(command.RuleSingleError);
Assert.Same(memberSpecification, command.MemberSpecification);
}
public void Should_Add_AsCollectionRule_When_AsCollection()
{
var builder = new MemberSpecificationBuilder <object, IEnumerable <int> >();
var itemSpecification = new MemberSpecification <object, int>(x => x);
builder.AsCollection <object, IEnumerable <int>, int>(itemSpecification);
Assert.Single(builder.Commands);
Assert.IsType <AsCollectionRule <object, int> >(builder.Commands.Single());
var command = (AsCollectionRule <object, int>)builder.Commands.Single();
Assert.Equal("AsCollection", command.Name);
Assert.Null(command.RuleSingleError);
Assert.Same(itemSpecification, command.ItemSpecification);
Assert.NotNull(command.ItemSpecification);
}
public static Exception TestMemberRuleException <TMember>(MemberSpecification <object, TMember> specification, Type expectedException)
{
try
{
MemberValidatorCreator.Create(specification);
}
catch (Exception exception)
{
if (!expectedException.IsInstanceOfType(exception))
{
throw new TesterException($"Invalid exception (`{exception.GetType().FullName}`) thrown when `{expectedException.FullName}` was expected");
}
return(exception);
}
throw new TesterException($"No exception thrown when `{expectedException.FullName}` was expected");
}
public RuntimeMember Find(MemberSpecification specification, Func <KeyValuePair <string, Accessor>, bool> filter)
{
foreach (KeyValuePair <string, Accessor> accessor in accessors)
{
if (!filter(accessor))
{
continue;
}
if (specification.IsSetter)
{
return(new SetterMember(accessor.Value));
}
if (specification.IsGetter)
{
return(new GetterMember(accessor.Value));
}
}
throw new ArgumentException(string.Format("Missing member '{0}'", specification));
}
public RuntimeMember Find(MemberSpecification specification)
{
return(columnAccessors.Find(specification, accessor => {
var accessorName = accessor.Key.EndsWith("=")
? accessor.Key.Substring(0, accessor.Key.Length - 1)
: accessor.Key;
if (!specification.MatchesIdentifierName(accessorName))
{
return false;
}
if (currentHeader != null && currentHeader.Text.EndsWith("=") && !accessor.Key.EndsWith("="))
{
return false;
}
if (currentHeader != null && !currentHeader.Text.EndsWith("=") && accessor.Key.EndsWith("="))
{
return false;
}
return true;
}));
}
public void Should_NotExecuteCollect_When_AsRelative_And_NullMember(ValidationStrategy validationStrategy)
{
var executed = false;
MemberSpecification <object, int> memberSpecification = be => be.AsRelative(m =>
{
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
null,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.False(executed);
}
public void Should_NotExecuteCollect_When_Validate_And_Force()
{
var executed = false;
MemberSpecification <object, int> memberSpecification = be => be.Valid(m =>
{
executed = true;
return(true);
}, "message");
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
ValidationStrategy.Force,
out _);
Assert.False(executed);
}
public MemberScope(PropertyInfo memberPropertyInfo, MemberSpecification <TModel, TMember> memberSpecification)
{
MemberPropertyInfo = memberPropertyInfo ?? throw new ArgumentNullException(nameof(memberPropertyInfo));
MemberValidator = MemberValidatorCreator.Create(memberSpecification ?? (m => m));
Name = memberPropertyInfo.Name;
_getErrors = (executableRule, model, executionContext, validationStrategy, depth) =>
{
var memberValue = model != null
? (TMember)executableRule.MemberPropertyInfo.GetValue(model)
: default;
return(ValidatorExecutor.ExecuteMember(
executableRule.MemberValidator,
model,
memberValue,
executionContext,
validationStrategy,
depth
));
};
}
public void Should_Add_AsNullableRule_When_AsNullable_And_AdvancedSpecification()
{
var builder = new MemberSpecificationBuilder <object, int?>();
Predicate <int> innerPredicate = z => true;
var memberSpecification = new MemberSpecification <object, int>(x => x.Valid(innerPredicate).SetSingleError("single_message"));
builder.AsNullable(memberSpecification);
Assert.Single(builder.Commands);
Assert.IsType <AsNullableRule <object, int> >(builder.Commands.Single());
var command = (AsNullableRule <object, int>)builder.Commands.Single();
Assert.Equal("AsNullable", command.Name);
Assert.Null(command.RuleSingleError);
Assert.Same(memberSpecification, command.MemberSpecification);
Assert.NotNull(command.MemberSpecification);
Assert.Equal("single_message", command.MemberValidator.SingleError.Message);
Assert.Same(innerPredicate, ((ValidRule <int>)command.MemberValidator.Rules.Single()).IsValid);
}
public void Should_PassModelAndMemberToPredicate_When_Validate_And_AsRelative_InChain(ValidationStrategy validationStrategy)
{
var validateExecuted = false;
var validateRelationExecuted = false;
int?member = 1230;
var model = new object();
MemberSpecification <object, int> memberSpecification = be => be.Valid(m =>
{
Assert.Equal(member.Value, m);
validateExecuted = true;
return(true);
}, "message")
.AsRelative(m =>
{
Assert.Same(model, m);
validateRelationExecuted = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
model,
member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(validateExecuted);
Assert.True(validateRelationExecuted);
}
public ISpecificationBuilder <TModel> Member <TMember>(Expression <Func <TModel, TMember> > memberSelector, MemberSpecification <TModel, TMember> memberSpecification = null)
{
if (memberSelector == null)
{
throw new ArgumentNullException(nameof(memberSelector));
}
var memberScope = new MemberScope <TModel, TMember>(GetPropertyInfo(memberSelector), memberSpecification);
AddCommand(memberScope);
return(this);
}
public static void TestSingleMemberRule <TMember>(MemberSpecification <object, TMember> specification, TMember member, bool expectedIsValid, string expectedErrorMessage = null, IReadOnlyCollection <IMessageArg> expectedArgs = null)
{
var validator = MemberValidatorCreator.Create(specification);
var rule = validator.Rules.Single();
var executionContext = new ExecutionContextStub();
IErrorsCollection errorsCollection;
if (rule is ValidRule <TMember> validateRule)
{
validateRule.TryGetErrors(member, executionContext, ValidationStrategy.Complete, out errorsCollection);
}
else if (rule is AsNullableRule validateNullableRule)
{
validateNullableRule.TryGetErrors(new object(), member, executionContext, ValidationStrategy.Complete, out errorsCollection);
}
else
{
throw new UntestableException($"Only Valid and AsNullable can be tested in {nameof(TestSingleMemberRule)}");
}
if (expectedIsValid)
{
if (!errorsCollection.IsEmpty)
{
throw new TesterException("Error collection isn't empty, but no error is expected");
}
}
else
{
if (errorsCollection.IsEmpty)
{
throw new TesterException("Error collection is empty, but error is expected");
}
if ((errorsCollection.Errors.Count != 1) || (errorsCollection.Members.Count > 0))
{
throw new TesterException("Only one error is expected");
}
var error = errorsCollection.Errors.Single();
if (expectedErrorMessage != null)
{
if (!string.Equals(error.Message, expectedErrorMessage))
{
throw new TesterException($"Message `{error.Message}` is not as expected: `{expectedErrorMessage}`");
}
}
if (expectedArgs != null)
{
if (error.Arguments == null)
{
throw new TesterException($"No arguments while expected amount is `{expectedArgs.Count}`");
}
if (error.Arguments.Count != expectedArgs.Count)
{
throw new TesterException($"Arguments count `{error.Arguments.Count}` is not as expected `{expectedArgs.Count}`");
}
for (var i = 0; i < expectedArgs.Count; ++i)
{
var expected = expectedArgs.ElementAt(i);
var actual = error.Arguments.ElementAt(i);
if (!string.Equals(expected.Name, actual.Name))
{
throw new TesterException($"Argument at position `{i}` - name `{actual.Name}` is not as expected `{expected.Name}`");
}
var actualType = actual.GetType();
var expectedType = expected.GetType();
if (!expectedType.IsAssignableFrom(actualType))
{
throw new TesterException($"Argument at position `{i}` - type `{actualType.FullName}` cannot be used as `{expectedType.FullName}`");
}
var actualValue = actualType.GetProperties().Single(p => p.Name == "Value").GetValue(actual);
var expectedValue = actualType.GetProperties().Single(p => p.Name == "Value").GetValue(expected);
if (actualValue is double d)
{
if (Math.Abs(d - (double)expectedValue) > 0.0000001d)
{
throw new TesterException($"Argument at position `{i}` - value (double) `{actualValue}` is not as expected `{expectedValue}`");
}
}
else if (!expectedValue.Equals(actualValue))
{
throw new TesterException($"Argument at position `{i}` - value `{actualValue}` is not as expected `{expectedValue}`");
}
}
}
else if (error.Arguments != null)
{
throw new TesterException("Arguments are not expected in the error");
}
}
}
/// <summary>
/// Sets the validation logic for the nullable member's underlying value type.
/// If the nullable member as no value, the validation logic is not triggered and no error is added.
/// </summary>
/// <typeparam name="TModel">Type of the parent model.</typeparam>
/// <typeparam name="TMember">The underlying value type.</typeparam>
/// <param name="this"></param>
/// <param name="memberSpecification">The specification for the underlying value type.</param>
/// <exception cref="Exceptions.InvalidProcessedReferenceException">
/// Thrown when <paramref name="memberSpecification" />
/// returns different reference than the one on the input.
/// </exception>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="memberSpecification" /> is null.</exception>
public static IMemberSpecificationBuilder <TModel, TMember?> AsNullable <TModel, TMember>(this IMemberSpecificationBuilder <TModel, TMember?> @this, MemberSpecification <TModel, TMember> memberSpecification)
where TModel : class
where TMember : struct
{
if (memberSpecification == null)
{
throw new ArgumentNullException(nameof(memberSpecification));
}
var memberSpecificationBuilder = (MemberSpecificationBuilder <TModel, TMember?>)@this;
memberSpecificationBuilder.AddCommand(new AsNullableRule <TModel, TMember>(memberSpecification));
return(@this);
}
public PatternMemberMatcher(CellProcessor processor, object instance, MemberSpecification specification)
{
this.processor = processor;
this.specification = specification;
this.instance = instance;
}
/// <summary>
/// Sets the validation logic for the member as a collection.
/// </summary>
/// <typeparam name="TModel">Type of the parent model.</typeparam>
/// <typeparam name="TItem">Type of the items in the collection.</typeparam>
/// <param name="this"></param>
/// <param name="itemSpecification">The specification for the single item in the collection.</param>
public static IMemberSpecificationBuilder <TModel, Collection <TItem> > AsCollection <TModel, TItem>(this IMemberSpecificationBuilder <TModel, Collection <TItem> > @this, MemberSpecification <TModel, TItem> itemSpecification)
where TModel : class
{
var memberSpecification = (MemberSpecificationBuilder <TModel, Collection <TItem> >)@this;
memberSpecification.AddCommand(new AsCollectionRule <TModel, TItem>(itemSpecification));
return(@this);
}
public static IMemberValidator Create <TModel, TMember>(MemberSpecification <TModel, TMember> memberSpecification)
where TModel : class
{
return(Create(memberSpecification, out _));
}
public RuntimeMember Find(MemberSpecification specification)
{
return(columnAccessors.Find(specification, accessor => specification.MatchesIdentifierName(accessor.Key)));
}
public RuntimeMember Find(MemberSpecification specification)
{
Assert.IsTrue(specification.MatchesIdentifierName("dynamic"));
return(new QueryableMember("dynamic"));
}
