Exemple #1
0
        public void ModelStateDictionary_AddsCustomErrorMessage_WhenModelStateSet()
        {
            // Arrange
            var expected   = "Hmm, the value 'some value' is not valid for Length.";
            var dictionary = new ModelStateDictionary();

            dictionary.SetModelValue("key", new string[] { "some value" }, "some value");

            var messageProvider = new ModelBindingMessageProvider
            {
                MissingBindRequiredValueAccessor = name => "Unexpected MissingBindRequiredValueAccessor use",
                MissingKeyOrValueAccessor        = () => "Unexpected MissingKeyOrValueAccessor use",
                ValueMustNotBeNullAccessor       = value => "Unexpected ValueMustNotBeNullAccessor use",
                AttemptedValueIsInvalidAccessor  =
                    (value, name) => $"Hmm, the value '{ value }' is not valid for { name }.",
                UnknownValueIsInvalidAccessor = name => "Unexpected InvalidValueWithUnknownAttemptedValueAccessor use",
                ValueIsInvalidAccessor        = value => "Unexpected InvalidValueWithUnknownModelErrorAccessor use",
                ValueMustBeANumberAccessor    = name => "Unexpected ValueMustBeANumberAccessor use",
            };
            var bindingMetadataProvider = new DefaultBindingMetadataProvider(messageProvider);
            var compositeProvider       = new DefaultCompositeMetadataDetailsProvider(new[] { bindingMetadataProvider });
            var provider = new DefaultModelMetadataProvider(compositeProvider);
            var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));

            // Act
            dictionary.TryAddModelError("key", new FormatException(), metadata);

            // Assert
            var entry = Assert.Single(dictionary);

            Assert.Equal("key", entry.Key);
            var error = Assert.Single(entry.Value.Errors);

            Assert.Equal(expected, error.ErrorMessage);
        }
Exemple #2
0
        public void ModelStateDictionary_AddsCustomErrorMessage_WhenModelStateSet()
        {
            // Arrange
            var expected   = "Hmm, the value 'some value' is not valid for Length.";
            var dictionary = new ModelStateDictionary();

            dictionary.SetModelValue("key", new string[] { "some value" }, "some value");

            var bindingMetadataProvider = new DefaultBindingMetadataProvider();
            var compositeProvider       = new DefaultCompositeMetadataDetailsProvider(new[] { bindingMetadataProvider });
            var optionsAccessor         = new OptionsAccessor();

            optionsAccessor.Value.ModelBindingMessageProvider.AttemptedValueIsInvalidAccessor =
                (value, name) => $"Hmm, the value '{ value }' is not valid for { name }.";

            var provider = new DefaultModelMetadataProvider(compositeProvider, optionsAccessor);
            var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));

            // Act
            dictionary.TryAddModelError("key", new FormatException(), metadata);

            // Assert
            var entry = Assert.Single(dictionary);

            Assert.Equal("key", entry.Key);
            var error = Assert.Single(entry.Value.Errors);

            Assert.Equal(expected, error.ErrorMessage);
        }
Exemple #3
0
    public static DefaultModelMetadata CreateModelMetadata <T>()
    {
        var metadataDetailProvider = new Mock <ICompositeMetadataDetailsProvider>().Object;
        var modelMetadataProvider  = new DefaultModelMetadataProvider(metadataDetailProvider);
        var details = new DefaultMetadataDetails(ModelMetadataIdentity.ForType(typeof(T)), ModelAttributes.GetAttributesForType(typeof(T)));

        return(new DefaultModelMetadata(modelMetadataProvider, metadataDetailProvider, details));
    }
        protected ModelValidatorProviderContext GetMockedContext()
        {
            var options  = _provider.GetRequiredService <IOptions <MvcOptions> >();
            var provider = new DefaultModelMetadataProvider(_compositeMetadataDetailsProvider, options);
            var metadata = provider.GetMetadataForType(typeof(ValidatableObject));

            var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));

            return(context);
        }
        protected ModelValidationContext GetMockedValidationContextForModel(object model, object container = null)
        {
            var actionContext = ValidatorUtils.CreateActionContext();
            var options       = _provider.GetRequiredService <IOptions <MvcOptions> >();
            var provider      = new DefaultModelMetadataProvider(_compositeMetadataDetailsProvider, options);
            var metadata      = provider.GetMetadataForProperty(typeof(RequiredModel).GetProperty("Summary"), typeof(RequiredModel));

            var context = new ModelValidationContext(actionContext, metadata, provider, container, model);

            return(context);
        }
        protected ModelValidationContext GetMockedValidationContextWithContainer(ValidatableSampleModel model)
        {
            var container     = new ValidatableSampleModelContainer();
            var options       = _provider.GetRequiredService <IOptions <MvcOptions> >();
            var actionContext = ValidatorUtils.CreateActionContext();
            var provider      = new DefaultModelMetadataProvider(_compositeMetadataDetailsProvider, options);
            var metadata      = provider.GetMetadataForType(model.GetType());

            var context = new ModelValidationContext(actionContext, metadata, provider, container, model);

            return(context);
        }
        protected ModelValidationContext GetModelValidationContextWithoutContainer(ValidatableSampleModel model)
        {
            var options       = _provider.GetRequiredService <IOptions <MvcOptions> >();
            var actionContext = ValidatorUtils.CreateActionContext();
            var provider      = new DefaultModelMetadataProvider(_compositeMetadataDetailsProvider, options);
            var metadata      = provider.GetMetadataForProperty(
                typeof(ValidatableSampleModelContainer),
                nameof(ValidatableSampleModelContainer.SampleModel));

            var context = new ModelValidationContext(actionContext, metadata, provider, null, model);

            return(context);
        }
Exemple #8
0
        /// <summary>
        /// Pieced this together from aspnet/Mvc github. See remarks for link.
        /// </summary>
        /// <remarks>Reference: https://github.com/aspnet/Mvc/blob/67a1f2dda9bcb5795033b0c0ce775d931627fe17/test/Microsoft.AspNetCore.Mvc.TagHelpers.Test/LabelTagHelperTest.cs#L156</remarks>
        protected ModelExpression GetModelExpression(DateTime?instance, string format = null)
        {
            var providers = new List <IMetadataDetailsProvider>
            {
                new DefaultMetaDataHelperProvider(format)
            };
            var compositeDetailsProvider = new DefaultCompositeMetadataDetailsProvider(providers);
            var metadataProvider         = new DefaultModelMetadataProvider(compositeDetailsProvider);
            var containerExplorer        = metadataProvider.GetModelExplorerForType(typeof(DateTime?), instance);
            var modelExplorer            = containerExplorer.GetExplorerForModel(instance);
            var modelExpression          = new ModelExpression("", modelExplorer);

            return(modelExpression);
        }
Exemple #9
0
        protected ModelExpression MakeExpression <TModel, TProperty>(
            TModel model,
            Expression <Func <TModel, TProperty> > expression)
        {
            var modelExpressionProvider = ServiceProvider.GetService <ModelExpressionProvider>();

            var compositeMetadataDetailsProvider = ServiceProvider.GetService <ICompositeMetadataDetailsProvider>();
            var metadataProvider = new DefaultModelMetadataProvider(compositeMetadataDetailsProvider);

            var viewDataDictionary = new ViewDataDictionary <TModel>(metadataProvider, new ModelStateDictionary())
            {
                Model = model
            };

            return(modelExpressionProvider.CreateModelExpression(viewDataDictionary, expression));
        }
Exemple #10
0
        protected ModelExpression MakeExpression <TModel>(TModel model)
        {
            var modelExpressionProvider = ServiceProvider.GetService <ModelExpressionProvider>();

            var compositeMetadataDetailsProvider = ServiceProvider.GetService <ICompositeMetadataDetailsProvider>();
            var metadataProvider = new DefaultModelMetadataProvider(compositeMetadataDetailsProvider);

            var viewDataDictionary = new ViewDataDictionary <TModel>(metadataProvider, new ModelStateDictionary())
            {
                Model = model
            };

            var modelExplorer = new ModelExplorer(
                metadataProvider, metadataProvider.GetMetadataForType(model.GetType()), model);

            return(new ModelExpression("Model", modelExplorer));
        }
Exemple #11
0
        protected ModelExpression MakeExpression <TModel>(TModel viewModel, string propertyName, object propertyContent)
        {
            var containerType = viewModel.GetType();

            var m3 = ServiceProvider.GetService <ModelExpressionProvider>();

            var compositeMetadataDetailsProvider = ServiceProvider.GetService <ICompositeMetadataDetailsProvider>();
            var metadataProvider = new DefaultModelMetadataProvider(compositeMetadataDetailsProvider);

            var containerMetadata = metadataProvider.GetMetadataForType(containerType);
            var containerExplorer = metadataProvider.GetModelExplorerForType(containerType, viewModel);

            var propertyMetadata = metadataProvider.GetMetadataForProperty(containerType, propertyName);

            var modelExplorer = containerExplorer.GetExplorerForExpression(propertyMetadata, propertyContent);

            return(new ModelExpression(propertyName, modelExplorer));
        }
        public void WhenModelTypeIsOfTypeUnknown_ItShouldReturnNull()
        {
            // Arrange
            var modelBinderProvider        = new IdentifierModelBinderProvider <int>();
            var modelBinderProviderContext = new Mock <ModelBinderProviderContext>();

            // modelBinderProviderContext.Metadata.ModelType
            var compositeMetadataDetailsProvider = new Mock <ICompositeMetadataDetailsProvider>();


            var data          = new DefaultModelMetadataProvider(compositeMetadataDetailsProvider.Object);
            var modelMetadata = data.GetMetadataForType(typeof(DateTime));

            modelBinderProviderContext.Setup(x => x.Metadata)
            .Returns(modelMetadata);

            // Act
            var modelBinder = modelBinderProvider.GetBinder(modelBinderProviderContext.Object);

            // Assert
            Assert.Null(modelBinder);
        }
        public void WhenModelValueForModelNameIsNull_ItShouldReturnCompletedTask()
        {
            // Arrange
            var modelName           = "id";
            var valueProviderResult = new ValueProviderResult(new StringValues(""));

            var compositeMetadataDetailsProvider = new Mock <ICompositeMetadataDetailsProvider>();


            var data          = new DefaultModelMetadataProvider(compositeMetadataDetailsProvider.Object);
            var modelMetadata = data.GetMetadataForType(typeof(Identifier));

            var valueProvider = new Mock <IValueProvider>();

            valueProvider.Setup(x => x.GetValue(modelName))
            .Returns(valueProviderResult);

            var bindingContext = new DefaultModelBindingContext
            {
                ModelName     = modelName,
                ModelState    = new ModelStateDictionary(),
                ValueProvider = valueProvider.Object,
                ModelMetadata = modelMetadata
            };

            var modelBinder = new IdentifierModelBinder <int>();

            // Act
            var task = modelBinder.BindModelAsync(bindingContext);

            // Assert
            Assert.Same(Task.CompletedTask, task);
            Assert.False(bindingContext.Result.IsModelSet);
            Assert.Null(bindingContext.Result.Model);
            Assert.Equal("Failed", bindingContext.Result.ToString());
        }
        public void IsReadOnly_ReturnsFalse_ForPublicSetProperty()
        {
            // Arrange
            var detailsProvider = new EmptyCompositeMetadataDetailsProvider();
            var provider = new DefaultModelMetadataProvider(detailsProvider);

            var key = ModelMetadataIdentity.ForType(typeof(TypeWithProperties));
            var cache = new DefaultMetadataDetails(key, new ModelAttributes(new object[0]));

            var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);

            // Act
            var isReadOnly = metadata.Properties["PublicGetPublicSetProperty"].IsReadOnly;

            // Assert
            Assert.False(isReadOnly);
        }
		/// <summary>
		/// Initialises a new instance of <see cref="HandlebarsService"/>
		/// </summary>
		public HandlebarsService()
		{
			TagProviders = new TagProvidersCollection(TagProvidersCollection.Default);
			ModelMetadataProvider = new DefaultModelMetadataProvider();
		}
Exemple #16
0
 /// <summary>
 /// Initialises a new instance of <see cref="HandlebarsService"/>
 /// </summary>
 public HandlebarsService()
 {
     TagProviders          = new TagProvidersCollection(TagProvidersCollection.Default);
     ModelMetadataProvider = new DefaultModelMetadataProvider();
 }
        public void ModelStateDictionary_AddsCustomErrorMessage_WhenModelStateSet()
        {
            // Arrange
            var expected = "Hmm, the value 'some value' is not valid for Length.";
            var dictionary = new ModelStateDictionary();
            dictionary.SetModelValue("key", new string[] { "some value" }, "some value");

            var messageProvider = new ModelBindingMessageProvider
            {
                MissingBindRequiredValueAccessor = name => "Unexpected MissingBindRequiredValueAccessor use",
                MissingKeyOrValueAccessor = () => "Unexpected MissingKeyOrValueAccessor use",
                ValueMustNotBeNullAccessor = value => "Unexpected ValueMustNotBeNullAccessor use",
                AttemptedValueIsInvalidAccessor =
                    (value, name) => $"Hmm, the value '{ value }' is not valid for { name }.",
                UnknownValueIsInvalidAccessor = name => "Unexpected InvalidValueWithUnknownAttemptedValueAccessor use",
                ValueIsInvalidAccessor = value => "Unexpected InvalidValueWithUnknownModelErrorAccessor use",
                ValueMustBeANumberAccessor = name => "Unexpected ValueMustBeANumberAccessor use",
            };
            var bindingMetadataProvider = new DefaultBindingMetadataProvider(messageProvider);
            var compositeProvider = new DefaultCompositeMetadataDetailsProvider(new[] { bindingMetadataProvider });
            var provider = new DefaultModelMetadataProvider(compositeProvider);
            var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));

            // Act
            dictionary.TryAddModelError("key", new FormatException(), metadata);

            // Assert
            var entry = Assert.Single(dictionary);
            Assert.Equal("key", entry.Key);
            var error = Assert.Single(entry.Value.Errors);
            Assert.Equal(expected, error.ErrorMessage);
        }