public void RegisterValidatableObjectAdapterFactoryGuardClauses()
{
DataAnnotationsValidatableObjectAdapterFactory factory = (metadata, context) => null;
// Attribute type cannot be null
Assert.ThrowsArgumentNull(
() => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(null, factory),
"modelType");
// Factory cannot be null
Assert.ThrowsArgumentNull(
() => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), null),
"factory");
// Validation attribute must derive from ValidationAttribute
Assert.Throws <ArgumentException>(
() => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(typeof(object), factory),
"The type System.Object must derive from System.ComponentModel.DataAnnotations.IValidatableObject\r\nParameter name: modelType");
}
public void GetValidatorsReturnsValidationRulesForPropertiesWithMinAndMaxLength()
{ // Dev10 Bug #868619
// Arrange
var provider = new DataAnnotationsModelValidatorProvider();
var context = new ControllerContext();
var viewdata = new ViewDataDictionary <DerivedModel>();
var metadata = ModelMetadata.FromLambdaExpression(m => m.MinMaxProperty, viewdata);
// Act
IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);
// Assert
ModelClientValidationRule[] clientRule = validators
.SelectMany(v => v.GetClientValidationRules())
.OrderBy(t => t.GetType().Name)
.ToArray();
Assert.IsType <ModelClientValidationMaxLengthRule>(clientRule[0]);
Assert.IsType <ModelClientValidationMinLengthRule>(clientRule[1]);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ModelBinders.Binders.Add(typeof(DateTime?), new MyDateTimeModelBinder());
DependencyResolver.SetResolver(new StructureMapDependecyResolver(() => Container ?? ObjectFactory.Container));
ObjectFactory.Configure(cfg =>
{
cfg.AddRegistry(new StandardRegistry());
cfg.AddRegistry(new ControllerRegistry());
cfg.AddRegistry(new DataRegistry());
cfg.AddRegistry(new ActionFilterRegistry(() => Container ?? ObjectFactory.Container));
cfg.AddRegistry(new TaskRegistry());
cfg.AddRegistry(new ModelMetadataRegistry());
});
using (var container = ObjectFactory.Container.GetNestedContainer())
{
foreach (var task in container.GetAllInstances <IRunAtInit>())
{
task.Execute();
}
foreach (var task in container.GetAllInstances <IRunAtStartup>())
{
task.Execute();
}
}
ClientDataTypeModelValidatorProvider.ResourceClassKey = "MyNewResource";
DefaultModelBinder.ResourceClassKey = "MyNewResource";
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(MyRequiredAttributeAdapter));
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
}
private void OnStart()
{
var config = this.Context.Server.MapPath("~/log4net.config");
FileInfo repository = new FileInfo(config);
XmlConfigurator.ConfigureAndWatch(repository);
ILog log = LogManager.GetLogger("app");
DatabaseInstance.SqlStore = new DirectorySqlStore(Context.Server.MapPath("~/sql"));
log.Debug("sql store updated");
SetupContiner();
log.Debug("SetupContiner");
SetupSite();
log.Debug("SetupSite");
RegisterRoutes();
log.Debug("RegisterRoutes");
registerActionFilters();
log.Debug("registerActionFilters");
registerModelBinders();
log.Debug("registerModelBinders");
registerViewEngines();
log.Debug("registerViewEngines");
registerControllerFactory();
log.Debug("registerControllerFactory");
BuildSiteCss();
log.Debug("BuildSiteCss");
DependencyResolver.SetResolver(new UnityDependencyResolver((IUnityContainer)Application["container"]));
log.Debug("SetResolver");
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MobileAttribute), typeof(MobileAttributeAdapter));
log.Debug("RegisterAdapter");
ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());
log.Debug("ValueProviderFactories.Factories.Add(new JsonValueProviderFactory())");
}
public void UnknownValidationAttributeGetsDefaultAdapter()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute));
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = providerContext.Results.Single();
Assert.IsType <DataAnnotationsModelValidator>(validatorItem.Validator);
}
public override void Application_Start(object sender, EventArgs e)
{
base.Application_Start(sender, e);
foreach (var provider in CommerceDbProviders.Providers)
{
provider.Initialize();
}
// AutoMapper
AutoMapperConfiguration.Configure();
// Mvc
ViewEngines.Engines.Insert(0, new CommerceRazorViewEngine());
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequiredAttributeAdapter));
// Async Activity
Kooboo.Job.Jobs.Instance.AttachJob(typeof(AsyncActivityExecutionJob).FullName, new AsyncActivityExecutionJob(), 30 * 1000, null);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Enable arabic validation messages
ClientDataTypeModelValidatorProvider.ResourceClassKey = "Messages";
DefaultModelBinder.ResourceClassKey = "Meassages";
// Register adapter class
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(MyRequiredAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RegularExpressionAttribute), typeof(MyRegExAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RangeAttribute), typeof(MyRangeAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(StringLengthAttribute), typeof(MyStringLengthAttributeAdapter));
}
public async Task TryUpdateModelNonGeneric_ModelTypeOverload_ReturnsTrue_IfModelBindsAndValidatesSuccessfully()
{
// Arrange
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel {
MyProperty = "Old-Value"
};
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary <string, object>
{
{ "", null },
{ "MyProperty", "MyPropertyValue" }
};
var valueProvider = new TestValueProvider(values);
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
model.GetType(),
"",
Mock.Of <HttpContext>(),
modelStateDictionary,
TestModelMetadataProvider.CreateDefaultProvider(),
GetCompositeBinder(binders),
valueProvider,
new List <IInputFormatter>(),
new DefaultObjectValidator(
new IExcludeTypeValidationFilter[0],
metadataProvider),
validator);
// Assert
Assert.True(result);
Assert.Equal("MyPropertyValue", model.MyProperty);
}
public void RegisterAdapterFactoryGuardClauses()
{
DataAnnotationsModelValidationFactory factory = (metadata, context, attribute) => null;
// Attribute type cannot be null
ExceptionHelper.ExpectArgumentNullException(
() => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(null, factory),
"attributeType");
// Factory cannot be null
ExceptionHelper.ExpectArgumentNullException(
() => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(MyValidationAttribute), null),
"factory");
// Validation attribute must derive from ValidationAttribute
ExceptionHelper.ExpectArgumentException(
() => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(object), factory),
"The type System.Object must derive from System.ComponentModel.DataAnnotations.ValidationAttribute\r\nParameter name: attributeType");
}
protected void Application_Start()
{
Nybble.Validators.Initializer.RegisterAdapters();
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(PostalCodeRemoteAttribute), typeof(RemoteAttributeAdapter));
log4net.Config.XmlConfigurator.Configure();
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new AreaViewEngine());
ModelBinders.Binders.DefaultBinder = new SharpModelBinder();
ModelValidatorProviders.Providers.Add(new NHibernateValidatorProvider());
InitializeServiceLocator();
AreaRegistration.RegisterAllAreas();
RouteRegistrar.RegisterRoutesTo(RouteTable.Routes);
}
protected void Application_Start()
{
log4net.Config.XmlConfigurator.Configure();
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new AreaViewEngine());
ModelBinders.Binders.DefaultBinder = new SharpModelBinder();
DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(EmailAttribute), typeof(RegularExpressionAttributeAdapter));
ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(new DataAnnotationsModelValidatorProvider());
InitializeServiceLocator();
AreaRegistration.RegisterAllAreas();
RouteRegistrar.RegisterRoutesTo(RouteTable.Routes);
}
public void StringLengthValidatorsMatch()
{
var controllerContext = new ControllerContext();
var expectedValidatorCount = new DataAnnotationsModelValidatorProvider()
.GetValidators(Expected, controllerContext)
.OfType <StringLengthAttributeAdapter>()
.Count();
Assert.InRange(expectedValidatorCount, 0, 1);
Assert.Equal(
expectedValidatorCount,
new FluentValidationProvider()
.GetValidators(Fluent, controllerContext)
.OfType <RuleModelValidator>()
.SelectMany(rmv => rmv.GetClientValidationRules())
.OfType <ModelClientValidationStringLengthRule>()
.Count());
}
public void NonNullableValueTypeDoesntGetImplicitRequiredAttributeWhenFlagIsOff()
{
DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;
try {
// Arrange
var provider = new DataAnnotationsModelValidatorProvider();
var context = new ControllerContext();
var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithoutAttribute");
// Act
IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);
// Assert
Assert.AreEqual(0, validators.Count());
}
finally {
DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = true;
}
}
public void RegisterDefaultAdapter()
{
var oldFactory = DataAnnotationsModelValidatorProvider.DefaultAttributeFactory;
try {
// Arrange
var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(MyValidatedClass));
var context = new ControllerContext();
DataAnnotationsModelValidatorProvider.RegisterDefaultAdapter(typeof(MyDefaultValidationAttributeAdapter));
// Act
var result = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, context).Single();
// Assert
Assert.AreEqual(typeof(MyDefaultValidationAttributeAdapter), result.GetType());
}
finally {
DataAnnotationsModelValidatorProvider.DefaultAttributeFactory = oldFactory;
}
}
protected void Application_Start()
{
//Yoonus
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
//Yoonus
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalFilters.Filters.Add(new app.bsms.FilterAttribute());
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequiredIfValidator));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(AssertThatAttribute), typeof(AssertThatValidator));
//Yoonus //Previously these 2 lines were here
//ViewEngines.Engines.Clear();
//ViewEngines.Engines.Add(new RazorViewEngine());
//Yoonus
}
public void GetValidatorsReturnsClientValidatorForDerivedTypeAppliedAgainstBaseTypeViaFromLambdaExpression() // Dev10 Bug #868619
// Arrange
{
var provider = new DataAnnotationsModelValidatorProvider();
var context = new ControllerContext();
var viewdata = new ViewDataDictionary <DerivedModel>();
var metadata = ModelMetadata.FromLambdaExpression(m => m.MyProperty, viewdata); // Bug is in FromLambdaExpression
// Act
IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);
// Assert
ModelValidator validator = validators.Single();
ModelClientValidationRule clientRule = validator.GetClientValidationRules().Single();
Assert.IsInstanceOfType(clientRule, typeof(ModelClientValidationStringLengthRule));
ModelClientValidationStringLengthRule stringLengthRule = (ModelClientValidationStringLengthRule)clientRule;
Assert.AreEqual(10, stringLengthRule.ValidationParameters["max"]);
}
public void CreateValidators_ReturnsValidatorForIValidatableObject()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var mockValidatable = Mock.Of <IValidatableObject>();
var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType());
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.IsType <ValidatableObjectAdapter>(validatorItem.Validator);
}
public void CreateValidators_InsertsRequiredValidatorsFirst()
{
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForProperty(
typeof(ClassWithProperty),
"PropertyWithMultipleValidationAttributes");
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
Assert.Equal(4, providerContext.Results.Count);
Assert.IsAssignableFrom <RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Results[0].Validator).Attribute);
Assert.IsAssignableFrom <RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Results[1].Validator).Attribute);
}
public void NonNullableValueTypesGetImplicitRequiredAttribute()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider();
var context = new ControllerContext();
var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(
() => null,
typeof(DummyRequiredAttributeHelperClass),
"WithoutAttribute"
);
// Act
IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);
// Assert
ModelValidator validator = validators.Single();
ModelClientValidationRule rule = validator.GetClientValidationRules().Single();
Assert.IsType <ModelClientValidationRequiredRule>(rule);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
UnityConfig.RegisterComponents();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
WebHelper.Log = new LogService();
ModelBinders.Binders.Add(typeof(decimal), new DecimalModelBinder());
ModelBinders.Binders.Add(typeof(decimal?), new DecimalModelBinder());
ModelBinders.Binders.Add(typeof(double), new DecimalModelBinder());
ModelBinders.Binders.Add(typeof(double?), new DecimalModelBinder());
CriteriaOperator.RegisterCustomFunction(new AccentFilter());
//Data annotations
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(CustomRequiredAttributeAdapter));
DevExpress.XtraReports.Web.Extensions.ReportStorageWebExtension.RegisterExtensionGlobal(new CustomReportStorageWebExtension());
ModelBinders.Binders.DefaultBinder = new DevExpress.Web.Mvc.DevExpressEditorsBinder();
}
public async Task TryUpdateModel_ReturnsFalse_IfModelValidationFails()
{
// Arrange
var expectedMessage = TestPlatformHelper.IsMono ? "The field MyProperty is invalid." :
"The MyProperty field is required.";
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel();
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary <string, object>
{
{ "", null }
};
var valueProvider = new TestValueProvider(values);
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
"",
Mock.Of <HttpContext>(),
modelStateDictionary,
modelMetadataProvider,
GetCompositeBinder(binders),
valueProvider,
new List <IInputFormatter>(),
new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], modelMetadataProvider),
validator);
// Assert
Assert.False(result);
var error = Assert.Single(modelStateDictionary["MyProperty"].Errors);
Assert.Equal(expectedMessage, error.ErrorMessage);
}
protected void Application_Start()
{
#if DEBUG
Database.SetInitializer <TaskDBContext>(new TaskDbContextInitializer());
using (var init = new TaskDBContext())
{
init.Database.Initialize(force: false);
}
Database.SetInitializer <SchoolContext>(new SchoolInitializer());
// Database.SetInitializer<ImageContext>(new ImageInitializer());
Database.SetInitializer <MovieContext>(new MovieInitializer());
Log.SingletonLogger.Instance.Attach(new Log.ObserverLogToConsole());
#endif
//ModelBinders.Binders.Add(typeof(Appointment), new ValidatingModelBinder());
//ModelValidatorProviders.Providers.Clear();
//ModelValidatorProviders.Providers.Add(new CustomValidationProvider());
//HtmlHelper.ClientValidationEnabled = true;
//HtmlHelper.UnobtrusiveJavaScriptEnabled = true;
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
DataAnnotationsModelValidatorProvider.RegisterAdapter(
typeof(RemoteUID_Attribute),
typeof(RemoteValidator));
ControllerBuilder.Current.SetControllerFactory(new NinjectControllerFactory());
ModelBinders.Binders.Add(typeof(Cart), new CartModelBinder());
ModelBinders.Binders.Add(typeof(Appointment), new ValidatingModelBinder());
//odelBinders.Binders.Add(typeof(DateTime), new DateBinder());
}
public void RegisterAdapterFactory()
{
var oldFactories = DataAnnotationsModelValidatorProvider.AttributeFactories;
try {
// Arrange
DataAnnotationsModelValidatorProvider.AttributeFactories = new Dictionary <Type, DataAnnotationsModelValidationFactory>();
DataAnnotationsModelValidationFactory factory = delegate { return(null); };
// Act
DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(MyValidationAttribute), factory);
// Assert
var type = DataAnnotationsModelValidatorProvider.AttributeFactories.Keys.Single();
Assert.AreEqual(typeof(MyValidationAttribute), type);
Assert.AreSame(factory, DataAnnotationsModelValidatorProvider.AttributeFactories.Values.Single());
}
finally {
DataAnnotationsModelValidatorProvider.AttributeFactories = oldFactories;
}
}
protected void Application_Start()
{
MvcHandler.DisableMvcResponseHeader = true;
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
DependencyRegistrar.Register("Web.Admin");
//DependencyRegistrar.Container
AreaRegistration.RegisterAllAreas();
//GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequiredAttributeAdapter));
ModelMetadataProviders.Current = new CachedDataAnnotationsModelMetadataProvider();
System.Web.Mvc.ModelBinders.Binders.Add(typeof(DataTablesModel), new DataTablesModelBinder());
string publicKey = WebConfigurationManager.AppSettings["RecaptchaPublicKey"];
string secretKey = WebConfigurationManager.AppSettings["RecaptchaPrivateKey"];
ReCaptcha.Configure(publicKey, secretKey);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
WebApiConfig.Register(GlobalConfiguration.Configuration);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configuration.MessageHandlers.Add(new AccessTokenHandler());
DependencyResolver.SetResolver(new NinjectDependecyResolver());
AutoMapperPortalConfiguration.Configure();
Mapper.AssertConfigurationIsValid();
log4net.Config.XmlConfigurator.Configure();
DataAnnotationsModelValidatorProvider.RegisterAdapter(
typeof(PhoneNumberAttribute),
typeof(RegularExpressionAttributeAdapter));
}
/// <summary>
/// Sets up Autofac to work with an MVC3 environment.
/// Should be called from Application_Start
/// </summary>
/// <param name="d">A lambda that takes a container builder that then registers any dependencies within the application</param>
/// <returns>The container so that the application can do any resolves necessary within Application_Start</returns>
public IContainer RegisterDependencies(Dependencies d)
{
var builder = new ContainerBuilder();
RegisterWebbyStuff(builder);
builder.RegisterModule <AuthModule>();
d(builder);
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Enable the flow forms model metadata provider
ModelMetadataProviders.Current = new MetadataProvider();
// Enable the flow forms Validator Provider to fix MVC bug
DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapterFactory((m, c) => new CustomValidatableObjectAdapter(m, c));
return(container);
}
public async Task TryUpdateModel_ReturnsFalse_IfModelValidationFails()
{
// Arrange
var expectedMessage = TestPlatformHelper.IsMono ? "The field MyProperty is invalid." :
"The MyProperty field is required.";
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel();
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary<string, object>
{
{ "", null }
};
var valueProvider = new TestValueProvider(values);
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
"",
Mock.Of<HttpContext>(),
modelStateDictionary,
modelMetadataProvider,
GetCompositeBinder(binders),
valueProvider,
new List<IInputFormatter>(),
new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], modelMetadataProvider),
validator);
// Assert
Assert.False(result);
var error = Assert.Single(modelStateDictionary["MyProperty"].Errors);
Assert.Equal(expectedMessage, error.ErrorMessage);
}
public override void Boot(RouteCollection routes)
{
base.Boot(routes);
routes.RegisterArea(_installRegistration);
//register all component areas
foreach (var c in _componentAreas)
{
routes.RegisterArea(c);
}
//IMPORTANT: We need to register the Umbraco area after the components because routes overlap.
// For example, a surface controller might have a url of:
// /Umbraco/MyPackage/Surface/MySurface
// and because the default action is 'Index' its not required to be there, however this same route
// matches the default Umbraco back office route of Umbraco/{controller}/{action}/{id}
// so we want to make sure that the plugin routes are matched first
routes.RegisterArea(_areaRegistration);
//ensure that the IAttributeTypeRegistry is set
AttributeTypeRegistry.SetCurrent(_attributeTypeRegistry);
//register validation extensions
DataAnnotationsModelValidatorProviderExtensions.RegisterValidationExtensions();
LocalizationWebConfig.RegisterRoutes(routes, _settings.UmbracoPaths.LocalizationPath);
//If this is outside of an ASP.Net application (i.e. Unit test) and RegisterVirtualPathProvider is called then an exception is thrown.
if (HostingEnvironment.IsHosted)
{
HostingEnvironment.RegisterVirtualPathProvider(new EmbeddedViewVirtualPathProvider());
}
//register custom validation adapters
DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(
typeof(HiveIdRequiredAttribute),
(metadata, controllerContext, attribute) =>
new RequiredHiveIdAttributeAdapter(metadata, controllerContext, (HiveIdRequiredAttribute)attribute));
}
public async Task BindModel_WithDefaultValidators_ValidatesInstance()
{
// Arrange
var validatorProvider = new DataAnnotationsModelValidatorProvider();
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleHttpValueProvider
{
{ "user.password", "password" },
{ "user.confirmpassword", "password" },
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(User), new[] { validatorProvider });
bindingContext.ModelName = "user";
// Act
var isBound = await binder.BindModelAsync(bindingContext);
// Assert
var error = Assert.Single(bindingContext.ModelState["user"].Errors);
Assert.Equal("Password does not meet complexity requirements.", error.ErrorMessage);
}
public async Task BindModel_WithDefaultValidators_ValidatesSubProperties()
{
// Arrange
var validatorProvider = new DataAnnotationsModelValidatorProvider();
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleHttpValueProvider
{
{ "user.password", "password-val" },
{ "user.confirmpassword", "not-password-val" },
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(User), new[] { validatorProvider });
bindingContext.ModelName = "user";
// Act
var isBound = await binder.BindModelAsync(bindingContext);
// Assert
var error = Assert.Single(bindingContext.ModelState["user.confirmpassword"].Errors);
Assert.Equal("'ConfirmPassword' and 'Password' do not match.", error.ErrorMessage);
}
protected void Application_Start()
{
//Prevents information leakage from the X-AspNetMvc-Version header of the HTTP response
MvcHandler.DisableMvcResponseHeader = true;
//Adds Installation route
RouteTable.Routes.MapRoute(
name: "Installation",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Installation", action = "Index", id = UrlParameter.Optional }
);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//I did not apply the following fix as I've decided to use a String data type rather then a DateTime
//Fixes issue where MVC DateTime is bound with incorrect date format http://stackoverflow.com/a/17651519/496676
//ModelBinders.Binders.Add(typeof(DateTime), new CustomDateBinder());
//ModelBinders.Binders.Add(typeof(DateTime?), new NullableCustomDateBinder());
//Registers the custom attributes with the relative validation providers http://forums.asp.net/t/1528277.aspx
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsDomainName), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsRange), typeof(RangeAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsNotEqualTo), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyDecimal), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyIntegers), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyLetters), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyLettersNumbers), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyNonAccentedLettersNumbersDashes), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyNonAccentedLettersNumbersDashesSpaces), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlyNumbers), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsOnlySafeCharacters), typeof(RegularExpressionAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsRequired), typeof(RequiredAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsStringLengthMax), typeof(StringLengthAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsStringLengthMin), typeof(MinLengthAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsStringLengthRange), typeof(StringLengthAttributeAdapter));
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(DataAnnotationsURL), typeof(RegularExpressionAttributeAdapter));
IsApplicationStart = true;
}
public async Task BindModel_WithDefaultValidators_ValidatesInstance()
{
// Arrange
var validatorProvider = new DataAnnotationsModelValidatorProvider();
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleHttpValueProvider
{
{ "user.password", "password" },
{ "user.confirmpassword", "password" },
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(User), new[] { validatorProvider });
bindingContext.ModelName = "user";
// Act
var isBound = await binder.BindModelAsync(bindingContext);
// Assert
var error = Assert.Single(bindingContext.ModelState["user"].Errors);
Assert.Equal("Password does not meet complexity requirements.", error.ErrorMessage);
}
public async Task TryUpdateModel_UsingIncludeExpressionOverload_ReturnsTrue_ModelBindsAndValidatesSuccessfully()
{
// Arrange
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel
{
MyProperty = "Old-Value",
IncludedProperty = "Old-IncludedPropertyValue",
ExcludedProperty = "Old-ExcludedPropertyValue"
};
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary<string, object>
{
{ "", null },
{ "MyProperty", "MyPropertyValue" },
{ "IncludedProperty", "IncludedPropertyValue" },
{ "ExcludedProperty", "ExcludedPropertyValue" }
};
var valueProvider = new TestValueProvider(values);
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
"",
Mock.Of<HttpContext>(),
modelStateDictionary,
TestModelMetadataProvider.CreateDefaultProvider(),
GetCompositeBinder(binders),
valueProvider,
new DefaultObjectValidator(Mock.Of<IValidationExcludeFiltersProvider>(), metadataProvider),
validator,
m => m.IncludedProperty,
m => m.MyProperty);
// Assert
Assert.True(result);
Assert.Equal("MyPropertyValue", model.MyProperty);
Assert.Equal("IncludedPropertyValue", model.IncludedProperty);
Assert.Equal("Old-ExcludedPropertyValue", model.ExcludedProperty);
}
public async Task BindModel_WithDefaultValidators_ValidatesSubProperties()
{
// Arrange
var validatorProvider = new DataAnnotationsModelValidatorProvider();
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleHttpValueProvider
{
{ "user.password", "password-val" },
{ "user.confirmpassword", "not-password-val" },
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(User), new[] { validatorProvider });
bindingContext.ModelName = "user";
// Act
var isBound = await binder.BindModelAsync(bindingContext);
// Assert
var error = Assert.Single(bindingContext.ModelState["user.confirmpassword"].Errors);
Assert.Equal("'ConfirmPassword' and 'Password' do not match.", error.ErrorMessage);
}
public async Task TryUpdateModel_ReturnsTrue_IfModelBindsAndValidatesSuccessfully()
{
// Arrange
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel { MyProperty = "Old-Value" };
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary<string, object>
{
{ "", null },
{ "MyProperty", "MyPropertyValue" }
};
var valueProvider = new TestValueProvider(values);
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
"",
Mock.Of<HttpContext>(),
modelStateDictionary,
metadataProvider,
GetCompositeBinder(binders),
valueProvider,
new List<IInputFormatter>(),
new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], metadataProvider),
validator);
// Assert
Assert.True(result);
Assert.Equal("MyPropertyValue", model.MyProperty);
}
public async Task TryUpdateModelNonGeneric_PredicateOverload_ReturnsTrue_ModelBindsAndValidatesSuccessfully()
{
// Arrange
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new ComplexModelDtoModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel
{
MyProperty = "Old-Value",
IncludedProperty = "Old-IncludedPropertyValue",
ExcludedProperty = "Old-ExcludedPropertyValue"
};
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary<string, object>
{
{ "", null },
{ "MyProperty", "MyPropertyValue" },
{ "IncludedProperty", "IncludedPropertyValue" },
{ "ExcludedProperty", "ExcludedPropertyValue" }
};
Func<ModelBindingContext, string, bool> includePredicate =
(context, propertyName) =>
string.Equals(propertyName, "IncludedProperty", StringComparison.OrdinalIgnoreCase) ||
string.Equals(propertyName, "MyProperty", StringComparison.OrdinalIgnoreCase);
var valueProvider = new TestValueProvider(values);
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
model.GetType(),
"",
Mock.Of<HttpContext>(),
modelStateDictionary,
metadataProvider,
GetCompositeBinder(binders),
valueProvider,
new List<IInputFormatter>(),
new DefaultObjectValidator(
new IExcludeTypeValidationFilter[0],
metadataProvider),
validator,
includePredicate);
// Assert
Assert.True(result);
Assert.Equal("MyPropertyValue", model.MyProperty);
Assert.Equal("IncludedPropertyValue", model.IncludedProperty);
Assert.Equal("Old-ExcludedPropertyValue", model.ExcludedProperty);
}
public async Task TryUpdateModel_UsingDefaultIncludeOverload_IncludesAllProperties()
{
// Arrange
var binders = new IModelBinder[]
{
new TypeConverterModelBinder(),
new MutableObjectModelBinder()
};
var validator = new DataAnnotationsModelValidatorProvider();
var model = new MyModel
{
MyProperty = "Old-Value",
IncludedProperty = "Old-IncludedPropertyValue",
ExcludedProperty = "Old-ExcludedPropertyValue"
};
var modelStateDictionary = new ModelStateDictionary();
var values = new Dictionary<string, object>
{
{ "", null },
{ "MyProperty", "MyPropertyValue" },
{ "IncludedProperty", "IncludedPropertyValue" },
{ "ExcludedProperty", "ExcludedPropertyValue" }
};
var valueProvider = new TestValueProvider(values);
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
// Act
var result = await ModelBindingHelper.TryUpdateModelAsync(
model,
"",
Mock.Of<HttpContext>(),
modelStateDictionary,
metadataProvider,
GetCompositeBinder(binders),
valueProvider,
new List<IInputFormatter>(),
new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], metadataProvider),
validator);
// Assert
// Includes everything.
Assert.True(result);
Assert.Equal("MyPropertyValue", model.MyProperty);
Assert.Equal("IncludedPropertyValue", model.IncludedProperty);
Assert.Equal("ExcludedPropertyValue", model.ExcludedProperty);
}
