public void ShouldProcessTheDefaultValidatorForNotNullableValueTypesWhenFormValueIsNull()
        {
            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            validatorFactory.GetValidatorForOptional(typeof(TestModel)).Returns(x => new TestModelValidator());

            LaboModelValidatorProvider.Configure(validatorFactory);

            FormCollection form = new FormCollection
            {
                { "Age", string.Empty }
            };

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelName             = "test",
                ModelMetadata         = GetModelMetaData(typeof(TestModel)),
                ModelState            = new ModelStateDictionary(),
                FallbackToEmptyPrefix = true,
                ValueProvider         = form.ToValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            binder.BindModel(controllerContext, bindingContext);

            Assert.AreEqual("'Age' must not be empty.", bindingContext.ModelState["Age"].Errors.Single().ErrorMessage);
        }
        public void GetValidators_ValidatorFactoryGetValidatorForOptionalContainerTypeShouldBeCalled()
        {
            IValidatorFactory validatorFactory  = Substitute.For <IValidatorFactory>();
            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory);
            ModelMetadata modelMetaData         = GetModelMetaDataForProperty(typeof(TestModel), LinqUtils.GetMemberName <TestModel, string>(x => x.Name));

            provider.GetValidators(modelMetaData, controllerContext);

            validatorFactory.Received(1).GetValidatorForOptional(modelMetaData.ContainerType);
        }
        public void Configure()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            LaboModelValidatorProvider.Configure(validatorFactory);

            Assert.IsFalse(DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes);

            LaboModelValidatorProvider laboModelValidatorProvider = ModelValidatorProviders.Providers.Last() as LaboModelValidatorProvider;

            Assert.IsNotNull(laboModelValidatorProvider);
            Assert.AreEqual(validatorFactory, laboModelValidatorProvider.ValidatorFactory);
            Assert.AreEqual(true, laboModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes);
        }
        public void GetValidators_ShouldReturnValidatorsWithTheSamePropertiesAsTheSpecifiedProperty()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            validatorFactory.GetValidatorForOptional(typeof(TestModel)).Returns(x => new TestModelValidator());

            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory);

            ValidateValidatorPropertyNames(x => x.Name, provider, controllerContext);
            ValidateValidatorPropertyNames(x => x.Email, provider, controllerContext);
        }
        public void GetValidators_ValidatorFactoryGetValidatorForOptionalShouldBeCalled()
        {
            IValidatorFactory validatorFactory  = Substitute.For <IValidatorFactory>();
            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider          = new LaboModelValidatorProvider(validatorFactory);
            ModelMetadata modelMetaData                  = GetModelMetaData(typeof(TestModel));
            IEnumerable <ModelValidator> modelValidators = provider.GetValidators(modelMetaData, controllerContext);

            Assert.IsTrue(modelValidators.First() is LaboModelValidator);

            validatorFactory.Received(1).GetValidatorForOptional(modelMetaData.ModelType);
        }
        public void ConfigureWithConfigurationAction()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();
            Func <ModelMetadata, ControllerContext, IEntityValidationRule, IValidationTransformerManager, ModelValidator> phoneNumberValidatorFactory = (metadata, context, validator, validatorTransformerManager) => new LaboPropertyValidator(metadata, context, new StubEntityValidationRule(new EntityPropertyValidator(new PhoneNumberValidator()), metadata.GetDisplayName(), metadata.PropertyName));

            LaboModelValidatorProvider.Configure(validatorFactory, x =>
            {
                x.AddImplicitRequiredAttributeForValueTypes = false;
                x.RegisterValidatorFactory("PhoneNumberValidator", phoneNumberValidatorFactory);
            });

            Assert.IsFalse(DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes);

            LaboModelValidatorProvider laboModelValidatorProvider = ModelValidatorProviders.Providers.Last() as LaboModelValidatorProvider;

            Assert.IsNotNull(laboModelValidatorProvider);
            Assert.AreEqual(false, laboModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes);
            Assert.AreSame(phoneNumberValidatorFactory, laboModelValidatorProvider.PropertyValidatorFactories["PhoneNumberValidator"]);
        }
        public void GetValidators_ShouldReturnLaboPropertyValidatorWhenTheSpecifiedValidatorTypeIsNotInThePropertyValidatorFactories()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            validatorFactory.GetValidatorForOptional(typeof(TestModel)).Returns(x => new TestModelValidator());

            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory)
            {
                AddImplicitRequiredAttributeForValueTypes = false
            };

            string                 propertyName      = LinqUtils.GetMemberName <TestModel, string>(x => x.Type);
            ModelMetadata          propertyMetaData  = GetModelMetaDataForProperty(typeof(TestModel), propertyName);
            IList <ModelValidator> properyValidators = provider.GetValidators(propertyMetaData, controllerContext).ToList();

            Assert.IsTrue(properyValidators.First() is LaboPropertyValidator);
        }
        public void GetValidators_ShouldNotReturnNotNullValidatorWhenModelMetadataIsRequiredAndAddImplicitRequiredAttributeForValueTypesIsFalse()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            validatorFactory.GetValidatorForOptional(typeof(TestModel)).Returns(x => new TestModelValidator());

            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory)
            {
                AddImplicitRequiredAttributeForValueTypes = false
            };

            string                 propertyName      = LinqUtils.GetMemberName <TestModel, int>(x => x.Age);
            ModelMetadata          propertyMetaData  = GetModelMetaDataForProperty(typeof(TestModel), propertyName);
            IList <ModelValidator> properyValidators = provider.GetValidators(propertyMetaData, controllerContext).ToList();

            Assert.AreEqual(0, properyValidators.Count);
        }
        public void GetValidators_ShouldReturnTheRightValidators()
        {
            IValidatorFactory validatorFactory = Substitute.For <IValidatorFactory>();

            validatorFactory.GetValidatorForOptional(typeof(TestModel)).Returns(x => new TestModelValidator());

            ControllerContext controllerContext = new ControllerContext {
                HttpContext = Substitute.For <HttpContextBase>()
            };
            LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory);

            string                 propertyName      = LinqUtils.GetMemberName <TestModel, string>(x => x.Name);
            ModelMetadata          propertyMetaData  = GetModelMetaDataForProperty(typeof(TestModel), propertyName);
            IList <ModelValidator> properyValidators = provider.GetValidators(propertyMetaData, controllerContext).ToList();

            Assert.AreEqual(2, properyValidators.Count);
            Assert.IsTrue(properyValidators[0].IsRequired);
            Assert.IsTrue(GetInnerValidator(properyValidators[0]) is NotNullValidator);
            Assert.IsTrue(GetInnerValidator(properyValidators[1]) is LengthValidator);
            Assert.AreEqual(10, ((LengthValidator)GetInnerValidator(properyValidators[1])).Max);
        }
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            DefaultEntityValidatorFactory validatorFactory = new DefaultEntityValidatorFactory();

            validatorFactory.RegisterValidator(new CustomerInsertDtoValidator());

            DefaultValidationTransformerManager validationTransformerManager = new DefaultValidationTransformerManager();

            validationTransformerManager.RegisterValidationTransformer(new CustomerInsertModelToDtoValidationTransformer());

            ValidatorSettings.ValidationTransformerManager = validationTransformerManager;

            LaboModelValidatorProvider.Configure(validatorFactory);
        }