Пример #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.False(model.PropertyWasRead());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (ModelValidatorProvider provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }
Пример #2
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());
        }
Пример #3
0
        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());
        }
Пример #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
            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 TestAddTo()
        {
            var count  = 10;
            var tuples = new List <Tuple <ObservableModel, Observer <PropertyChangedEventArgs> > >();
            CompositeDisposable disposables = new CompositeDisposable();

            for (var i = 0; i < count; i++)
            {
                // 被観測者, 観測者を生成します
                var model    = new ObservableModel();
                var observer = new Observer <PropertyChangedEventArgs>();
                tuples.Add(new Tuple <ObservableModel, Observer <PropertyChangedEventArgs> >(model, observer));

                // イベントを購読します
                model
                .ObserveEvent <PropertyChangedEventArgs>(nameof(model.PropertyChanged))
                .Subscribe(observer.OnObservedEvent)
                .AddTo(disposables);

                // イベントを送受信することで, 以上の動作を確認します
                model.Qty = 8;
                Assert.That(observer.LastEventArgs, Is.Not.Null);
            }

            // イベント購読をまとめて解除します
            disposables.Dispose();

            for (var i = 0; i < count; i++)
            {
                (var model, var observer) = tuples[i];

                // イベントを受信できないことで, 以上の動作を確認します
                observer.LastEventArgs = null;
                model.Qty = 16;
                Assert.That(observer.LastEventArgs, Is.Null);
            }
        }
Пример #7
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 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());
        }
Пример #9
0
 public EditModeMessage(ObservableModel item, EditAction action)
 {
     Item   = item;
     Action = action;
 }
        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());
        }
Пример #13
0
        public SampleExtendedStackViewModel()
        {
            Title = "Binding Title";

            Model = new ObservableModel();
        }
        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.");
        }