コード例 #1
0
        public void Setup_SetsUpExcludeFromValidationDelegates()
        {
            // Arrange & Act
            var options = GetOptions <MvcOptions>(services =>
            {
                var builder = new MvcCoreBuilder(services);
                builder.AddXmlDataContractSerializerFormatters();
            });

            // Assert
            Assert.Equal(8, options.ValidationExcludeFilters.Count);
            var i = 0;

            // Verify if the delegates registered by default exclude the given types.
            Assert.IsType(typeof(SimpleTypesExcludeFilter), options.ValidationExcludeFilters[i++]);

            Assert.IsType(typeof(DefaultTypeBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var typeFilter
                = Assert.IsType <DefaultTypeBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(typeFilter.ExcludedType, typeof(Type));

            Assert.IsType(typeof(DefaultTypeBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var cancellationTokenFilter
                = Assert.IsType <DefaultTypeBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(cancellationTokenFilter.ExcludedType, typeof(System.Threading.CancellationToken));

            Assert.IsType(typeof(DefaultTypeBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var formFileFilter
                = Assert.IsType <DefaultTypeBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(formFileFilter.ExcludedType, typeof(Http.IFormFile));

            Assert.IsType(
                typeof(DefaultTypeBasedExcludeFilter),
                options.ValidationExcludeFilters[i]);
            var formCollectionFilter
                = Assert.IsType <DefaultTypeBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(formCollectionFilter.ExcludedType, typeof(Http.IFormCollection));

            Assert.IsType(typeof(DefaultTypeBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var jTokenFilter
                = Assert.IsType <DefaultTypeBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(jTokenFilter.ExcludedType, typeof(JToken));

            Assert.IsType(typeof(DefaultTypeNameBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var xObjectFilter
                = Assert.IsType <DefaultTypeNameBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(xObjectFilter.ExcludedTypeName, typeof(XObject).FullName);

            Assert.IsType(typeof(DefaultTypeNameBasedExcludeFilter), options.ValidationExcludeFilters[i]);
            var xmlNodeFilter =
                Assert.IsType <DefaultTypeNameBasedExcludeFilter>(options.ValidationExcludeFilters[i++]);

            Assert.Equal(xmlNodeFilter.ExcludedTypeName, "System.Xml.XmlNode");
        }
コード例 #2
0
        public void Setup_SetsUpMetadataDetailsProviders()
        {
            // Arrange & Act
            var options = GetOptions <MvcOptions>(services =>
            {
                var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
                builder.AddXmlDataContractSerializerFormatters();
            });

            // Assert
            var providers = options.ModelMetadataDetailsProviders;

            Assert.Collection(providers,
                              provider => Assert.IsType <ExcludeBindingMetadataProvider>(provider),
                              provider => Assert.IsType <DefaultBindingMetadataProvider>(provider),
                              provider => Assert.IsType <DefaultValidationMetadataProvider>(provider),
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(Type), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(Uri), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(CancellationToken), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(IFormFile), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(IFormCollection), excludeFilter.Type);
            },
                              provider => Assert.IsType <DataAnnotationsMetadataProvider>(provider),
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(JToken), excludeFilter.Type);
            },
                              provider => Assert.IsType <DataMemberRequiredBindingMetadataProvider>(provider),
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(XObject).FullName, excludeFilter.FullTypeName);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <ValidationExcludeFilter>(provider);
                Assert.Equal(typeof(XmlNode).FullName, excludeFilter.FullTypeName);
            });
        }
コード例 #3
0
        public void Setup_SetsUpMetadataDetailsProviders()
        {
            // Arrange & Act
            var options = GetOptions <MvcOptions>(services =>
            {
                var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
                builder.AddXmlDataContractSerializerFormatters();
            });

            // Assert
            var providers = options.ModelMetadataDetailsProviders;

            Assert.Collection(providers,
                              provider => Assert.IsType <ExcludeBindingMetadataProvider>(provider),
                              provider => Assert.IsType <DefaultBindingMetadataProvider>(provider),
                              provider => Assert.IsType <DefaultValidationMetadataProvider>(provider),
                              provider =>
            {
                var specialParameter = Assert.IsType <BindingSourceMetadataProvider>(provider);
                Assert.Equal(typeof(CancellationToken), specialParameter.Type);
                Assert.Equal(BindingSource.Special, specialParameter.BindingSource);
            },
                              provider =>
            {
                var formFileParameter = Assert.IsType <BindingSourceMetadataProvider>(provider);
                Assert.Equal(typeof(IFormFile), formFileParameter.Type);
                Assert.Equal(BindingSource.FormFile, formFileParameter.BindingSource);
            },
                              provider =>
            {
                var formCollectionParameter = Assert.IsType <BindingSourceMetadataProvider>(provider);
                Assert.Equal(typeof(IFormCollection), formCollectionParameter.Type);
                Assert.Equal(BindingSource.FormFile, formCollectionParameter.BindingSource);
            },
                              provider =>
            {
                var formFileParameter = Assert.IsType <BindingSourceMetadataProvider>(provider);
                Assert.Equal(typeof(IFormFileCollection), formFileParameter.Type);
                Assert.Equal(BindingSource.FormFile, formFileParameter.BindingSource);
            },
                              provider =>
            {
                var formFileParameter = Assert.IsType <BindingSourceMetadataProvider>(provider);
                Assert.Equal(typeof(IEnumerable <IFormFile>), formFileParameter.Type);
                Assert.Equal(BindingSource.FormFile, formFileParameter.BindingSource);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(Type), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(Uri), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(CancellationToken), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(IFormFile), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(IFormCollection), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(IFormFileCollection), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(Stream), excludeFilter.Type);
            },
                              provider => Assert.IsType <DataAnnotationsMetadataProvider>(provider),
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(IJsonPatchDocument), excludeFilter.Type);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(JToken), excludeFilter.Type);
            },
                              provider => Assert.IsType <DataMemberRequiredBindingMetadataProvider>(provider),
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(XObject).FullName, excludeFilter.FullTypeName);
            },
                              provider =>
            {
                var excludeFilter = Assert.IsType <SuppressChildValidationMetadataProvider>(provider);
                Assert.Equal(typeof(XmlNode).FullName, excludeFilter.FullTypeName);
            },
                              provider => Assert.IsType <HasValidatorsValidationMetadataProvider>(provider));
        }