Пример #1
0
        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.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
            }
            finally {
                ModelValidatorProviders.Providers.Clear();
                foreach (ModelValidatorProvider provider in originalProviders) {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }
Пример #2
0
        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 ClientModelValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel model    = new ObservableModel();
            ModelMetadata   metadata = _metadataProvider.GetMetadataForProperty(
                () => model.TheProperty,
                typeof(ObservableModel),
                "TheProperty"
                );
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new ClientDataTypeModelValidatorProvider()
                                          .GetValidators(metadata, controllerContext)
                                          .ToArray();
            ModelValidationResult[] results = validators
                                              .SelectMany(o => o.Validate(model))
                                              .ToArray();

            // Assert
            Assert.Equal(
                new Type[] { typeof(ClientDataTypeModelValidatorProvider.NumericModelValidator) },
                Array.ConvertAll(validators, o => o.GetType())
                );
            Assert.Empty(results);
            Assert.False(model.PropertyWasRead());
        }
Пример #4
0
        public void GetModelValidator_DoesNotReadPropertyValues()
        {
            // Arrange
            IEnumerable<ModelValidatorProvider> validatorProviders = new[] { new ObservableModelValidatorProvider() };
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel));

            // Act
            ModelValidator validator = ModelValidator.GetModelValidator(validatorProviders);
            ModelValidationResult[] results = validator.Validate(metadata, model).ToArray();

            // Assert
            Assert.False(model.PropertyWasRead());
        }
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel   model             = new ObservableModel();
            ModelMetadata     metadata          = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[]        validators = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results    = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            var           provider = new DataAnnotationsModelValidatorProvider();
            var           model    = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");

            // Act
            ModelValidator[]        validators = provider.GetValidators(metadata, _noValidatorProviders).ToArray();
            ModelValidationResult[] results    = validators.SelectMany(o => o.Validate(metadata, model)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }
        public void GetModelValidator_DoesNotReadPropertyValues()
        {
            // Arrange
            IEnumerable <ModelValidatorProvider> validatorProviders = new[] { new ObservableModelValidatorProvider() };
            ObservableModel model    = new ObservableModel();
            ModelMetadata   metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel));

            // Act
            ModelValidator validator = ModelValidator.GetModelValidator(validatorProviders);

            ModelValidationResult[] results = validator.Validate(metadata, model).ToArray();

            // Assert
            Assert.False(model.PropertyWasRead());
        }
Пример #8
0
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel   model             = new ObservableModel();
            ModelMetadata     metadata          = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[]        validators = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results    = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.AreEqual(0, validators.Length, "Provider shouldn't have returned any validators.");
            Assert.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
        }
Пример #9
0
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var model    = new ObservableModel();
            var metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            var context  = new ModelValidationContext(null, null, null, metadata, null);

            // Act
            var validators = provider.GetValidators(metadata).ToArray();
            var results    = validators.SelectMany(o => o.Validate(context)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }
        public void NumericValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel   model             = new ObservableModel();
            ModelMetadata     metadata          = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[]        validators = new ClientDataTypeModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results    = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            CollectionAssert.AreEqual(new Type[] { typeof(ClientDataTypeModelValidatorProvider.NumericModelValidator) }, Array.ConvertAll(validators, o => o.GetType()), "Provider did not return expected validator.");
            Assert.AreEqual(0, results.Length);
            Assert.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
        }
        public void PropertyValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel   model             = new ObservableModel();
            ModelMetadata     metadata          = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[]        validators = new DataErrorInfoModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results    = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            CollectionAssert.AreEqual(new Type[] { typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator) }, Array.ConvertAll(validators, o => o.GetType()), "Provider did not return expected validator.");
            CollectionAssert.AreEquivalent(new string[] { "TheProperty" }, model.GetColumnNamesPassed(), "Model.get_Item() was not called as expected.");
            Assert.AreEqual(0, results.Length);
            Assert.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
        }
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");

            // Act
            ModelValidator[] validators = provider.GetValidators(metadata, _noValidatorProviders).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(metadata, model)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }
        public void PropertyValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new DataErrorInfoModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.Equal(new[] { typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator) }, Array.ConvertAll(validators, o => o.GetType()));
            Assert.Equal(new[] { "TheProperty" }, model.GetColumnNamesPassed().ToArray());
            Assert.Empty(results);
            Assert.False(model.PropertyWasRead());
        }
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var model = new ObservableModel();
            var metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            var context = new ModelValidationContext(null, null, null, metadata, null);

            // Act
            var validators = provider.GetValidators(metadata).ToArray();
            var results = validators.SelectMany(o => o.Validate(context)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }
        public void PropertyValidator_Validate_DoesNotReadPropertyValue() {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new DataErrorInfoModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            CollectionAssert.AreEqual(new Type[] { typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator) }, Array.ConvertAll(validators, o => o.GetType()), "Provider did not return expected validator.");
            CollectionAssert.AreEquivalent(new string[] { "TheProperty" }, model.GetColumnNamesPassed(), "Model.get_Item() was not called as expected.");
            Assert.AreEqual(0, results.Length);
            Assert.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
        }
        public void NumericValidator_Validate_DoesNotReadPropertyValue() {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new ClientDataTypeModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            CollectionAssert.AreEqual(new Type[] { typeof(ClientDataTypeModelValidatorProvider.NumericModelValidator) }, Array.ConvertAll(validators, o => o.GetType()), "Provider did not return expected validator.");
            Assert.AreEqual(0, results.Length);
            Assert.IsFalse(model.PropertyWasRead(), "Property should not have been read by provider or validator.");
        }