public void ApplyParameters_CalledOnNonNull_WithNonNullInvalidParams_ThrowsCorrectException(
            List <NavigationParameterModel> parameters)
        {
            IViewModelBase viewModel = new ViewModelStub();

            Assert.ThrowsAny <Exception>(() => viewModel.ApplyParameters(parameters));
        }
        public void GetValue_CallingGetValueWithinValueInitializer_DoesNotCallValueInitializerAgain()
        {
            PropertyStub <object> property = null;

            Func <IBehaviorContext, object> provideValueFunction = ctx => {
                return(new Object());
            };

            var behavior = new TestBehavior(provideValueFunction);
            var valueInitializerWasAlreadyInvoked = false;

            Action <IBehaviorContext> initializeValueAction = ctx => {
                Assert.IsFalse(valueInitializerWasAlreadyInvoked);
                valueInitializerWasAlreadyInvoked = true;
                property.Behaviors.GetValueNext <object>(ctx);
            };

            property = PropertyStub
                       .WithBehaviors(behavior, new TestValueInitializerBehavior(initializeValueAction))
                       .Build();

            var context = ViewModelStub
                          .WithProperties(property)
                          .BuildContext();

            behavior.GetValue(context);

            Assert.IsTrue(valueInitializerWasAlreadyInvoked);
        }
        public void InitializeValue_WhenInitialValueIsNull_DoesNothing()
        {
            ViewModelStub initialValue = null;

            Next.ValueToReturn = initialValue;
            Behavior.InitializeValue(Context);
        }
        public void GetValue_CallingGetValueWithinProvideValue_ThrowsException()
        {
            PropertyStub <object> property   = null;
            var provideValueWasAlreadyCalled = false;

            Func <IBehaviorContext, object> provideValueFunction = ctx => {
                Assert.IsFalse(provideValueWasAlreadyCalled);
                provideValueWasAlreadyCalled = true;
                property.Behaviors.GetValueNext <object>(ctx);
                return(new Object());
            };

            var behavior = new TestBehavior(provideValueFunction);

            property = PropertyStub
                       .WithBehaviors(behavior)
                       .Build();

            var context = ViewModelStub
                          .WithProperties(property)
                          .BuildContext();

            AssertHelper.Throws <InvalidOperationException>(() =>
                                                            behavior.GetValue(context)
                                                            ).WithMessage(EViewModels.ValueAccessedWithinProvideValue);

            Assert.IsTrue(provideValueWasAlreadyCalled);
        }
Esempio n. 5
0
        public void TestRaiseValidInvalidPropertyName()
        {
            var vm = new ViewModelStub();

            var receivedPropertyChanged     = false;
            var invalidPropertyNameReceived = false;

            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.RealPropertyPropertyName)
                {
                    receivedPropertyChanged = true;
                }
                else
                {
                    invalidPropertyNameReceived = true;
                }
            };

            vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName);

            Assert.IsTrue(receivedPropertyChanged);
            Assert.IsFalse(invalidPropertyNameReceived);

            vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName + "1");

            Assert.IsTrue(invalidPropertyNameReceived);
        }
        public void Setup()
        {
            Behavior = new ItemProviderBehavior <TestSourceObject, TestSourceItem>();

            Context = ViewModelStub
                      .WithBehaviors(Behavior)
                      .BuildContext();
        }
Esempio n. 7
0
        public void TryPopViewModel_WithEmptyBackStack_ReturnsFalse()
        {
            IViewModelBase result = new ViewModelStub();
            var            popped = _backStackManager.TryPopViewModel(out result);

            Assert.False(popped);
            Assert.Null(result);
        }
        public void SetValue_PreviousValueWasNull_AddsParentToNewValue()
        {
            var newValue = new ViewModelStub();

            Next.ValueToReturn = null;
            Behavior.SetValue(Context, newValue);
            Assert.IsTrue(newValue.Kernel.Parents.Contains(Context.VM));
        }
Esempio n. 9
0
 public void IDataErrorInfoErrorPropertyIsNotSupported()
 {
     Assert.Throws<NotSupportedException>(() =>
     {
         ViewModelStub viewModel = new ViewModelStub();
         string value = viewModel.Error;
     });
 }
        public void InitializeValue_AddsParent()
        {
            var initialValue = new ViewModelStub();

            Next.ValueToReturn = initialValue;
            Behavior.InitializeValue(Context);
            Assert.IsTrue(initialValue.Kernel.Parents.Contains(Context.VM));
        }
Esempio n. 11
0
        public void Setup()
        {
            var behavior = new TestBehavior(ValueStage.Value);

            VM      = ViewModelStub.WithBehaviors(behavior).Build();
            Manager = behavior.Manager;
            Context = new BehaviorContextStub(VM);
        }
Esempio n. 12
0
        public void GetManager_RootViewModelContainsBehavior_ReturnsManager()
        {
            var rootVM = new ViewModelStub(new UndoRootBehavior());

            var foundManager = UndoManager.GetManager(rootVM);

            Assert.IsNotNull(foundManager);
        }
Esempio n. 13
0
        public void IndexerValidatesPropertyNameWithValidValue()
        {
            ViewModelStub viewModel = new ViewModelStub
            {
                RequiredProperty = "Some Value"
            };

            Assert.IsNull(viewModel["RequiredProperty"]);
        }
        public void HandleChange_DescendantValidationStateChanged_PerformsViewModelValidation()
        {
            var args = ChangeArgs.ValidationResultChanged()
                       .PrependViewModel(VM)
                       .PrependViewModel(ViewModelStub.Build());

            Behavior.HandleChange(Context, args);
            Assert.AreEqual(HandleChangeNext + Validate + RevalidateNext, ActionLog);
        }
Esempio n. 15
0
        public void ViewModelPropertyChanged_SetsOldAndNewItems()
        {
            var property = PropertyStub.Build();
            var newValue = ViewModelStub.Build();
            var args     = ChangeArgs.ViewModelPropertyChanged(property, ValueStage.ValidatedValue, null, newValue);

            CollectionAssert.AreEqual(new IViewModel[0], args.OldItems.ToArray());
            CollectionAssert.AreEqual(new IViewModel[] { newValue }, args.NewItems.ToArray());
        }
Esempio n. 16
0
        private void SetupForProperty(ValueStage stage)
        {
            var behavior = new TestBehavior(stage);

            Property = PropertyStub.WithBehaviors(behavior).Of <object>();
            VM       = ViewModelStub.WithProperties(Property).Build();
            Manager  = behavior.Manager;
            Context  = new BehaviorContextStub(VM);
        }
        public void ViewModelBase_NotifiesWhenIsBusyChanges(bool initialIsBusy, bool changedIsBusy)
        {
            var vm = new ViewModelStub()
            {
                IsBusy = initialIsBusy
            };

            Assert.PropertyChanged(vm, nameof(vm.IsBusy), () => vm.IsBusy = changedIsBusy);
        }
Esempio n. 18
0
        public void HandleChange_WithPropertyChangedOfOwnViewModelProperty_UpdatesCachedResults()
        {
            var owner = new TestVM();

            owner.MakePropertiesAndViewModelInvalid();
            var expected = owner.GetCurrentlySetupResults();

            //   S E T   C H I L D
            var firstChild = new ViewModelStub {
                ValidationResult = CreateValidationResult("First child error")
            };

            var propertyChangedArgs = ChangeArgs
                                      .ViewModelPropertyChanged(
                owner.SecondProperty,
                ValueStage.ValidatedValue,
                oldValue: null,
                newValue: firstChild)
                                      .PrependViewModel(owner);

            owner.CallHandleChangeWith(propertyChangedArgs);

            expected.Descenants = firstChild.ValidationResult;
            AssertBehaviorResults(owner, expected);

            //   C H A N G E   C H I L D
            var secondChild = new ViewModelStub {
                ValidationResult = CreateValidationResult("Second child error")
            };

            propertyChangedArgs = ChangeArgs
                                  .ViewModelPropertyChanged(
                owner.SecondProperty,
                ValueStage.ValidatedValue,
                oldValue: firstChild,
                newValue: secondChild)
                                  .PrependViewModel(owner);

            owner.CallHandleChangeWith(propertyChangedArgs);

            expected.Descenants = secondChild.ValidationResult;
            AssertBehaviorResults(owner, expected);

            //   S E T   C H I L D   T O   N U L L
            propertyChangedArgs = ChangeArgs
                                  .ViewModelPropertyChanged(
                owner.SecondProperty,
                ValueStage.ValidatedValue,
                oldValue: secondChild,
                newValue: null)
                                  .PrependViewModel(owner);

            owner.CallHandleChangeWith(propertyChangedArgs);

            expected.Descenants = ValidationResult.Valid;
            AssertBehaviorResults(owner, expected);
        }
        public void OnInitialized_ChangesCorrespondingProperty()
        {
            var vm = new ViewModelStub();

            Assert.False(vm.IsInitialized);

            vm.OnInitialize();

            Assert.True(vm.IsInitialized);
        }
        public void ViewModelBase_DoesNotNotifyWhenIsBusyNotChanges(bool initialIsBusy)
        {
            var vm = new ViewModelStub()
            {
                IsBusy = initialIsBusy
            };

            Assert.Throws <PropertyChangedException>(() =>
                                                     Assert.PropertyChanged(vm, nameof(vm.IsBusy), () => vm.IsBusy = initialIsBusy));
        }
        public void ApplyParameters_CalledOnNonNull_WithNonNullValidParams_SetsCorrectProperties()
        {
            var viewModel  = new ViewModelStub();
            var parameters = FluentNavigatorExtensionsTestsDataProvider.ValidNavigationParams;

            viewModel.ApplyParameters(parameters);

            Assert.Equal(FluentNavigatorExtensionsTestsDataProvider.PropertyValue1, viewModel.StringParameter);
            Assert.Equal(FluentNavigatorExtensionsTestsDataProvider.PropertyValue2, viewModel.IntParameter);
        }
        protected static ViewModelStub CreateInvalidVM(ValidationResult validationResult)
        {
            var behavior = new ValidationResultAggregatorStub();

            behavior.ReturnedValidationResults[ValidationResultScope.All] = validationResult;

            return(ViewModelStub
                   .WithBehaviors(behavior)
                   .Build());
        }
Esempio n. 23
0
        public void ItemsRemoved_SetsChangedPathToEmpty()
        {
            var collection = VMCollectionStub.Build();
            var oldItems   = new[] { ViewModelStub.Build() };
            var args       = ChangeArgs.ItemsRemoved(collection, oldItems);

            Assert.AreEqual(ChangeType.RemovedFromCollection, args.ChangeType);
            CollectionAssert.AreEqual(oldItems, args.OldItems.ToArray());
            Assert.IsFalse(args.NewItems.Any());
            DomainAssert.AreEqual(Path.Empty.Append(collection), args.ChangedPath);
        }
Esempio n. 24
0
        public void ItemsAdded_SetsChangeTypeAndNewItemsAndChangedPathToCollection()
        {
            var collection = VMCollectionStub.Build();
            var newItems   = new[] { ViewModelStub.Build() };
            var args       = ChangeArgs.ItemsAdded(collection, newItems);

            Assert.AreEqual(ChangeType.AddedToCollection, args.ChangeType);
            CollectionAssert.AreEqual(newItems, args.NewItems.ToArray());
            Assert.IsFalse(args.OldItems.Any());
            DomainAssert.AreEqual(Path.Empty.Append(collection), args.ChangedPath);
        }
        public void Bind_ViewModel_ModelIsBound()
        {
            var model     = new ModelStub("Test", 2);
            var viewModel = new ViewModelStub();

            viewModel.Bind(model);

            _collectionViewModel.Bind(viewModel);

            Assert.True(_collectionViewModel.IsBound(model));
        }
        public void SetValue_ToNull_RemovesParentFromPreviousValue()
        {
            var previousValue = new ViewModelStub();

            previousValue.Kernel.Parents.Add(Context.VM);
            Next.ValueToReturn = previousValue;

            Behavior.SetValue(Context, null);

            Assert.IsFalse(previousValue.Kernel.Parents.Contains(Context.VM));
        }
Esempio n. 27
0
        public void Setup()
        {
            Behavior = new RefreshablePropertyChangedNotifierBehavior <object>();

            Property = PropertyStub
                       .WithBehaviors(Behavior)
                       .Build();

            Context = ViewModelStub
                      .WithProperties(Property)
                      .BuildContext();
        }
        public void Setup()
        {
            Behavior = new CommandAccessorMock();

            OwnerProperty = PropertyStub
                            .WithBehaviors(Behavior)
                            .Build();

            OwnerVM = ViewModelStub
                      .WithProperties(OwnerProperty)
                      .Build();
        }
Esempio n. 29
0
        public void IndexerReturnsErrorMessageForRequestedInvalidProperty()
        {
            ViewModelStub viewModel = new ViewModelStub
            {
                RequiredProperty = null,
                SomeOtherProperty = null
            };

            string errorMessage = viewModel["SomeOtherProperty"];

            Assert.AreEqual("The SomeOtherProperty field is required.", errorMessage);
        }
Esempio n. 30
0
        public void TryPopViewModel_WithNonEmptyBackStack_ReturnsTrueAndViewModelAndRemoves(
            List <IViewModelBase> viewModels, IViewModelBase expectedResult)
        {
            InitializeBackStack(viewModels);

            IViewModelBase result = new ViewModelStub();
            var            popped = _backStackManager.TryPopViewModel(out result);

            Assert.True(popped);
            Assert.Equal(viewModels.Count - 1, _backStackManager.Count);
            Assert.Same(expectedResult, result);
        }
        public void Bind_ViewModel_AddedToChildrenOnce()
        {
            var model     = new ModelStub("Test", 2);
            var viewModel = new ViewModelStub();

            viewModel.Bind(model);

            _collectionViewModel.Bind(viewModel);

            var child = _collectionViewModel.Children.Single(vm => Equals(vm.ActiveModel, model));

            Assert.NotNull(child);
        }
        public void ShouldMapViewModelToDomain()
        {
            const int Id = 1;
            const int Value = 100;
            const string Name = "Name";
            var viewModelStub = new ViewModelStub { Id = Id, Name1 = Name, Value1 = Value };

            var domainStub = DomainViewModelMapper<DomainStub, ViewModelStub>.Map(viewModelStub);

            Assert.That(domainStub.Id, Is.EqualTo(Id));
            Assert.That(domainStub.Name1, Is.EqualTo(Name));
            Assert.That(domainStub.Value1, Is.EqualTo(Value));
        }
Esempio n. 33
0
        public void Setup()
        {
            ValueAccessor = new ValueAccessorStub <ChildVM>();
            Behavior      = new DelegateViewModelAccessorBehavior <ChildVM>();

            Property = PropertyStub
                       .WithBehaviors(Behavior, ValueAccessor)
                       .Build();

            Context = ViewModelStub
                      .WithProperties(Property)
                      .BuildContext();
        }
        public void Setup()
        {
            ActionLogBuilder = new StringBuilder();
            Behavior         = new ViewModelValidationSourceBehavior();
            Next             = new NextBehavior(ActionLogBuilder);
            Executor         = new TestExecutor(ActionLogBuilder);

            VM = ViewModelStub
                 .WithBehaviors(Behavior, Next, Executor)
                 .Build();

            Context = VM.GetContext();
        }
Esempio n. 35
0
        public void TestReturnValueWithStringSetNoBroadcast()
        {
            var vm = new ViewModelStub();
            const int firstValue = 1234;
            var receivedValueChanged = 0;
            var receivedValueChanging = 0;

            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.PropertyWithStringSetNoBroadcastPropertyName)
                {
                    receivedValueChanged = vm.PropertyWithStringSetNoBroadcast;
                }
            };

#if !WP71
            vm.PropertyChanging += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.PropertyWithStringSetNoBroadcastPropertyName)
                {
                    receivedValueChanging = vm.PropertyWithStringSetNoBroadcast;
                }
            };
#endif

            vm.PropertyWithStringSetNoBroadcast = firstValue;
#if !WP71
            Assert.AreEqual(-1, receivedValueChanging);
#endif
            Assert.AreEqual(firstValue, receivedValueChanged);
            Assert.IsTrue(vm.SetRaisedPropertyChangedEvent);

            vm.PropertyWithStringSetNoBroadcast = firstValue;
#if !WP71
            Assert.AreEqual(-1, receivedValueChanging);
#endif
            Assert.AreEqual(firstValue, receivedValueChanged);
            Assert.IsFalse(vm.SetRaisedPropertyChangedEvent);

            vm.PropertyWithStringSetNoBroadcast = firstValue + 1;
#if !WP71
            Assert.AreEqual(firstValue, receivedValueChanging);
#endif
            Assert.AreEqual(firstValue + 1, receivedValueChanged);
            Assert.IsTrue(vm.SetRaisedPropertyChangedEvent);
        }
Esempio n. 36
0
        public void TestSetWithStringNoBroadcast()
        {
            Messenger.Reset();

            var vm = new ViewModelStub();
            const int expectedValue = 1234;
            var receivedValueChanged = 0;
            var receivedValueChanging = 0;
            var receivedValueWithMessenger = 0;

            Messenger.Default.Register<PropertyChangedMessage<int>>(this, msg => receivedValueWithMessenger = msg.NewValue);

            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.PropertyWithStringSetNoBroadcastPropertyName)
                {
                    receivedValueChanged = vm.PropertyWithStringSetNoBroadcast;
                }
            };

#if !WP71
            vm.PropertyChanging += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.PropertyWithStringSetNoBroadcastPropertyName)
                {
                    receivedValueChanging = vm.PropertyWithStringSetNoBroadcast;
                }
            };
#endif

            vm.PropertyWithStringSetNoBroadcast = expectedValue;
            Assert.AreEqual(expectedValue, receivedValueChanged);
#if !WP71
            Assert.AreEqual(-1, receivedValueChanging);
#endif
            Assert.AreEqual(0, receivedValueWithMessenger);
        }
Esempio n. 37
0
        public void TestRaiseValidInvalidPropertyName()
        {
            var vm = new ViewModelStub();

            var receivedPropertyChanged = false;
            var invalidPropertyChangedNameReceived = false;
            var receivedPropertyChanging = false;
            var invalidPropertyChangingNameReceived = false;
            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.RealPropertyPropertyName)
                {
                    receivedPropertyChanged = true;
                }
                else
                {
                    invalidPropertyChangedNameReceived = true;
                }
            };

#if !WP71
            vm.PropertyChanging += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.RealPropertyPropertyName)
                {
                    receivedPropertyChanging = true;
                }
                else
                {
                    invalidPropertyChangingNameReceived = true;
                }
            };

            vm.RaisePropertyChanging(ViewModelStub.RealPropertyPropertyName);
#endif
            vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName);

            Assert.IsTrue(receivedPropertyChanged);
            Assert.IsFalse(invalidPropertyChangedNameReceived);

#if !WP71
            Assert.IsTrue(receivedPropertyChanging);
            Assert.IsFalse(invalidPropertyChangingNameReceived);
#endif

            try
            {
#if !WP71
                vm.RaisePropertyChanging(ViewModelStub.RealPropertyPropertyName + "1");
#endif

#if DEBUG
                Assert.Fail("ArgumentException was expected");
#else
#if !WP71
                Assert.IsTrue(invalidPropertyChangingNameReceived);
#endif
#endif
            }
            catch (ArgumentException)
            {
            }

            try
            {
                vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName + "1");

#if DEBUG
                Assert.Fail("ArgumentException was expected");
#else
                Assert.IsTrue(invalidPropertyChangedNameReceived);
#endif
            }
            catch (ArgumentException)
            {
            }
        }
Esempio n. 38
0
 public void IndexerValidatesPropertyNameWithInvalidValue()
 {
     ViewModelStub viewModel = new ViewModelStub();
     Assert.IsNotNull(viewModel["RequiredProperty"]);
 }
        public void TestSetBroadcast()
        {
            Messenger.Reset();

            var vm = new ViewModelStub();
            const int expectedValue = 1234;
            var receivedValue = 0;
            var receivedValueWithMessenger = 0;

            Messenger.Default.Register<PropertyChangedMessage<int>>(this, msg => receivedValueWithMessenger = msg.NewValue);

            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.PropertyWithSetBroadcastPropertyName)
                {
                    receivedValue = expectedValue;
                }
            };

            vm.PropertyWithSetBroadcast = expectedValue;
            Assert.AreEqual(expectedValue, receivedValue);
            Assert.AreEqual(expectedValue, receivedValueWithMessenger);
        }
        public void TestRaiseValidInvalidPropertyName()
        {
            var vm = new ViewModelStub();

            var receivedPropertyChanged = false;
            var invalidPropertyNameReceived = false;
            vm.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == ViewModelStub.RealPropertyPropertyName)
                {
                    receivedPropertyChanged = true;
                }
                else
                {
                    invalidPropertyNameReceived = true;
                }
            };

            vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName);

            Assert.IsTrue(receivedPropertyChanged);
            Assert.IsFalse(invalidPropertyNameReceived);

            vm.RaisePropertyChanged(ViewModelStub.RealPropertyPropertyName + "1");

            Assert.IsTrue(invalidPropertyNameReceived);
        }