public async Task BindModel()
{
// Arrange
var metadataProvider = new EmptyModelMetadataProvider();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(typeof(IDictionary<int, string>)),
ModelName = "someName",
ValueProvider = new SimpleHttpValueProvider
{
{ "someName[0]", new KeyValuePair<int, string>(42, "forty-two") },
{ "someName[1]", new KeyValuePair<int, string>(84, "eighty-four") }
},
OperationBindingContext = new OperationBindingContext
{
ModelBinder = CreateKvpBinder(),
MetadataProvider = metadataProvider
}
};
var binder = new DictionaryModelBinder<int, string>();
// Act
var retVal = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotNull(retVal);
var dictionary = Assert.IsAssignableFrom<IDictionary<int, string>>(retVal.Model);
Assert.NotNull(dictionary);
Assert.Equal(2, dictionary.Count);
Assert.Equal("forty-two", dictionary[42]);
Assert.Equal("eighty-four", dictionary[84]);
}
public void GetModelValidator_DoesNotReadPropertyValues()
{
ModelValidatorProvider[] originalProviders = ModelValidatorProviders.Providers.ToArray();
try
{
// Arrange
ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider());
ObservableModel model = new ObservableModel();
ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel));
ControllerContext controllerContext = new ControllerContext();
// Act
ModelValidator validator = ModelValidator.GetModelValidator(metadata, controllerContext);
ModelValidationResult[] results = validator.Validate(model).ToArray();
// Assert
Assert.False(model.PropertyWasRead());
}
finally
{
ModelValidatorProviders.Providers.Clear();
foreach (ModelValidatorProvider provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public void GetModelValidators_ReturnsValidatorsFromAllProviders()
{
// Arrange
var validator1 = Mock.Of<IModelValidator>();
var validator2 = Mock.Of<IModelValidator>();
var validator3 = Mock.Of<IModelValidator>();
var provider1 = new Mock<IModelValidatorProvider>();
provider1.Setup(p => p.GetValidators(It.IsAny<ModelValidatorProviderContext>()))
.Callback<ModelValidatorProviderContext>(c =>
{
c.Validators.Add(validator1);
c.Validators.Add(validator2);
});
var provider2 = new Mock<IModelValidatorProvider>();
provider2.Setup(p => p.GetValidators(It.IsAny<ModelValidatorProviderContext>()))
.Callback<ModelValidatorProviderContext>(c =>
{
c.Validators.Add(validator3);
});
var compositeModelValidator = new CompositeModelValidatorProvider(new[] { provider1.Object, provider2.Object });
var modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(string));
// Act
var validatorProviderContext = new ModelValidatorProviderContext(modelMetadata);
compositeModelValidator.GetValidators(validatorProviderContext);
// Assert
Assert.Equal(
new[] { validator1, validator2, validator3 },
validatorProviderContext.Validators.ToArray());
}
public void DefaultValues()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new DefaultCompositeMetadataDetailsProvider(
Enumerable.Empty<IMetadataDetailsProvider>());
var key = ModelMetadataIdentity.ForType(typeof(string));
var cache = new DefaultMetadataDetails(key, new ModelAttributes(new object[0]));
// Act
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Assert
Assert.NotNull(metadata.AdditionalValues);
Assert.Empty(metadata.AdditionalValues);
Assert.Equal(typeof(string), metadata.ModelType);
Assert.True(metadata.ConvertEmptyStringToNull);
Assert.False(metadata.HasNonDefaultEditFormat);
Assert.False(metadata.HideSurroundingHtml);
Assert.True(metadata.HtmlEncode);
Assert.False(metadata.IsBindingRequired);
Assert.False(metadata.IsComplexType);
Assert.False(metadata.IsCollectionType);
Assert.False(metadata.IsEnum);
Assert.False(metadata.IsFlagsEnum);
Assert.False(metadata.IsNullableValueType);
Assert.False(metadata.IsReadOnly);
Assert.False(metadata.IsRequired);
Assert.True(metadata.ShowForDisplay);
Assert.True(metadata.ShowForEdit);
Assert.Null(metadata.DataTypeName);
Assert.Null(metadata.Description);
Assert.Null(metadata.DisplayFormatString);
Assert.Null(metadata.DisplayName);
Assert.Null(metadata.EditFormatString);
Assert.Null(metadata.EnumDisplayNamesAndValues);
Assert.Null(metadata.EnumNamesAndValues);
Assert.Null(metadata.NullDisplayText);
Assert.Null(metadata.TemplateHint);
Assert.Null(metadata.SimpleDisplayProperty);
Assert.Equal(10000, ModelMetadata.DefaultOrder);
Assert.Equal(ModelMetadata.DefaultOrder, metadata.Order);
Assert.Null(metadata.BinderModelName);
Assert.Null(metadata.BinderType);
Assert.Null(metadata.BindingSource);
Assert.Null(metadata.PropertyBindingPredicateProvider);
}
private static DefaultModelBindingContext GetBindingContext(Type modelType, HttpContext httpContext)
{
var metadataProvider = new EmptyModelMetadataProvider();
var bindingContext = new DefaultModelBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = httpContext,
},
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "file",
ValidationState = new ValidationStateDictionary(),
};
return bindingContext;
}
private static DefaultModelBindingContext GetBindingContext(Type modelType)
{
var metadataProvider = new EmptyModelMetadataProvider();
DefaultModelBindingContext bindingContext = new DefaultModelBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = new DefaultHttpContext(),
},
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = new SimpleValueProvider(),
ValidationState = new ValidationStateDictionary(),
};
return bindingContext;
}
public void CreateMetadataForType()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new DefaultCompositeMetadataDetailsProvider(
Enumerable.Empty<IMetadataDetailsProvider>());
var key = ModelMetadataIdentity.ForType(typeof(Exception));
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
// Act
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Assert
Assert.Equal(typeof(Exception), metadata.ModelType);
Assert.Null(metadata.PropertyName);
Assert.Null(metadata.ContainerType);
}
private static ModelBindingContext GetBindingContext(Type modelType)
{
var metadataProvider = new EmptyModelMetadataProvider();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = new SimpleHttpValueProvider(),
OperationBindingContext = new OperationBindingContext
{
ModelBinder = new CancellationTokenModelBinder(),
MetadataProvider = metadataProvider,
HttpContext = new DefaultHttpContext(),
}
};
return bindingContext;
}
public void GenerateErrorMessage_ErrorMessageOnContextAndModelStateUsesContextError_ReturnsContent()
{
// Arrange
var tagHelperContext = new TagHelperContext(
tagName: "test",
allAttributes: new TagHelperAttributeList(),
items: new Dictionary <object, object>(),
uniqueId: "test");
var formGroupContext = new TestFormGroupContext();
formGroupContext.SetErrorMessage(visuallyHiddenText: "vht", attributes: null, content: new HtmlString("Context error"));
var modelExplorer = new EmptyModelMetadataProvider().GetModelExplorerForType(typeof(Model), new Model())
.GetExplorerForProperty(nameof(Model.SimpleProperty));
var viewContext = new ViewContext();
var modelExpression = nameof(Model.SimpleProperty);
var modelHelper = new Mock <IModelHelper>();
modelHelper.Setup(mock => mock.GetValidationMessage(viewContext, modelExplorer, modelExpression)).Returns("ModelState error");
var tagHelper = new TestFormGroupTagHelper(new ComponentGenerator(), modelHelper.Object)
{
AspFor = new ModelExpression(modelExpression, modelExplorer),
Id = "test",
ViewContext = viewContext
};
// Act
var errorMessage = tagHelper.GenerateErrorMessage(tagHelperContext, formGroupContext);
// Assert
Assert.NotNull(errorMessage);
Assert.Contains("Context error", errorMessage.RenderToString());
}
public override async Task OnExceptionAsync(ExceptionContext context)
{
var exception = context.Exception;
string message = string.Empty;
if (exception.InnerException != null)
{
message = exception.InnerException.Message;
}
else
{
message = exception.Message;
}
// log exception here....
var result = new ViewResult {
ViewName = "SinjulMSBHError"
};
var modelMetadata = new EmptyModelMetadataProvider();
result.ViewData = new ViewDataDictionary(modelMetadata, context.ModelState);
result.ViewData.Add("Exception", message);
context.Result = result;
context.ExceptionHandled = true;
}
public async Task ProcessAsync_ThrowsIfActionAndPageProvided()
{
// Arrange
var metadataProvider = new EmptyModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var anchorTagHelper = new AnchorTagHelper(htmlGenerator)
{
Action = "Action",
Page = "Page",
};
var output = new TagHelperOutput(
"a",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) => Task.FromResult <TagHelperContent>(null));
var expectedErrorMessage = string.Join(
Environment.NewLine,
"Cannot determine the 'href' attribute for <a>. The following attributes are mutually exclusive:",
"asp-route",
"asp-controller, asp-action",
"asp-page, asp-page-handler");
var context = new TagHelperContext(
tagName: "test",
allAttributes: new TagHelperAttributeList(
Enumerable.Empty <TagHelperAttribute>()),
items: new Dictionary <object, object>(),
uniqueId: "test");
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => anchorTagHelper.ProcessAsync(context, output));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task OnPostCreateLoanApplicationAsync_ReturnsAPageResult_WhenModelStateIsInValid()
{
// Arrange
var authorizationService = new Mock <IAuthorizationService>();
authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >()))
.ReturnsAsync(AuthorizationResult.Success());
var store = new Mock <IUserStore <IdentityUser> >();
var mgr = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null);
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new CreateModel(AppDbContext, authorizationService.Object, mgr.Object)
{
PageContext = pageContext,
TempData = tempData,
Url = new UrlHelper(actionContext),
LoanApplication = new LoanApplication()
};
pageModel.ModelState.AddModelError("LoanApplication.Purpose", "Loan purpose is required.");
// Act
var result = await pageModel.OnPostAsync();
// Assert
Assert.IsType <PageResult>(result);
}
public void OnPost_ReturnsPageResult_WhenModelStateIsInvalid()
{
// Arrange
var mockRegionsRepo = new Mock <IRegionsRepository>();
var mockWeatherRepo = new Mock <IWeatherRepository>();
var expectedRegions = new RegionsRepository().GetRegionsSelectList();
mockRegionsRepo.Setup(x => x.GetRegionsSelectList()).Returns(expectedRegions);
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new IndexModel(mockRegionsRepo.Object, mockWeatherRepo.Object)
{
PageContext = pageContext,
TempData = tempData,
Url = new UrlHelper(actionContext)
};
pageModel.ModelState.AddModelError("ZipCode.Text", "The Text field is required.");
// Act
var result = pageModel.OnPost();
// Assert
var pageResult = result as PageResult;
Assert.IsNotNull(pageResult, "OnPost returns Null PageResult when Model State is Invalid");
Assert.IsNull(pageModel.WeatherInfo, "OnPost returns NON-Null WeatherInfo when Model State is Invalid");
}
public async Task JsonFormatterReadsSimpleTypes(string content, Type type, object expected)
{
// Arrange
var logger = GetLogger();
var formatter = new JsonInputFormatter(logger);
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(type);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.False(result.HasError);
Assert.Equal(expected, result.Model);
}
public void GetModelValidator_DoesNotReadPropertyValues()
{
ModelValidatorProvider[] originalProviders =
ModelValidatorProviders.Providers.ToArray();
try
{
// Arrange
ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider());
ObservableModel model = new ObservableModel();
ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(
() => model,
typeof(ObservableModel)
);
ControllerContext controllerContext = new ControllerContext();
// Act
ModelValidator validator = ModelValidator.GetModelValidator(
metadata,
controllerContext
);
ModelValidationResult[] results = validator.Validate(model).ToArray();
// Assert
Assert.False(model.PropertyWasRead());
}
finally
{
ModelValidatorProviders.Providers.Clear();
foreach (ModelValidatorProvider provider in originalProviders)
{
ModelValidatorProviders.Providers.Add(provider);
}
}
}
public void GenerateHint_HintOnContextAndModelMetadataDescriptionUsesContextHint_ReturnsContent()
{
// Arrange
var formGroupContext = new TestFormGroupContext();
formGroupContext.SetHint(attributes: null, content: new HtmlString("Context hint"));
var tagHelperContext = new TagHelperContext(
tagName: "test",
allAttributes: new TagHelperAttributeList(),
items: new Dictionary <object, object>(),
uniqueId: "test");
var modelExplorer = new EmptyModelMetadataProvider().GetModelExplorerForType(typeof(Model), new Model())
.GetExplorerForProperty(nameof(Model.SimpleProperty));
var viewContext = new ViewContext();
var modelExpression = nameof(Model.SimpleProperty);
var modelHelper = new Mock <IModelHelper>();
modelHelper.Setup(mock => mock.GetDescription(modelExplorer)).Returns("ModelState hint");
var tagHelper = new TestFormGroupTagHelper(new ComponentGenerator(), modelHelper.Object)
{
AspFor = new ModelExpression(modelExpression, modelExplorer),
Id = "test",
ViewContext = viewContext
};
// Act
var hint = tagHelper.GenerateHint(tagHelperContext, formGroupContext);
// Assert
Assert.NotNull(hint);
Assert.Contains("Context hint", hint.RenderToString());
}
public void ModelSetter_DifferentType_UpdatesModelMetadata(Type originalMetadataType)
{
// Arrange
var metadataProvider = new EmptyModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForType(originalMetadataType);
var explorer = new ModelExplorer(metadataProvider, metadata, model: null);
var viewData = new TestViewDataDictionary(metadataProvider)
{
ModelExplorer = explorer,
};
// Act
viewData.Model = true;
// Assert
Assert.NotNull(viewData.ModelExplorer);
Assert.NotNull(viewData.ModelMetadata);
Assert.NotSame(explorer, viewData.ModelExplorer);
Assert.Equal(typeof(bool), viewData.ModelMetadata.ModelType);
var model = Assert.IsType <bool>(viewData.Model);
Assert.True(model);
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var actionContext = GetActionContext(contentBytes);
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User));
var context = new InputFormatterContext(actionContext, metadata.ModelType);
actionContext.ModelState.MaxAllowedErrors = 3;
actionContext.ModelState.AddModelError("key1", "error1");
actionContext.ModelState.AddModelError("key2", "error2");
// Act
var model = await formatter.ReadAsync(context);
// Assert
Assert.False(actionContext.ModelState.ContainsKey("age"));
var error = Assert.Single(actionContext.ModelState[""].Errors);
Assert.IsType <TooManyModelErrorsException>(error.Exception);
}
public async Task OnPostAsync_ReturnsAPageResult_WhenModelStateIsInvalid(int resourceId)
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <ClippyContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockContext = new Mock <ClippyContext>(optionsBuilder.Options);
var expectedResource = DatabaseInitializer.GetSeedingResources().Single(r => r.Id == resourceId);
mockContext.Setup(db => db.GetResourceAsync(resourceId)).Returns(Task.FromResult(expectedResource));
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new EditModel(mockContext.Object)
{
PageContext = pageContext,
TempData = tempData,
Url = new UrlHelper(actionContext)
};
pageModel.ModelState.AddModelError("Title", "Title is required.");
// Act
var result = await pageModel.OnPostAsync(resourceId);
// Assert
Assert.IsType <PageResult>(result);
}
public async Task BindModelAsync_ReturnsNullWhenResponseCannotBeFound()
{
// Arrange
var binder = new OpenIddictModelBinder();
var provider = new EmptyModelMetadataProvider();
var context = new DefaultModelBindingContext {
ActionContext = new ActionContext()
{
HttpContext = new DefaultHttpContext(),
},
ModelMetadata = provider.GetMetadataForType(typeof(OpenIdConnectResponse)),
ValidationState = new ValidationStateDictionary()
};
// Act
await binder.BindModelAsync(context);
// Assert
Assert.True(context.Result.IsModelSet);
Assert.Null(context.Result.Model);
}
public void Validate_SkipsRemainingValidationIfModelStateIsInvalid()
{
// Because a property validator fails, the model validator shouldn't run
// Arrange
List <string> log = new List <string>();
LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log);
ModelMetadata modelMetadata = GetModelMetadata(model);
ControllerContext controllerContext = new ControllerContext()
{
Controller = new EmptyController()
};
ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "InvalidStringProperty");
node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.InvalidStringProperty"));
node.Validating += delegate {
log.Add("In OnValidating()");
};
node.Validated += delegate {
log.Add("In OnValidated()");
};
// Act
node.Validate(controllerContext);
// Assert
CollectionAssert.AreEqual(
new string[] { "In OnValidating()", "In IDataErrorInfo.get_Item('InvalidStringProperty')", "In OnValidated()" },
log);
Assert.AreEqual("Sample error message", controllerContext.Controller.ViewData.ModelState["theKey.InvalidStringProperty"].Errors[0].ErrorMessage);
}
private static ModelBindingContext GetBindingContext(
IValueProvider valueProvider,
IModelBinder innerBinder = null,
Type keyValuePairType = null)
{
var metataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metataProvider.GetMetadataForType(keyValuePairType ?? typeof(KeyValuePair <int, string>)),
ModelName = "someName",
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
ModelBinder = innerBinder ?? CreateIntBinder(),
MetadataProvider = metataProvider,
ValidatorProvider = new DataAnnotationsModelValidatorProvider(
new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(),
stringLocalizerFactory: null)
}
};
return(bindingContext);
}
public async Task CustomSerializerSettingsObject_TakesEffect()
{
// Arrange
// missing password property here
var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}");
var logger = GetLogger();
// by default we ignore missing members, so here explicitly changing it
var serializerSettings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Error
};
var jsonFormatter =
new JsonInputFormatter(logger, serializerSettings, ArrayPool <char> .Shared, _objectPoolProvider);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes, "application/json;charset=utf-8");
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(UserLogin));
var inputFormatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.IsValid);
var modelErrorMessage = modelState.Values.First().Errors[0].ErrorMessage;
Assert.Contains("Required property 'Password' not found in JSON", modelErrorMessage);
}
// Adds one or more errors for all properties in OrderedModel. But adds errors out of order.
private void AddOrderedErrors(ModelStateDictionary modelState)
{
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(OrderedModel), nameof(OrderedModel.Property3));
modelState.AddModelError("Property3", "This is an error for Property3.");
modelState.AddModelError("Property3", new InvalidCastException("An ignored Exception."), metadata);
modelState.AddModelError("Property2", "This is an error for Property2.");
modelState.AddModelError("Property2", "This is another error for Property2.");
modelState.AddModelError("OrderedProperty3", "This is an error for OrderedProperty3.");
modelState.AddModelError("OrderedProperty2", "This is an error for OrderedProperty2.");
modelState.AddModelError("OrderedProperty2", "This is another error for OrderedProperty2.");
modelState.AddModelError("LastProperty", "This is an error for LastProperty.");
modelState.AddModelError("Property1", "This is an error for Property1.");
modelState.AddModelError("Property1", "This is another error for Property1.");
modelState.AddModelError("OrderedProperty1", "This is an error for OrderedProperty1.");
modelState.AddModelError("OrderedProperty2", "This is yet-another error for OrderedProperty2.");
}
public async Task BindModelAsync_DoesNotTrimValue()
{
ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForProperty(typeof(AllTypesView), nameof(AllTypesView.StringField));
DefaultModelBindingContext context = new DefaultModelBindingContext();
NotTrimmedAttribute attribute = new NotTrimmedAttribute();
context.ModelMetadata = metadata;
context.ActionContext = new ActionContext();
context.ModelState = new ModelStateDictionary();
context.ModelName = nameof(AllTypesView.StringField);
context.ValueProvider = Substitute.For <IValueProvider>();
context.ActionContext.HttpContext = new DefaultHttpContext();
context.HttpContext.RequestServices = Substitute.For <IServiceProvider>();
context.ValueProvider.GetValue(context.ModelName).Returns(ValueProviderResult.None);
context.ValueProvider.GetValue(nameof(AllTypesView.StringField)).Returns(new ValueProviderResult(" Value "));
context.HttpContext.RequestServices.GetService(typeof(ILoggerFactory)).Returns(Substitute.For <ILoggerFactory>());
await attribute.BindModelAsync(context);
ModelBindingResult expected = ModelBindingResult.Success(" Value ");
ModelBindingResult actual = context.Result;
Assert.Equal(expected, actual);
}
// Adds errors for various parts of the model, including the root.
private void AddMultipleErrors(ModelStateDictionary modelState)
{
modelState.AddModelError("Property3.Property2", "This is an error for Property3.Property2.");
modelState.AddModelError("Property3.OrderedProperty3", "This is an error for Property3.OrderedProperty3.");
modelState.AddModelError("Property3.OrderedProperty2", "This is an error for Property3.OrderedProperty2.");
modelState.SetModelValue("Property3.Empty", rawValue: null, attemptedValue: null);
modelState.MarkFieldValid("Property3.Empty");
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(ValidationModel), nameof(ValidationModel.Property3));
modelState.AddModelError("Property3", "This is an error for Property3.");
modelState.AddModelError("Property3", new InvalidCastException("Exception will be ignored."), metadata);
metadata = provider.GetMetadataForProperty(typeof(ValidationModel), nameof(ValidationModel.Property2));
modelState.AddModelError("Property2", "This is an error for Property2.");
modelState.AddModelError("Property2", "This is another error for Property2.");
modelState.AddModelError("Property2", new OverflowException("Produces invalid value message"), metadata);
metadata = provider.GetMetadataForType(typeof(ValidationModel));
modelState.AddModelError(string.Empty, "This is an error for the model root.");
modelState.AddModelError(string.Empty, "This is another error for the model root.");
modelState.AddModelError(string.Empty, new InvalidOperationException("Another ignored Exception."), metadata);
}
public void CopyConstructorUsesPassedInModel()
{
// Arrange
var metadataProvider = new EmptyModelMetadataProvider();
var model = new TestModel();
var source = new ViewDataDictionary(metadataProvider)
{
Model = "string model"
};
source["key1"] = "value1";
// Act
var viewData = new ViewDataDictionary(source, model);
// Assert
Assert.NotNull(viewData.ModelState);
Assert.NotNull(viewData.TemplateInfo);
Assert.Same(model, viewData.Model);
Assert.NotNull(viewData.ModelMetadata);
Assert.Equal(typeof(TestModel), viewData.ModelMetadata.ModelType);
Assert.Equal("value1", viewData["key1"]);
Assert.IsType <CopyOnWriteDictionary <string, object> >(viewData.Data);
}
public void Properties_UsesRuntimeType()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var modelExplorer = provider.GetModelExplorerForType(typeof(BaseClass), new DerivedClass());
// Act
var properties = modelExplorer.Properties.ToArray();
// Assert
Assert.Equal(2, properties.Length);
var baseProperty = Assert.Single(properties, p => p.Metadata.PropertyName == "Base1");
Assert.Equal(typeof(int), baseProperty.Metadata.ModelType);
Assert.Equal(typeof(DerivedClass), baseProperty.Metadata.ContainerType);
Assert.Same(modelExplorer, baseProperty.Container);
var derivedProperty = Assert.Single(properties, p => p.Metadata.PropertyName == "Derived1");
Assert.Equal(typeof(string), derivedProperty.Metadata.ModelType);
Assert.Equal(typeof(DerivedClass), derivedProperty.Metadata.ContainerType);
Assert.Same(modelExplorer, derivedProperty.Container);
}
public async Task ProcessAsync_ThrowsIfRouteAndActionOrControllerProvided(string propertyName)
{
// Arrange
var metadataProvider = new EmptyModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var anchorTagHelper = new AnchorTagHelper(htmlGenerator)
{
Route = "Default",
};
typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home");
var output = new TagHelperOutput(
"a",
attributes: new TagHelperAttributeList());
var expectedErrorMessage = "Cannot determine an 'href' attribute for <a>. An <a> with a specified " +
"'asp-route' must not have an 'asp-action' or 'asp-controller' attribute.";
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => anchorTagHelper.ProcessAsync(context: null, output: output));
Assert.Equal(expectedErrorMessage, ex.Message);
}
public async Task ReadAsync_AcceptsUTF16Characters()
{
// Arrange
var expectedInt = 10;
var expectedString = "TestString";
var input = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>" +
"<TestLevelOne><SampleInt>" + expectedInt + "</SampleInt>" +
"<sampleString>" + expectedString + "</sampleString></TestLevelOne>";
var formatter = new XmlDataContractSerializerInputFormatter(new MvcOptions());
var contentBytes = Encoding.Unicode.GetBytes(input);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes, contentType: "application/xml; charset=utf-16");
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(TestLevelOne));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.NotNull(result);
Assert.False(result.HasError);
var model = Assert.IsType <TestLevelOne>(result.Model);
Assert.Equal(expectedInt, model.SampleInt);
Assert.Equal(expectedString, model.sampleString);
}
public void Constructor_SerializesErrorsFromModelStateDictionary_AddsDefaultMessage()
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));
modelStateDictionary.AddModelError("unsafeError",
new Exception("This message should not be returned to clients"),
metadata);
// Act
var problemDescription = new ValidationProblemDetails(modelStateDictionary);
// Assert
Assert.Equal("One or more validation errors occurred.", problemDescription.Title);
Assert.Collection(
problemDescription.Errors,
item =>
{
Assert.Equal("unsafeError", item.Key);
Assert.Equal(new[] { "The input was not valid." }, item.Value);
});
}
public override void OnException(ExceptionContext context)
{
_logger.LogError(default(int), context.Exception, context.Exception.Message);
var result = new ViewResult {
ViewName = "~/Views/Home/Error.cshtml"
};
var modelMetadata = new EmptyModelMetadataProvider();
result.ViewData = new ViewDataDictionary(
modelMetadata, context.ModelState)
{
{
"Exception", context.Exception
}
};
result.ViewData.Model = new ErrorViewModel {
RequestId = Activity.Current?.Id ?? context.HttpContext.TraceIdentifier
};
result.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Result = result;
context.ExceptionHandled = true;
}
public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead)
{
// Arrange
var formatter = new XmlSerializerInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes("content");
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes, contentType: requestContentType);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(string));
var formatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = formatter.CanRead(formatterContext);
// Assert
Assert.Equal(expectedCanRead, result);
}
public void DropDownListFor_NullSelectListFindsListFromViewData()
{
// Arrange
var expectedHtml = "<select id=\"HtmlEncode[[Property1]]\" name=\"HtmlEncode[[Property1]]\">" +
"<option selected=\"HtmlEncode[[selected]]\" value=\"HtmlEncode[[0]]\">HtmlEncode[[Zero]]</option>" + Environment.NewLine +
"<option value=\"HtmlEncode[[1]]\">HtmlEncode[[One]]</option>" + Environment.NewLine +
"<option value=\"HtmlEncode[[2]]\">HtmlEncode[[Two]]</option>" + Environment.NewLine +
"<option value=\"HtmlEncode[[3]]\">HtmlEncode[[Three]]</option>" + Environment.NewLine +
"</select>";
var metadataProvider = new EmptyModelMetadataProvider();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary <TestModel>(metadataProvider));
helper.ViewContext.ClientValidationEnabled = false;
helper.ViewData["Property1"] = BasicSelectList;
helper.ViewData.Model = new TestModel {
Property1 = 0
};
// Act
var dropDownListForResult = helper.DropDownListFor(m => m.Property1, selectList: null);
// Assert
Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(dropDownListForResult));
}
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider, IModelBinder innerBinder = null)
{
var metataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metataProvider.GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
ModelName = "someName",
ValueProvider = valueProvider,
ModelBinder = innerBinder ?? CreateIntBinder(),
MetadataProvider = metataProvider,
ValidatorProviders = Enumerable.Empty<IModelValidatorProvider>()
};
return bindingContext;
}
public void CreateMetadataForProperty()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
var key = ModelMetadataIdentity.ForProperty(typeof(string), "Message", typeof(Exception));
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
// Act
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Assert
Assert.Equal(typeof(string), metadata.ModelType);
Assert.Equal("Message", metadata.PropertyName);
Assert.Equal(typeof(Exception), metadata.ContainerType);
}
private static DefaultModelBindingContext GetBindingContext(
Type modelType,
IEnumerable<IInputFormatter> inputFormatters = null,
HttpContext httpContext = null,
IModelMetadataProvider metadataProvider = null)
{
if (httpContext == null)
{
httpContext = new DefaultHttpContext();
}
if (inputFormatters == null)
{
inputFormatters = Enumerable.Empty<IInputFormatter>();
}
if (metadataProvider == null)
{
metadataProvider = new EmptyModelMetadataProvider();
}
var operationBindingContext = new OperationBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = httpContext,
},
InputFormatters = inputFormatters.ToList(),
MetadataProvider = metadataProvider,
};
var bindingContext = new DefaultModelBindingContext
{
FieldName = "someField",
IsTopLevelObject = true,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of<IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BindingSource = BindingSource.Body,
};
return bindingContext;
}
public void PropertiesEnumerationEvaluatedOnce()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
var key = ModelMetadataIdentity.ForType(typeof(string));
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Act
var firstPropertiesEvaluation = metadata.Properties.ToList();
var secondPropertiesEvaluation = metadata.Properties.ToList();
// Assert
// Identical ModelMetadata objects every time we run through the Properties collection.
Assert.Equal(firstPropertiesEvaluation, secondPropertiesEvaluation);
}
public async Task ProcessAsync_DoesNotUseGenerator_IfSelectedNullOrNoSelectedValues(
string originalContent,
string selected,
string value,
ICollection <string> currentValues,
TagHelperOutput _)
{
// Arrange
var originalAttributes = new TagHelperAttributeList
{
{ "label", "my-label" },
{ "selected", selected },
};
var originalTagName = "not-option";
var contextAttributes = new TagHelperAttributeList
{
{ "label", "my-label" },
{ "selected", selected },
{ "value", value },
};
var originalPreContent = "original pre-content";
var originalPostContent = "original post-content";
var tagHelperContext = new TagHelperContext(
tagName: "option",
allAttributes: contextAttributes,
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
originalTagName,
originalAttributes,
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent(originalContent);
return(Task.FromResult <TagHelperContent>(tagHelperContent));
})
{
TagMode = TagMode.StartTagAndEndTag,
};
output.PreContent.SetContent(originalPreContent);
output.Content.SetContent(originalContent);
output.PostContent.SetContent(originalPostContent);
var metadataProvider = new EmptyModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
tagHelperContext.Items[typeof(SelectTagHelper)] = currentValues == null ? null : new CurrentValues(currentValues);
var tagHelper = new OptionTagHelper(htmlGenerator)
{
Value = value,
ViewContext = viewContext,
};
// Act & Assert (does not throw)
// Tag helper would throw an NRE if it used Generator value.
await tagHelper.ProcessAsync(tagHelperContext, output);
}
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider, Type modelType)
{
var metadataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "foo",
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
MetadataProvider = metadataProvider,
}
};
return bindingContext;
}
public void GetMetadataForPropertiesContainerTest()
{
// Arrange
PropertyModel model = new PropertyModel { LocalAttributes = 42, MetadataAttributes = "hello", MixedAttributes = 21.12 };
EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
// Act
List<ModelMetadata> metadata = provider.GetMetadataForProperties(model, typeof(PropertyModel)).ToList();
// Assert
Assert.Equal(3, metadata.Count());
Assert.Same(model, metadata[0].Container);
Assert.Same(model, metadata[1].Container);
Assert.Same(model, metadata[2].Container);
}
private static DefaultModelBindingContext GetBindingContext(
Type modelType,
HttpContext httpContext = null,
IModelMetadataProvider metadataProvider = null)
{
if (httpContext == null)
{
httpContext = new DefaultHttpContext();
}
if (metadataProvider == null)
{
metadataProvider = new EmptyModelMetadataProvider();
}
var bindingContext = new DefaultModelBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = httpContext,
},
FieldName = "someField",
IsTopLevelObject = true,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of<IValueProvider>(),
ModelState = new ModelStateDictionary(),
BindingSource = BindingSource.Body,
};
return bindingContext;
}
private static ModelBindingContext GetBindingContext(
IValueProvider valueProvider,
IModelBinder innerBinder = null,
Type keyValuePairType = null)
{
var metataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metataProvider.GetMetadataForType(keyValuePairType ?? typeof(KeyValuePair<int, string>)),
ModelName = "someName",
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
ModelBinder = innerBinder ?? CreateIntBinder(),
MetadataProvider = metataProvider,
ValidatorProvider = new DataAnnotationsModelValidatorProvider()
}
};
return bindingContext;
}
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider)
{
var metadataProvider = new EmptyModelMetadataProvider();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(null, typeof(int[])),
ModelName = "someName",
ValueProvider = valueProvider,
ModelBinder = CreateIntBinder(),
MetadataProvider = metadataProvider
};
return bindingContext;
}
private static ModelBindingContext GetModelBindingContext(IValueProvider valueProvider)
{
var metadataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(typeof(int)),
ModelName = "someName",
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
ModelBinder = CreateIntBinder(),
MetadataProvider = metadataProvider
}
};
return bindingContext;
}
public void SimpleDisplayTextReturnsFirstPropertyValueForNonNullModel()
{
// Arrange
SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString
{
FirstProperty = "First Property Value"
};
EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.Equal(model.FirstProperty, result);
}
private static ModelMetadata GetMetadata() {
ModelMetadataProvider provider = new EmptyModelMetadataProvider();
return provider.GetMetadataForType(null, typeof(object));
}
public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithNoVisibleProperties()
{
// Arrange
SimpleDisplayTextModelWithNoProperties model = new SimpleDisplayTextModelWithNoProperties();
EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithNoProperties), null);
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.Equal(String.Empty, result);
}
public void AddValidation_ExistingInteger()
{
IModelMetadataProvider provider = new EmptyModelMetadataProvider();
ModelMetadata metadata = provider.GetMetadataForType(typeof(Int64));
Dictionary <String, String> attributes = new() { ["data-val-integer"] = "Test" };
private static ModelValidationNode GetValidationNode()
{
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(null, typeof(object));
return new ModelValidationNode(metadata, "someKey");
}
public void SimpleDisplayTextReturnsToStringValueWhenOverridden()
{
// Arrange
SimpleDisplayTextModelWithToString model = new SimpleDisplayTextModelWithToString();
EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithToString), null);
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.Equal(model.ToString(), result);
}
public void CreateMetadataForParameter()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
var methodInfo = GetType().GetMethod(
"ActionMethod",
BindingFlags.Instance | BindingFlags.NonPublic);
var parameterInfo = methodInfo.GetParameters().Where(p => p.Name == "input").Single();
var key = ModelMetadataIdentity.ForParameter(parameterInfo);
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
// Act
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
Assert.Equal(typeof(string), metadata.ModelType);
Assert.Equal("input", metadata.PropertyName);
Assert.Null(metadata.ContainerType);
}
public void SimpleDisplayTextReturnsFirstPropertyNullDisplayTextForNonNullModelWithNullDisplayColumnPropertyValue()
{
// Arrange
SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString();
EmptyModelMetadataProvider propertyProvider = new EmptyModelMetadataProvider();
ModelMetadata propertyMetadata = propertyProvider.GetMetadataForProperty(() => model.FirstProperty, typeof(SimpleDisplayTextModelWithoutToString), "FirstProperty");
propertyMetadata.NullDisplayText = "Null Display Text";
Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
provider.Setup(p => p.GetMetadataForProperties(model, typeof(SimpleDisplayTextModelWithoutToString)))
.Returns(new[] { propertyMetadata });
ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.Equal(propertyMetadata.NullDisplayText, result);
}
public void IsRequired_ReturnsTrue_ForNonNullableTypes(Type modelType)
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
var key = ModelMetadataIdentity.ForType(modelType);
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Act
var isRequired = metadata.IsRequired;
// Assert
Assert.True(isRequired);
}
public async Task ProcessAsync_GeneratesExpectedOutput(
string originalContent,
string selected,
string value,
ICollection <string> currentValues,
TagHelperOutput expectedTagHelperOutput)
{
// Arrange
var originalAttributes = new TagHelperAttributeList
{
{ "label", "my-label" },
};
if (selected != null)
{
originalAttributes.Add("selected", selected);
}
var contextAttributes = new TagHelperAttributeList(originalAttributes);
if (value != null)
{
contextAttributes.Add("value", value);
}
var tagHelperContext = new TagHelperContext(
tagName: "option",
allAttributes: contextAttributes,
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagHelperOutput.TagName,
originalAttributes,
getChildContentAsync: (useCachedResult, encoder) =>
{
// GetChildContentAsync should not be invoked since we are setting the content below.
Assert.True(false);
return(Task.FromResult <TagHelperContent>(null));
})
{
TagMode = TagMode.StartTagAndEndTag
};
output.Content.SetContent(originalContent);
var metadataProvider = new EmptyModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
tagHelperContext.Items[typeof(SelectTagHelper)] = currentValues == null ? null : new CurrentValues(currentValues);
var tagHelper = new OptionTagHelper(htmlGenerator)
{
Value = value,
ViewContext = viewContext,
};
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedTagHelperOutput.TagName, output.TagName);
Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent());
Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count);
foreach (var attribute in output.Attributes)
{
Assert.Contains(attribute, expectedTagHelperOutput.Attributes);
}
}
public void PropertiesSetOnce()
{
// Arrange
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
var key = ModelMetadataIdentity.ForType(typeof(string));
var cache = new DefaultMetadataDetailsCache(key, new object[0]);
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
// Act
var firstPropertiesEvaluation = metadata.Properties;
var secondPropertiesEvaluation = metadata.Properties;
// Assert
// Same IEnumerable<ModelMetadata> object.
Assert.Same(firstPropertiesEvaluation, secondPropertiesEvaluation);
}
private static ModelMetadata GetMetadata()
{
ModelMetadataProvider provider = new EmptyModelMetadataProvider();
return(provider.GetMetadataForType(null, typeof(object)));
}
private static ModelBindingContext GetBindingContext(
IValueProvider valueProvider,
IModelBinder innerBinder = null,
Type keyValuePairType = null)
{
var metataProvider = new EmptyModelMetadataProvider();
var bindingContext = new ModelBindingContext
{
ModelMetadata = metataProvider.GetMetadataForType(
keyValuePairType ?? typeof(KeyValuePair<int, string>)),
ModelName = "someName",
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
ModelBinder = innerBinder ?? CreateIntBinder(),
MetadataProvider = metataProvider,
ValidatorProvider = new DataAnnotationsModelValidatorProvider(
new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(),
stringLocalizerFactory: null)
}
};
return bindingContext;
}
