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")); }