public void Activate_InitializesTagHelpersWithMultipleInitializers()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services);
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = "Test 1";
h.Number = 100;
});
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name += ", Test 2";
h.Number += 100;
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var activator = new DefaultTagHelperActivator();
var helper = new TestTagHelper();
// Act
activator.Activate(helper, viewContext);
// Assert
Assert.Equal("Test 1, Test 2", helper.Name);
Assert.Equal(200, helper.Number);
}
public void Activate_InitializesTagHelpers(string name, int number)
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services);
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = name;
h.Number = number;
h.ViewDataValue = vc.ViewData["TestData"];
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var viewDataValue = new object();
viewContext.ViewData.Add("TestData", viewDataValue);
var activator = new DefaultTagHelperActivator();
var helper = new TestTagHelper();
// Act
activator.Activate(helper, viewContext);
// Assert
Assert.Equal(name, helper.Name);
Assert.Equal(number, helper.Number);
Assert.Same(viewDataValue, helper.ViewDataValue);
}
public void Activate_InitializesTagHelpersWithCorrectInitializers()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services);
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = "Test 1";
h.Number = 100;
});
builder.InitializeTagHelper <AnotherTestTagHelper>((h, vc) =>
{
h.Name = "Test 2";
h.Number = 102;
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var activator = new DefaultTagHelperActivator();
var testTagHelper = new TestTagHelper();
var anotherTestTagHelper = new AnotherTestTagHelper();
// Act
activator.Activate(testTagHelper, viewContext);
activator.Activate(anotherTestTagHelper, viewContext);
// Assert
Assert.Equal("Test 1", testTagHelper.Name);
Assert.Equal(100, testTagHelper.Number);
Assert.Equal("Test 2", anotherTestTagHelper.Name);
Assert.Equal(102, anotherTestTagHelper.Number);
}
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");
}
public void CreateTagHelper_InitializesTagHelpersWithMultipleInitializers()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = "Test 1";
h.Number = 100;
});
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name += ", Test 2";
h.Number += 100;
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var factory = CreateFactory();
// Act
var helper = factory.CreateTagHelper <TestTagHelper>(viewContext);
// Assert
Assert.Equal("Test 1, Test 2", helper.Name);
Assert.Equal(200, helper.Number);
}
public void CreateTagHelper_InitializesTagHelpers(string name, int number)
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = name;
h.Number = number;
h.ViewDataValue = vc.ViewData["TestData"];
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var viewDataValue = new object();
viewContext.ViewData.Add("TestData", viewDataValue);
var factory = CreateFactory();
// Act
var helper = factory.CreateTagHelper <TestTagHelper>(viewContext);
// Assert
Assert.Equal(name, helper.Name);
Assert.Equal(number, helper.Number);
Assert.Same(viewDataValue, helper.ViewDataValue);
}
public void ConfigureApiBehaviorOptions_InvokesSetupAction()
{
// Arrange
var serviceCollection = new ServiceCollection()
.AddOptions();
var builder = new MvcCoreBuilder(
serviceCollection,
new ApplicationPartManager());
var part = new TestApplicationPart();
// Act
var result = builder.ConfigureApiBehaviorOptions(o =>
{
o.SuppressMapClientErrors = true;
});
// Assert
var options = serviceCollection.
BuildServiceProvider()
.GetRequiredService <IOptions <ApiBehaviorOptions> >()
.Value;
Assert.True(options.SuppressMapClientErrors);
}
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);
});
}
private static IServiceProvider MvcCoreBuilder()
{
var services = new ServiceCollection();
var mvc = new MvcCoreBuilder(services, new ApplicationPartManager());
mvc.AddFluentRestBuilder();
return(services.BuildServiceProvider());
}
public void WithService <TService>(FeatureOptions options)
where TService : BaseStateMachineService <TKey, TGraphEnum, TVertexEnum, TSubject, TRepository>
{
Services.AddScoped <TService>();
Services.AddScoped <BaseStateMachineService <TKey, TGraphEnum, TVertexEnum, TSubject, TRepository>, TService>();
Services.AddScoped <IStateMachineMetaService <TKey> >(serviceProvider => serviceProvider.GetRequiredService <TService>());
MvcCoreBuilder.AddMvcOptions(o =>
{
o.Conventions.Add(new StateMachineControllerNameConvention <TKey, TSubject>(options.SubjectControllerName));
});
}
private static void TestCoreBuilderInternal <TResolver>(Action <IMvcCoreBuilder> useAction)
where TResolver : IJsonFormatterResolver <byte, TResolver>, new()
{
var options = GetOptions <MvcOptions>(services =>
{
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
useAction(builder);
});
Assert.NotNull(options);
Assert.Single(options.InputFormatters);
Assert.Single(options.OutputFormatters);
Assert.IsType <SpanJsonInputFormatter <TResolver> >(options.InputFormatters[0]);
Assert.IsType <SpanJsonOutputFormatter <TResolver> >(options.OutputFormatters[0]);
}
public async Task FormTagHelper_GeneratesExpectedContent(bool?optionsAntiforgery)
{
// Arrange
var newServices = new ServiceCollection();
var builder = new MvcCoreBuilder(newServices);
builder.InitializeTagHelper <FormTagHelper>((helper, _) => helper.Antiforgery = optionsAntiforgery);
var server = TestHelper.CreateServer(_app, SiteName,
services =>
{
services.Add(newServices);
_configureServices(services);
});
var client = server.CreateClient();
var expectedMediaType = MediaTypeHeaderValue.Parse("text/html; charset=utf-8");
var outputFile = string.Format(
"compiler/resources/HtmlGenerationWebSite.HtmlGeneration_Home.Form.Options.Antiforgery.{0}.html",
optionsAntiforgery?.ToString() ?? "null");
var expectedContent =
await ResourceFile.ReadResourceAsync(_resourcesAssembly, outputFile, sourceFile : false);
// Act
// The host is not important as everything runs in memory and tests are isolated from each other.
var response = await client.GetAsync("http://localhost/HtmlGeneration_Home/Form");
var responseContent = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expectedMediaType, response.Content.Headers.ContentType);
responseContent = responseContent.Trim();
var forgeryTokens = AntiforgeryTestHelper.RetrieveAntiforgeryTokens(responseContent).ToArray();
#if GENERATE_BASELINES
// Reverse usual substitutions and insert format items into the new file content.
for (var index = 0; index < forgeryTokens.Length; index++)
{
responseContent = responseContent.Replace(forgeryTokens[index], $"{{{ index }}}");
}
ResourceFile.UpdateFile(_resourcesAssembly, outputFile, expectedContent, responseContent);
#else
expectedContent = string.Format(expectedContent, forgeryTokens);
Assert.Equal(expectedContent.Trim(), responseContent, ignoreLineEndingDifferences: true);
#endif
}
public void CreateTagHelper_InitializesTagHelpersAfterActivatingProperties()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
builder.InitializeTagHelper <TestTagHelper>((h, _) => h.ViewContext = MakeViewContext(MakeHttpContext()));
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var factory = CreateFactory();
// Act
var helper = factory.CreateTagHelper <TestTagHelper>(viewContext);
// Assert
Assert.NotSame(viewContext, helper.ViewContext);
}
public void AddApplicationPart_AddsAnApplicationPart_ToTheListOfPartsOnTheBuilder()
{
// Arrange
var manager = new ApplicationPartManager();
var builder = new MvcCoreBuilder(Mock.Of <IServiceCollection>(), manager);
var assembly = typeof(MvcCoreBuilder).Assembly;
// Act
var result = builder.AddApplicationPart(assembly);
// Assert
Assert.Same(result, builder);
var part = Assert.Single(builder.PartManager.ApplicationParts);
var assemblyPart = Assert.IsType <AssemblyPart>(part);
Assert.Equal(assembly, assemblyPart.Assembly);
}
protected void AddSpaPolicy(SchemeOwnerIdentityProviderOptions options)
{
MvcCoreBuilder.AddAuthorization(opt =>
{
opt.AddPolicy(SpaConstants.SpaPolicy,
policy =>
{
if (options.Enable)
{
policy.RequireClaim("scope", options.Scope);
}
else
{
policy.RequireAssertion(_ => true);
}
});
});
}
public void UseOpenIddict_MvcCoreBuilder_RegistersModelBinderProvider()
{
// Arrange
var services = new ServiceCollection();
services.AddOptions();
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
// Act
builder.UseOpenIddict();
var provider = services.BuildServiceProvider();
var options = provider.GetRequiredService <IOptions <MvcOptions> >();
// Assert
Assert.Contains(options.Value.ModelBinderProviders, binder => binder is OpenIddictMvcBinderProvider);
}
public void Activate_InitializesTagHelpersAfterActivatingProperties()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services);
builder.InitializeTagHelper <TestTagHelper>((h, _) => h.ViewContext = MakeViewContext(MakeHttpContext()));
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var activator = new DefaultTagHelperActivator();
var helper = new TestTagHelper();
// Act
activator.Activate(helper, viewContext);
// Assert
Assert.NotSame(viewContext, helper.ViewContext);
}
public void ConfigureApplicationParts_InvokesSetupAction()
{
// Arrange
var builder = new MvcCoreBuilder(
Mock.Of <IServiceCollection>(),
new ApplicationPartManager());
var part = new TestApplicationPart();
// Act
var result = builder.ConfigureApplicationPartManager(manager =>
{
manager.ApplicationParts.Add(part);
});
// Assert
Assert.Same(result, builder);
Assert.Equal(new ApplicationPart[] { part }, builder.PartManager.ApplicationParts.ToArray());
}
public void AddTagHelpersAsServices_RegistersDiscoveredTagHelpers()
{
// Arrange
var services = new ServiceCollection();
var manager = new ApplicationPartManager();
manager.ApplicationParts.Add(new TestApplicationPart(
typeof(TestTagHelperOne),
typeof(TestTagHelperTwo)));
manager.FeatureProviders.Add(new TestFeatureProvider());
var builder = new MvcCoreBuilder(services, manager);
// Act
builder.AddTagHelpersAsServices();
// Assert
var collection = services.ToList();
Assert.Equal(4, collection.Count);
var tagHelperOne = Assert.Single(collection, t => t.ServiceType == typeof(TestTagHelperOne));
Assert.Equal(typeof(TestTagHelperOne), tagHelperOne.ImplementationType);
Assert.Equal(ServiceLifetime.Transient, tagHelperOne.Lifetime);
var tagHelperTwo = Assert.Single(collection, t => t.ServiceType == typeof(TestTagHelperTwo));
Assert.Equal(typeof(TestTagHelperTwo), tagHelperTwo.ImplementationType);
Assert.Equal(ServiceLifetime.Transient, tagHelperTwo.Lifetime);
var activator = Assert.Single(collection, t => t.ServiceType == typeof(ITagHelperActivator));
Assert.Equal(typeof(ServiceBasedTagHelperActivator), activator.ImplementationType);
Assert.Equal(ServiceLifetime.Transient, activator.Lifetime);
var typeResolver = Assert.Single(collection, t => t.ServiceType == typeof(ITagHelperTypeResolver));
Assert.Equal(typeof(FeatureTagHelperTypeResolver), typeResolver.ImplementationType);
Assert.Equal(ServiceLifetime.Transient, typeResolver.Lifetime);
}
/// <summary>
/// Adds the minimum essential MVC services to the specified <see cref="IServiceCollection" />. Additional services
/// including MVC's support for authorization, formatters, and validation must be added separately using the
/// <see cref="IMvcCoreBuilder"/> returned from this method.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection" /> to add services to.</param>
/// <returns>An <see cref="IMvcCoreBuilder"/> that can be used to further configure the MVC services.</returns>
/// <remarks>
/// The <see cref="MvcCoreServiceCollectionExtensions.AddMvcCore(IServiceCollection)"/> approach for configuring
/// MVC is provided for experienced MVC developers who wish to have full control over the set of default services
/// registered. <see cref="MvcCoreServiceCollectionExtensions.AddMvcCore(IServiceCollection)"/> will register
/// the minimum set of services necessary to route requests and invoke controllers. It is not expected that any
/// application will satisfy its requirements with just a call to
/// <see cref="MvcCoreServiceCollectionExtensions.AddMvcCore(IServiceCollection)"/>. Additional configuration using the
/// <see cref="IMvcCoreBuilder"/> will be required.
/// </remarks>
public static IMvcCoreBuilder AddMvcCore(this IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var environment = GetServiceFromCollection <IWebHostEnvironment>(services);
var partManager = GetApplicationPartManager(services, environment);
services.TryAddSingleton(partManager);
ConfigureDefaultFeatureProviders(partManager);
ConfigureDefaultServices(services);
AddMvcCoreServices(services);
var builder = new MvcCoreBuilder(services, partManager);
return(builder);
}
public void CreateTagHelper_InitializesTagHelpersWithCorrectInitializers()
{
// Arrange
var services = new ServiceCollection();
var builder = new MvcCoreBuilder(services, new ApplicationPartManager());
builder.InitializeTagHelper <TestTagHelper>((h, vc) =>
{
h.Name = "Test 1";
h.Number = 100;
});
builder.InitializeTagHelper <AnotherTestTagHelper>((h, vc) =>
{
h.Name = "Test 2";
h.Number = 102;
});
var httpContext = MakeHttpContext(services.BuildServiceProvider());
var viewContext = MakeViewContext(httpContext);
var activator = new Mock <ITagHelperActivator>();
activator
.Setup(a => a.Create <TestTagHelper>(It.IsAny <ViewContext>()))
.Returns(new TestTagHelper());
activator
.Setup(a => a.Create <AnotherTestTagHelper>(It.IsAny <ViewContext>()))
.Returns(new AnotherTestTagHelper());
var factory = new DefaultTagHelperFactory(activator.Object);
// Act
var testTagHelper = factory.CreateTagHelper <TestTagHelper>(viewContext);
var anotherTestTagHelper = factory.CreateTagHelper <AnotherTestTagHelper>(viewContext);
// Assert
Assert.Equal("Test 1", testTagHelper.Name);
Assert.Equal(100, testTagHelper.Number);
Assert.Equal("Test 2", anotherTestTagHelper.Name);
Assert.Equal(102, anotherTestTagHelper.Number);
}
public void AddApplicationPart_UsesPartFactory_ToRetrieveApplicationParts()
{
// Arrange
var manager = new ApplicationPartManager();
var builder = new MvcCoreBuilder(Mock.Of <IServiceCollection>(), manager);
var assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Test"), AssemblyBuilderAccess.Run);
var attribute = new CustomAttributeBuilder(typeof(ProvideApplicationPartFactoryAttribute).GetConstructor(
new[] { typeof(Type) }),
new[] { typeof(TestApplicationPartFactory) });
assembly.SetCustomAttribute(attribute);
// Act
builder.AddApplicationPart(assembly);
// Assert
var part = Assert.Single(builder.PartManager.ApplicationParts);
Assert.Same(TestApplicationPartFactory.TestPart, part);
}
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));
}
