You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
packages
src
test
Microsoft.TestCommon
Microsoft.Web.Helpers.Test
Microsoft.Web.Http.Data.Test
Microsoft.Web.Mvc.Test
Microsoft.Web.WebPages.OAuth.Test
SPA.Test
System.Json.Test.Integration
System.Json.Test.Unit
System.Net.Http.Formatting.Test.Integration
System.Net.Http.Formatting.Test.Unit
System.Web.Helpers.Test
System.Web.Http.Integration.Test
System.Web.Http.SelfHost.Test
System.Web.Http.Test
Common
Controllers
Dispatcher
Filters
Hosting
Internal
Metadata
ModelBinding
Properties
Query
Routing
Services
Tracing
Util
Validation
Providers
AssociatedValidatorProviderTest.cs
DataAnnotationsModelValidatorProviderTest.cs
DataMemberModelValidatorProviderTest.cs
Validators
DefaultBodyModelValidatorTest.cs
ModelValidationNodeTest.cs
ModelValidationRequiredMemberSelectorTest.cs
ModelValidationResultTest.cs
ModelValidatorTest.cs
ValueProviders
AuthorizeAttributeTest.cs
DictionaryExtensionsTest.cs
HttpRequestMessageExtensionsTest.cs
HttpResponseExceptionTest.cs
HttpResponseMessageExtensionsTest.cs
HttpRouteCollectionExtensionsTest.cs
HttpServerTest.cs
QueryableAttributeTest.cs
System.Web.Http.Test.csproj
packages.config
System.Web.Http.WebHost.Test
System.Web.Mvc.Test
System.Web.Razor.Test
System.Web.WebPages.Administration.Test
System.Web.WebPages.Deployment.Test
System.Web.WebPages.Razor.Test
System.Web.WebPages.Test
WebMatrix.Data.Test
WebMatrix.WebData.Test
Settings.StyleCop
tools
.gitattributes
.gitignore
License.txt
README.md
Runtime.msbuild
Runtime.sln
Runtime.xunit
Settings.StyleCop
build.cmd
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
ikdasm
ikvm
linker
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
ikvm-native
libgc
llvm
m4
man
mcs
mono
msvc
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
520 lines
20 KiB
C#
520 lines
20 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Linq;
|
|
using System.Web.Http.Metadata;
|
|
using System.Web.Http.Metadata.Providers;
|
|
using System.Web.Http.Validation.Validators;
|
|
using Moq;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Web.Http.Validation.Providers
|
|
{
|
|
public class DataAnnotationsModelValidatorProviderTest
|
|
{
|
|
private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
|
|
private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();
|
|
|
|
// Validation attribute adapter registration
|
|
|
|
private class MyValidationAttribute : ValidationAttribute
|
|
{
|
|
public override bool IsValid(object value)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
private class MyValidationAttributeAdapter : DataAnnotationsModelValidator
|
|
{
|
|
public MyValidationAttributeAdapter(IEnumerable<ModelValidatorProvider> validatorProviders, ValidationAttribute attribute)
|
|
: base(validatorProviders, attribute)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
private class MyValidationAttributeAdapterBadCtor : ModelValidator
|
|
{
|
|
public MyValidationAttributeAdapterBadCtor(IEnumerable<ModelValidatorProvider> validatorProviders)
|
|
: base(validatorProviders)
|
|
{
|
|
}
|
|
|
|
public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
private class MyDefaultValidationAttributeAdapter : DataAnnotationsModelValidator
|
|
{
|
|
public MyDefaultValidationAttributeAdapter(IEnumerable<ModelValidatorProvider> validatorProviders, ValidationAttribute attribute)
|
|
: base(validatorProviders, attribute)
|
|
{
|
|
}
|
|
}
|
|
|
|
[MyValidation]
|
|
private class MyValidatedClass
|
|
{
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterAdapter()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
provider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();
|
|
|
|
// Act
|
|
provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapter));
|
|
|
|
// Assert
|
|
var type = provider.AttributeFactories.Keys.Single();
|
|
Assert.Equal(typeof(MyValidationAttribute), type);
|
|
|
|
var factory = provider.AttributeFactories.Values.Single();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(object));
|
|
var attribute = new MyValidationAttribute();
|
|
var validator = factory(_noValidatorProviders, attribute);
|
|
Assert.IsType<MyValidationAttributeAdapter>(validator);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterAdapterGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Attribute type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterAdapter(null, typeof(MyValidationAttributeAdapter)),
|
|
"attributeType");
|
|
|
|
// Adapter type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterAdapter(typeof(MyValidationAttribute), null),
|
|
"adapterType");
|
|
|
|
// Validation attribute must derive from ValidationAttribute
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterAdapter(typeof(object), typeof(MyValidationAttributeAdapter)),
|
|
"attributeType",
|
|
"The type Object must derive from ValidationAttribute");
|
|
|
|
// Adapter must derive from ModelValidator
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(object)),
|
|
"adapterType",
|
|
"The type Object must derive from ModelValidator");
|
|
|
|
// Adapter must have the expected constructor
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapterBadCtor)),
|
|
"adapterType",
|
|
"The type MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types ModelMetadata, IEnumerable<ModelValidatorProvider>, and MyValidationAttribute");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterAdapterFactory()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
provider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();
|
|
DataAnnotationsModelValidationFactory factory = delegate { return null; };
|
|
|
|
// Act
|
|
provider.RegisterAdapterFactory(typeof(MyValidationAttribute), factory);
|
|
|
|
// Assert
|
|
var type = provider.AttributeFactories.Keys.Single();
|
|
Assert.Equal(typeof(MyValidationAttribute), type);
|
|
Assert.Same(factory, provider.AttributeFactories.Values.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterAdapterFactoryGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
DataAnnotationsModelValidationFactory factory = (validatorProviders, attribute) => null;
|
|
|
|
// Attribute type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterAdapterFactory(null, factory),
|
|
"attributeType");
|
|
|
|
// Factory cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterAdapterFactory(typeof(MyValidationAttribute), null),
|
|
"factory");
|
|
|
|
// Validation attribute must derive from ValidationAttribute
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterAdapterFactory(typeof(object), factory),
|
|
"attributeType",
|
|
"The type Object must derive from ValidationAttribute");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultAdapter()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatedClass));
|
|
provider.RegisterDefaultAdapter(typeof(MyDefaultValidationAttributeAdapter));
|
|
|
|
// Act
|
|
var result = provider.GetValidators(metadata, _noValidatorProviders).Single();
|
|
|
|
// Assert
|
|
Assert.IsType<MyDefaultValidationAttributeAdapter>(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultAdapterGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Adapter type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterDefaultAdapter(null),
|
|
"adapterType");
|
|
|
|
// Adapter must derive from ModelValidator
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterDefaultAdapter(typeof(object)),
|
|
"adapterType",
|
|
"The type Object must derive from ModelValidator");
|
|
|
|
// Adapter must have the expected constructor
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterDefaultAdapter(typeof(MyValidationAttributeAdapterBadCtor)),
|
|
"adapterType",
|
|
"The type MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types ModelMetadata, IEnumerable<ModelValidatorProvider>, and ValidationAttribute");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultAdapterFactory()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatedClass));
|
|
ModelValidator validator = new Mock<ModelValidator>(_noValidatorProviders).Object;
|
|
DataAnnotationsModelValidationFactory factory = delegate { return validator; };
|
|
provider.RegisterDefaultAdapterFactory(factory);
|
|
|
|
// Act
|
|
var result = provider.GetValidators(metadata, _noValidatorProviders).Single();
|
|
|
|
// Assert
|
|
Assert.Same(validator, result);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultAdapterFactoryGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Factory cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterDefaultAdapterFactory(null),
|
|
"factory");
|
|
}
|
|
|
|
// IValidatableObject adapter registration
|
|
|
|
private class MyValidatableAdapter : ModelValidator
|
|
{
|
|
public MyValidatableAdapter(IEnumerable<ModelValidatorProvider> validatorProviders)
|
|
: base(validatorProviders)
|
|
{
|
|
}
|
|
|
|
public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
private class MyValidatableAdapterBadCtor : ModelValidator
|
|
{
|
|
public MyValidatableAdapterBadCtor(IEnumerable<ModelValidatorProvider> validatorProviders, int unused)
|
|
: base(validatorProviders)
|
|
{
|
|
}
|
|
|
|
public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
private class MyValidatableClass : IValidatableObject
|
|
{
|
|
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterValidatableObjectAdapter()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
provider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
|
|
IValidatableObject validatable = new Mock<IValidatableObject>().Object;
|
|
|
|
// Act
|
|
provider.RegisterValidatableObjectAdapter(validatable.GetType(), typeof(MyValidatableAdapter));
|
|
|
|
// Assert
|
|
var type = provider.ValidatableFactories.Keys.Single();
|
|
Assert.Equal(validatable.GetType(), type);
|
|
|
|
var factory = provider.ValidatableFactories.Values.Single();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(object));
|
|
var validator = factory(_noValidatorProviders);
|
|
Assert.IsType<MyValidatableAdapter>(validator);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterValidatableObjectAdapterGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Attribute type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterValidatableObjectAdapter(null, typeof(MyValidatableAdapter)),
|
|
"modelType");
|
|
|
|
// Adapter type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), null),
|
|
"adapterType");
|
|
|
|
// Validation attribute must derive from ValidationAttribute
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterValidatableObjectAdapter(typeof(object), typeof(MyValidatableAdapter)),
|
|
"modelType",
|
|
"The type Object must derive from IValidatableObject.");
|
|
|
|
// Adapter must derive from ModelValidator
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(object)),
|
|
"adapterType",
|
|
"The type Object must derive from ModelValidator");
|
|
|
|
// Adapter must have the expected constructor
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(MyValidatableAdapterBadCtor)),
|
|
"adapterType",
|
|
"The type MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types ModelMetadata and IEnumerable<ModelValidatorProvider>");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterValidatableObjectAdapterFactory()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
provider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
|
|
DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return null; };
|
|
|
|
// Act
|
|
provider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), factory);
|
|
|
|
// Assert
|
|
var type = provider.ValidatableFactories.Keys.Single();
|
|
Assert.Equal(typeof(MyValidatableClass), type);
|
|
Assert.Same(factory, provider.ValidatableFactories.Values.Single());
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterValidatableObjectAdapterFactoryGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
DataAnnotationsValidatableObjectAdapterFactory factory = (context) => null;
|
|
|
|
// Attribute type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterValidatableObjectAdapterFactory(null, factory),
|
|
"modelType");
|
|
|
|
// Factory cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), null),
|
|
"factory");
|
|
|
|
// Validation attribute must derive from ValidationAttribute
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterValidatableObjectAdapterFactory(typeof(object), factory),
|
|
"modelType",
|
|
"The type Object must derive from IValidatableObject");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultValidatableObjectAdapter()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatableClass));
|
|
provider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapter));
|
|
|
|
// Act
|
|
var result = provider.GetValidators(metadata, _noValidatorProviders).Single();
|
|
|
|
// Assert
|
|
Assert.IsType<MyValidatableAdapter>(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultValidatableObjectAdapterGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Adapter type cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterDefaultValidatableObjectAdapter(null),
|
|
"adapterType");
|
|
|
|
// Adapter must derive from ModelValidator
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterDefaultValidatableObjectAdapter(typeof(object)),
|
|
"adapterType",
|
|
"The type Object must derive from ModelValidator");
|
|
|
|
// Adapter must have the expected constructor
|
|
Assert.ThrowsArgument(
|
|
() => provider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapterBadCtor)),
|
|
"adapterType",
|
|
"The type MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types ModelMetadata and IEnumerable<ModelValidatorProvider>");
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultValidatableObjectAdapterFactory()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatableClass));
|
|
ModelValidator validator = new Mock<ModelValidator>(_noValidatorProviders).Object;
|
|
DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return validator; };
|
|
provider.RegisterDefaultValidatableObjectAdapterFactory(factory);
|
|
|
|
// Act
|
|
var result = provider.GetValidators(metadata, _noValidatorProviders).Single();
|
|
|
|
// Assert
|
|
Assert.Same(validator, result);
|
|
}
|
|
|
|
[Fact]
|
|
public void RegisterDefaultValidatableObjectAdapterFactoryGuardClauses()
|
|
{
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
|
|
// Factory cannot be null
|
|
Assert.ThrowsArgumentNull(
|
|
() => provider.RegisterDefaultValidatableObjectAdapterFactory(null),
|
|
"factory");
|
|
}
|
|
|
|
// Default adapter factory for unknown attribute type
|
|
|
|
[Fact]
|
|
public void UnknownValidationAttributeGetsDefaultAdapter()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(DummyClassWithDummyValidationAttribute));
|
|
|
|
// Act
|
|
IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, _noValidatorProviders);
|
|
|
|
// Assert
|
|
var validator = validators.Single();
|
|
Assert.IsType<DataAnnotationsModelValidator>(validator);
|
|
}
|
|
|
|
private class DummyValidationAttribute : ValidationAttribute
|
|
{
|
|
}
|
|
|
|
[DummyValidation]
|
|
private class DummyClassWithDummyValidationAttribute
|
|
{
|
|
}
|
|
|
|
// Default IValidatableObject adapter factory
|
|
|
|
[Fact]
|
|
public void IValidatableObjectGetsAValidator()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var mockValidatable = new Mock<IValidatableObject>();
|
|
var metadata = _metadataProvider.GetMetadataForType(() => null, mockValidatable.Object.GetType());
|
|
|
|
// Act
|
|
IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, _noValidatorProviders);
|
|
|
|
// Assert
|
|
Assert.Single(validators);
|
|
}
|
|
|
|
// Integration with metadata system
|
|
|
|
[Fact]
|
|
public void DoesNotReadPropertyValue()
|
|
{
|
|
// Arrange
|
|
var provider = new DataAnnotationsModelValidatorProvider();
|
|
var model = new ObservableModel();
|
|
ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
|
|
|
|
// Act
|
|
ModelValidator[] validators = provider.GetValidators(metadata, _noValidatorProviders).ToArray();
|
|
ModelValidationResult[] results = validators.SelectMany(o => o.Validate(metadata, model)).ToArray();
|
|
|
|
// Assert
|
|
Assert.Empty(validators);
|
|
Assert.False(model.PropertyWasRead());
|
|
}
|
|
|
|
private class ObservableModel
|
|
{
|
|
private bool _propertyWasRead;
|
|
|
|
public string TheProperty
|
|
{
|
|
get
|
|
{
|
|
_propertyWasRead = true;
|
|
return "Hello";
|
|
}
|
|
}
|
|
|
|
public bool PropertyWasRead()
|
|
{
|
|
return _propertyWasRead;
|
|
}
|
|
}
|
|
|
|
private class BaseModel
|
|
{
|
|
public virtual string MyProperty { get; set; }
|
|
}
|
|
|
|
private class DerivedModel : BaseModel
|
|
{
|
|
[StringLength(10)]
|
|
public override string MyProperty
|
|
{
|
|
get { return base.MyProperty; }
|
|
set { base.MyProperty = value; }
|
|
}
|
|
}
|
|
}
|
|
}
|