public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead) { // Arrange var loggerMock = GetLogger(); var formatter = new JsonInputFormatter(loggerMock, _serializerSettings, ArrayPool<char>.Shared, _objectPoolProvider); var contentBytes = Encoding.UTF8.GetBytes("content"); 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: new ModelStateDictionary(), metadata: metadata, readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader); // Act var result = formatter.CanRead(formatterContext); // Assert Assert.Equal(expectedCanRead, result); }
public void OnActionExecuting_ChangesActionResult_IfUnsupportedContentTypeExceptionIsFoundOnModelState() { // Arrange var context = new ActionExecutingContext( new ActionContext { HttpContext = new DefaultHttpContext(), RouteData = new RouteData(), ActionDescriptor = new ActionDescriptor() }, new List<IFilterMetadata>(), new Dictionary<string, object>(), new object()); var modelMetadata = new EmptyModelMetadataProvider() .GetMetadataForType(typeof(int)); context.ModelState.AddModelError( "person.body", new UnsupportedContentTypeException("error"), modelMetadata); var filter = new UnsupportedContentTypeFilter(); // Act filter.OnActionExecuting(context); // Assert Assert.NotNull(context.Result); var status = Assert.IsType<UnsupportedMediaTypeResult>(context.Result); }
public void AddModelError_WithErrorString_AddsTooManyModelErrors_WhenMaxErrorsIsReached() { // Arrange var expected = "The maximum number of allowed model errors has been reached."; var dictionary = new ModelStateDictionary { MaxAllowedErrors = 5 }; var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length)); dictionary.AddModelError("key1", "error1"); dictionary.AddModelError("key2", new Exception(), metadata); dictionary.AddModelError("key3", new Exception(), metadata); dictionary.AddModelError("key4", "error4"); dictionary.AddModelError("key5", "error5"); // Act and Assert Assert.True(dictionary.HasReachedMaxErrors); Assert.Equal(5, dictionary.ErrorCount); var error = Assert.Single(dictionary[string.Empty].Errors); Assert.IsType<TooManyModelErrorsException>(error.Exception); Assert.Equal(expected, error.Exception.Message); // TooManyModelErrorsException added instead of key5 error. Assert.DoesNotContain("key5", dictionary.Keys); }
public async Task JsonPatchInputFormatter_ReadsMultipleOperations_Successfully() { // Arrange var logger = GetLogger(); var formatter = new JsonPatchInputFormatter(logger); var content = "[{\"op\": \"add\", \"path\" : \"Customer/Name\", \"value\":\"John\"}," + "{\"op\": \"remove\", \"path\" : \"Customer/Name\"}]"; var contentBytes = Encoding.UTF8.GetBytes(content); var modelState = new ModelStateDictionary(); var httpContext = GetHttpContext(contentBytes); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(typeof(JsonPatchDocument<Customer>)); 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.False(result.HasError); var patchDoc = Assert.IsType<JsonPatchDocument<Customer>>(result.Model); Assert.Equal("add", patchDoc.Operations[0].op); Assert.Equal("Customer/Name", patchDoc.Operations[0].path); Assert.Equal("John", patchDoc.Operations[0].value); Assert.Equal("remove", patchDoc.Operations[1].op); Assert.Equal("Customer/Name", patchDoc.Operations[1].path); }
public StringLengthAdapterTests() { adapter = new StringLengthAdapter(new StringLengthAttribute(128)); IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = provider.GetMetadataForProperty(typeof(AdaptersModel), "StringLength"); context = new ModelValidationContextBase(new ActionContext(), metadata, provider); }
public EqualToAdapterTests() { attributes = new Dictionary<String, String>(); adapter = new EqualToAdapter(new EqualToAttribute("StringLength")); IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = provider.GetMetadataForProperty(typeof(AdaptersModel), "EqualTo"); context = new ClientModelValidationContext(new ActionContext(), metadata, provider, attributes); }
public FileSizeAdapterTests() { attributes = new Dictionary<String, String>(); adapter = new FileSizeAdapter(new FileSizeAttribute(12.25)); IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = provider.GetMetadataForProperty(typeof(AdaptersModel), "FileSize"); context = new ClientModelValidationContext(new ActionContext(), metadata, provider, attributes); }
public void GetBinder_ForNotStringReturnsNull() { IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelBinderProviderContext context = Substitute.For<ModelBinderProviderContext>(); context.Metadata.Returns(provider.GetMetadataForProperty(typeof(ProviderModel), "Date")); Assert.Null(new TrimmingModelBinderProvider().GetBinder(context)); }
public void CreateValidators_DoesNotCreate() { ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(String)); ClientValidatorProviderContext context = new ClientValidatorProviderContext(metadata, new List<ClientValidatorItem>()); new DateValidatorProvider().CreateValidators(context); Assert.Empty(context.Results); }
public void ModelType_UsesDeclaredType_WhenModelIsNull() { // Arrange var provider = new EmptyModelMetadataProvider(); var modelExplorer = provider.GetModelExplorerForType(typeof(BaseClass), model: null); // Act var modelType = modelExplorer.ModelType; // Assert Assert.Equal(typeof(BaseClass), modelType); }
public void CreateValidators_ForDate(Type type) { ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(type); ClientValidatorProviderContext context = new ClientValidatorProviderContext(metadata, new List<ClientValidatorItem>()); new DateValidatorProvider().CreateValidators(context); ClientValidatorItem actual = context.Results.Single(); Assert.IsType<DateValidator>(actual.Validator); Assert.Null(actual.ValidatorMetadata); Assert.True(actual.IsReusable); }
public void AddValidation_Date() { IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = provider.GetMetadataForType(typeof(DateTime)); Dictionary<String, String> attributes = new Dictionary<String, String>(); ClientModelValidationContext context = new ClientModelValidationContext(new ActionContext(), metadata, provider, attributes); new DateValidator().AddValidation(context); Assert.Equal(2, attributes.Count); Assert.Equal("true", attributes["data-val"]); Assert.Equal(String.Format(Validations.Date, "DateTime"), attributes["data-val-date"]); }
public async Task BindModelAsync_NoValue() { ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(String)); context.ValueProvider.GetValue(context.ModelName).Returns(ValueProviderResult.None); context.ModelMetadata = metadata; await binder.BindModelAsync(context); ModelBindingResult expected = new ModelBindingResult(); ModelBindingResult actual = context.Result; Assert.Equal(expected, actual); }
public void GetErrorMessage_Range() { IModelMetadataProvider provider = new EmptyModelMetadataProvider(); RangeAdapter adapter = new RangeAdapter(new RangeAttribute(4, 128)); ModelMetadata metadata = provider.GetMetadataForProperty(typeof(AdaptersModel), "Range"); ModelValidationContextBase context = new ModelValidationContextBase(new ActionContext(), metadata, provider); String expected = String.Format(Validations.Range, "Range", 4, 128); String actual = adapter.GetErrorMessage(context); Assert.Equal(Validations.Range, adapter.Attribute.ErrorMessage); Assert.Equal(expected, actual); }
public void GetPropertyExplorer_DeferredModelAccess_ContainerModelIsNull() { // Arrange var provider = new EmptyModelMetadataProvider(); var modelExplorer = provider.GetModelExplorerForType(typeof(BaseClass), model: null); var propertyExplorer = modelExplorer.GetExplorerForProperty("Base1"); // Act var propertyValue = propertyExplorer.Model; // Assert Assert.Null(propertyValue); }
private static ViewContext MakeViewContext(HttpContext httpContext) { var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var metadataProvider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary(metadataProvider); var viewContext = new ViewContext( actionContext, Mock.Of<IView>(), viewData, Mock.Of<ITempDataDictionary>(), TextWriter.Null, new HtmlHelperOptions()); return viewContext; }
public void GetSimpleDisplayText_WithoutSimpleDisplayProperty( object model, Type modelType, string expectedResult) { // Arrange var provider = new EmptyModelMetadataProvider(); var modelExplorer = provider.GetModelExplorerForType(modelType, model); // Act var result = modelExplorer.GetSimpleDisplayText(); // Assert Assert.Equal(expectedResult, result); }
public async Task BindModelAsync_Trimmed() { ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForProperty(typeof(AllTypesView), "StringField"); context.ValueProvider.GetValue("StringField").Returns(new ValueProviderResult(" Value ")); context.ModelName = "StringField"; context.ModelMetadata = metadata; await binder.BindModelAsync(context); ModelBindingResult expected = ModelBindingResult.Success("Value"); ModelBindingResult actual = context.Result; Assert.Equal(expected.IsModelSet, actual.IsModelSet); Assert.Equal(expected.Model, actual.Model); }
public JsTreeTagHelperTests() { JsTree tree = new JsTree(); tree.SelectedIds.Add(4567); tree.SelectedIds.Add(12345); tree.Nodes.Add(new JsTreeNode("Test")); tree.Nodes[0].Nodes.Add(new JsTreeNode(12345, "Test1")); tree.Nodes[0].Nodes.Add(new JsTreeNode(23456, "Test2")); EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelExplorer explorer = new ModelExplorer(provider, provider.GetMetadataForProperty(typeof(JsTreeView), "JsTree"), tree); helper = new JsTreeTagHelper(); helper.For = new ModelExpression("JsTree", explorer); output = new TagHelperOutput("div", new TagHelperAttributeList(), (useCachedResult, encoder) => null); }
public void TextBoxFor_UsesSpecifiedHtmlAttributes() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary<TestModel>(metadataProvider)); helper.ViewContext.ClientValidationEnabled = false; helper.ViewData.Model = new TestModel { Property1 = "propValue" }; // Act var textBoxForResult = helper.TextBoxFor(m => m.Property1, htmlAttributes: new { attr = "value" }); // Assert Assert.Equal( "<input attr=\"HtmlEncode[[value]]\" id=\"HtmlEncode[[Property1]]\" name=\"HtmlEncode[[Property1]]\" type=\"HtmlEncode[[text]]\" value=\"HtmlEncode[[propValue]]\" />", HtmlContentUtilities.HtmlContentToString(textBoxForResult)); }
public void RadioButtonFor_CheckedWhenValueMatchesSpecifiedExpression(string value) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary<TestModel>(metadataProvider)); helper.ViewContext.ClientValidationEnabled = false; helper.ViewData.Model = new TestModel { Property1 = value }; // Act var radioButtonForResult = helper.RadioButtonFor(m => m.Property1, value: "myvalue"); // Assert Assert.Equal( "<input checked=\"HtmlEncode[[checked]]\" id=\"HtmlEncode[[Property1]]\" name=\"HtmlEncode[[Property1]]\" type=\"HtmlEncode[[radio]]\" value=\"HtmlEncode[[myvalue]]\" />", HtmlContentUtilities.HtmlContentToString(radioButtonForResult)); }
public void TextBox_UsesSpecifiedFormat() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary<TestModel>(metadataProvider)); helper.ViewContext.ClientValidationEnabled = false; helper.ViewData.Model = new TestModel { Property1 = "propValue" }; // Act var textBoxResult = helper.TextBox("Property1", value: null, format: "prefix: {0}"); // Assert Assert.Equal( "<input id=\"HtmlEncode[[Property1]]\" name=\"HtmlEncode[[Property1]]\" type=\"HtmlEncode[[text]]\" value=\"HtmlEncode[[prefix: propValue]]\" />", HtmlContentUtilities.HtmlContentToString(textBoxResult)); }
public void FromLambdaExpression_GetsExpectedMetadata_ForIndexerExpression() { // Arrange var provider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary<TestModel[]>(provider); // Act var explorer = ExpressionMetadataProvider.FromLambdaExpression(m => m[23], viewData, provider); // Assert Assert.NotNull(explorer); Assert.NotNull(explorer.Metadata); Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); Assert.Equal(typeof(TestModel), explorer.ModelType); Assert.Null(explorer.Model); }
public void Constructor_InitalizesMembers() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var modelState = new ModelStateDictionary(); // Act var viewData = new ViewDataDictionary<string>(metadataProvider, modelState); // Assert Assert.Same(modelState, viewData.ModelState); Assert.NotNull(viewData.TemplateInfo); Assert.Null(viewData.Model); Assert.NotNull(viewData.ModelMetadata); Assert.Equal(0, viewData.Count); }
public void GetPropertyExplorer_ReturnsNull_ForPropertyNotFound() { // Arrange var model = new DerivedClass() { Base1 = 5, }; var provider = new EmptyModelMetadataProvider(); var modelExplorer = provider.GetModelExplorerForType(typeof(BaseClass), model); // Act var propertyExplorer = modelExplorer.GetExplorerForProperty("BadName"); // Assert Assert.Null(propertyExplorer); }
public void FromLambaExpression_SetsContainerAsExpected() { // Arrange var myModel = new TestModel { SelectedCategory = new Category() }; var provider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary<TestModel>(provider); viewData.Model = myModel; // Act var metadata = ExpressionMetadataProvider.FromLambdaExpression<TestModel, Category>( model => model.SelectedCategory, viewData, provider); // Assert Assert.Same(myModel, metadata.Container.Model); }
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", ValidationState = new ValidationStateDictionary(), }; bindingContext.HttpContext.Request.Method = "GET"; return bindingContext; }
public void FromLambdaExpression_GetsExpectedMetadata_ForLongerExpression() { // Arrange var provider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary<TestModel[]>(provider); var index = 42; // Act var explorer = ExpressionMetadataProvider.FromLambdaExpression( m => m[index].SelectedCategory.CategoryId, viewData, provider); // Assert Assert.NotNull(explorer); Assert.NotNull(explorer.Metadata); Assert.Equal(ModelMetadataKind.Property, explorer.Metadata.MetadataKind); Assert.Equal(typeof(int), explorer.ModelType); Assert.Null(explorer.Model); }
public void ListBoxFor_NullSelectListFindsListFromViewData() { // Arrange var expectedHtml = "<select id=\"HtmlEncode[[Property1]]\" multiple=\"HtmlEncode[[multiple]]\" name=\"HtmlEncode[[Property1]]\">" + "<option 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; // Act var listBoxForResult = helper.ListBoxFor(m => m.Property1, null); // Assert Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxForResult)); }
public void CopyConstructors_InitalizeModelAndModelMetadataBasedOnSource() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var model = new TestModel(); var source = new ViewDataDictionary<object>(metadataProvider) { Model = model }; source["foo"] = "bar"; source.TemplateInfo.HtmlFieldPrefix = "prefix"; // Act var viewData1 = new ViewDataDictionary<object>(source); var viewData2 = new ViewDataDictionary(source); // Assert Assert.NotNull(viewData1.ModelState); Assert.NotNull(viewData1.TemplateInfo); Assert.Equal("prefix", viewData1.TemplateInfo.HtmlFieldPrefix); Assert.NotSame(source.TemplateInfo, viewData1.TemplateInfo); Assert.Same(model, viewData1.Model); Assert.NotNull(viewData1.ModelMetadata); Assert.Equal(typeof(TestModel), viewData1.ModelMetadata.ModelType); Assert.Same(source.ModelMetadata, viewData1.ModelMetadata); Assert.Equal(source.Count, viewData1.Count); Assert.Equal("bar", viewData1["foo"]); Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData1.Data); Assert.NotNull(viewData2.ModelState); Assert.NotNull(viewData2.TemplateInfo); Assert.Equal("prefix", viewData2.TemplateInfo.HtmlFieldPrefix); Assert.NotSame(source.TemplateInfo, viewData2.TemplateInfo); Assert.Same(model, viewData2.Model); Assert.NotNull(viewData2.ModelMetadata); Assert.Equal(typeof(TestModel), viewData2.ModelMetadata.ModelType); Assert.Same(source.ModelMetadata, viewData2.ModelMetadata); Assert.Equal(source.Count, viewData2.Count); Assert.Equal("bar", viewData2["foo"]); Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData2.Data); }