public void IsUnique_WithDuplicateStringProperties_InvalidatesViewModel() { var error = "Duplicate item"; var vm = CreateParent(b => b .CheckCollection(x => x.Children, x => x.StringProperty) .IsUnique(StringComparison.CurrentCultureIgnoreCase, error) ); var item1 = new ChildVM("Item 1") { StringProperty = "VAL1" }; var item2 = new ChildVM("Item 2") { StringProperty = "VAL2" }; var item3 = new ChildVM("Item 3") { StringProperty = "VAL3" }; vm.Children.Add(item1); vm.Children.Add(item2); vm.Children.Add(item3); ValidationAssert.IsValid(vm); item3.StringProperty = "VAL2"; var expectedResult = CreateValidationResult( Error(error).For(item3, x => x.StringProperty), Error(error).For(item2, x => x.StringProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void Min_ForNullableIntegerProperty_ValidatesPropertyAccordingly() { var errorMessage = "Value below min"; int min = 10; int belowMin = min - 1; var vm = CreateParent(b => b .Check(x => x.NullableIntegerProperty) .Min(min, errorMessage) ); vm.SetValue(x => x.NullableIntegerProperty, null); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, min); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, belowMin); var expectedResult = CreateValidationResult( Error(errorMessage).For(vm, x => x.NullableIntegerProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void Max_ForNullableIntegerProperty_ValidatesPropertyAccordingly() { var errorMessage = "Value above max"; int max = 10; int aboveMax = max + 1; var vm = CreateParent(b => b .Check(x => x.NullableIntegerProperty) .Max(max, errorMessage) ); vm.SetValue(x => x.NullableIntegerProperty, null); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, max); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, aboveMax); var expectedResult = CreateValidationResult( Error(errorMessage).For(vm, x => x.NullableIntegerProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void Max_ForNullableIntegerPropertyWithMaxValueSelector_ValidatesPropertyAccordingly() { var errorMessage = "Value above max"; var vm = CreateParent(b => b .Check(x => x.NullableIntegerProperty) .Max(x => x.Limit, errorMessage) ); vm.Limit = 3; vm.SetValue(x => x.NullableIntegerProperty, null); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, vm.Limit); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, vm.Limit + 1); var expectedResult = CreateValidationResult( Error(errorMessage).For(vm, x => x.NullableIntegerProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void ValidateProperties_InvalidProperty_InvalidatesViewModel() { var propertyValid = true; var error = "Some fields are invalid"; var vm = CreateChild(b => { b.ValidateProperties(error); b.Check(x => x.StringProperty).Custom(x => { if (!propertyValid) { x.AddError("Property error"); } }); }); vm.Revalidate(); ValidationAssert.IsValid(vm); propertyValid = false; vm.Revalidate(); var viewModelOnlyResult = vm.GetValidationResult(ValidationResultScope.ViewModelValidationsOnly); ValidationAssert.ErrorMessages(viewModelOnlyResult, error); }
public void Revalidate_ValidationSucceeds_UpdatesValidationState() { SetPropertyToValidValue(); SetPropertyToInvalidValue(); VM.PropertyResultToReturn = ValidationResult.Valid; RevalidateProperty(); ValidationAssert.IsValid(VM.ValidationResult); }
public void CheckLength_PropertyLengthExceedsMaximumLength_AddsValidationErrorToProperty() { var error = "Value too long"; var vm = CreateChild(b => b.Check(x => x.StringProperty).Length(4, error)); vm.StringProperty = "1234"; ValidationAssert.IsValid(vm); vm.StringProperty = "12345"; ValidationAssert.ErrorMessages(vm.ValidationResult, error); }
public void VerifySetupValidationResults() { var expectedErrors = ValidatorSetups .Where(x => !x.Result.IsValid) .SelectMany(x => x.Result.Errors) .ToArray(); ValidationAssert.Errors(expectedErrors); // TODO: Check if this logic is correct for collection expectations. var validViewModelPropertyCombinations = ActualInvocations .Where(x => x.TargetVM != null) .GroupBy(x => new { VM = x.TargetVM, Prop = x.TargetProperty }) .Where(g => !ValidatorSetups .Select(x => new { VM = x.Invocation.TargetVM, Prop = x.Invocation.TargetProperty }) .Contains(g.Key) ); foreach (var item in validViewModelPropertyCombinations) { var target = item.Key.VM; var targetProperty = item.Key.Prop; if (targetProperty != null) { ValidationAssert.IsValid(target, targetProperty); } else { ValidationAssert.ValidViewModelValidationResultIsValid(target); } } var validSetup = ValidatorSetups.Where(x => x.Result.IsValid); foreach (var setup in validSetup) { var target = setup.Invocation.TargetVM; var targetProperty = setup.Invocation.TargetProperty; if (targetProperty != null) { ValidationAssert.IsValid(target, targetProperty); } else { ValidationAssert.ValidViewModelValidationResultIsValid(target); } } }
public void HasValue_PropertyHasNoValue_AddsValidationErrorToProperty() { var error = "Value required"; var vm = CreateChild(b => b.Check(x => x.StringProperty).HasValue(error)); vm.StringProperty = "Valid value"; ValidationAssert.IsValid(vm); vm.StringProperty = String.Empty; ValidationAssert.ErrorMessages(vm.ValidationResult, error); }
public void OwnerResult_WhenInvalidItemIsInTwoCollectionAndRemovedFromBoth_DoesNotContainItemErrorAnymore() { var invalidItem = CreateInvalidItem(); Owner.CollectionOne.Add(invalidItem); Owner.CollectionTwo.Add(invalidItem); Owner.CollectionOne.Remove(invalidItem); Owner.CollectionTwo.Remove(invalidItem); ValidationAssert.IsValid(Owner); }
public void OwnerResult_WhenPopulatedCollectionPropertyIsLoadedAndReturnsNewInvalidViewModel_ContainsError() { // This IsValid call is important, otherwise the bug that is tested here isn't triggered! ValidationAssert.IsValid(Owner); var invalidChild = CreateInvalidItem(); Owner.PopulatedCollectionPropertyItemToReturn = invalidChild; Owner.Load(x => x.PopulatedCollection); ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidChild.ErrorToReturn); }
public void OwnerResult_WhenInvalidItemIsRemovedFromCollectionAndPropertyIsSetToNull_DoesNotContainItemErrorAnymore() { var invalidItem = CreateInvalidItem(); Owner.CollectionOne.Add(invalidItem); Owner.ItemProperty = invalidItem; Owner.CollectionOne.Remove(invalidItem); Owner.ItemProperty = null; ValidationAssert.IsValid(Owner); }
public void SelectedItem_WhenNonExistingItemIsInitiallySelected_IsInvalid() { var vm = CreateUserVM( allDepartments: new[] { Department1 }, selectedDepartment: Department2 ); ValidationAssert.IsValid(vm); vm.Department.Load(x => x.SelectedItem); ValidationAssert.IsInvalid(vm); }
[TestMethod] // regression test public void SetValue_WhenOldChildGetsInvalidAndNewChildIsValid_ParentValidationResultIsValid() { var parent = new ParentVM(); var oldChild = new ChildVM(); var newChild = new ChildVM(); parent.SetValue(x => x.Child, oldChild); oldChild.ChildPropertyErrorMessage = "Old validation error"; parent.SetValue(x => x.Child, newChild); ValidationAssert.IsValid(parent.ValidationResult); }
public void RegexValidation_RegexPatternMatches_InvalidatesViewModel() { var error = "Invalid number"; var vm = CreateChild(b => b .Check(x => x.StringProperty) .RegexValidation(@"\d+", error) ); vm.StringProperty = "1234"; ValidationAssert.IsValid(vm); vm.StringProperty = "AnInvalidNumber"; ValidationAssert.ErrorMessages(vm.ValidationResult, error); }
public void OwnerResult_WhenDelegatedViewModelPropertyIsRefreshedAndReturnsNewInvalidViewModel_ContainsError() { Owner.DelegatedPropertyResultToReturn = new ItemVM(); Owner.Load(x => x.DelegatedProperty); ValidationAssert.IsValid(Owner); var invalidChild = CreateInvalidItem(); Owner.DelegatedPropertyResultToReturn = invalidChild; ValidationAssert.IsValid(Owner); Owner.Refresh(x => x.DelegatedProperty); Assert.IsFalse(Owner.DelegatedProperty.IsValid); ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidChild.ErrorToReturn); }
public void SetValue_RemovesValidationErrorsOfAncestorValidatorsFromOldChild() { string parentErrorMessage = "Parent error"; var vm = new ParentVM(); var oldChild = new ChildVM(); var newChild = new ChildVM(); vm.ChildPropertyErrorMessage = parentErrorMessage; vm.SetValue(x => x.Child, oldChild); ValidationAssert.ErrorMessages(oldChild.ValidationResult, parentErrorMessage); vm.SetValue(x => x.Child, newChild); ValidationAssert.IsValid(oldChild); }
public void GetValidationResult_Initially_ReturnsValidResults() { var vm = new TestVM(); ParameterizedTest .TestCase(ValidationResultScope.PropertiesOnly) .TestCase(ValidationResultScope.ViewModelValidationsOnly) .TestCase(ValidationResultScope.Self) .TestCase(ValidationResultScope.Descendants) .TestCase(ValidationResultScope.All) .Run(scope => { var result = vm .Behavior .GetValidationResult(vm.GetContext(), scope); ValidationAssert.IsValid(result); }); }
public void ViewModelCollectionValidation_WhenItemConditionIsFalse_IsNotExecuted() { ProjectVM project1 = new ProjectVM(); ProjectVM project2 = new ProjectVM(); EmployeeVM vm = CreateVM(b => b .ValidateDescendant(x => x.Projects) .When(args => args.Target == project2) .CheckViewModel(args => args.AddError("Test error")) ); vm.Projects.Add(project1); vm.Projects.Add(project2); vm.Revalidate(ValidationScope.SelfAndAllDescendants); ValidationAssert.IsValid(project1); ValidationAssert.IsInvalid(project2); }
public void PropertyValidation_WhenConditionIsFalse_IsNotExecuted() { bool condition = true; EmployeeVM vm = CreateVM(b => b .When(args => condition) .Check(x => x.Name) .Custom(args => args.AddError("Test error")) ); vm.Revalidate(ValidationScope.SelfAndAllDescendants); ValidationAssert.IsInvalid(vm); condition = false; vm.Revalidate(ValidationScope.SelfAndAllDescendants); ValidationAssert.IsValid(vm); }
public void Min_ForIntegerPropertyWithMinValueSelector_ValidatesPropertyAccordingly() { var errorMessage = "Value below min"; var vm = CreateParent(b => b .Check(x => x.IntegerProperty) .Min(x => x.Limit, errorMessage) ); vm.Limit = 3; vm.SetValue(x => x.IntegerProperty, vm.Limit); ValidationAssert.IsValid(vm); vm.SetValue(x => x.IntegerProperty, vm.Limit - 1); var expectedResult = CreateValidationResult( Error(errorMessage).For(vm, x => x.IntegerProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void ValidationResult_WhenExistingItemIsSelectedWhenCurrentItemDoesNotExist_BecomesValid() { var allGroups = new[] { Group1, InactiveGroup }; var selectableGroups = new[] { Group1, Group2 }; var vm = CreateUserVM( allGroups: allGroups, filter: (v, x) => x.IsActive, selectedGroups: Group2 ); var selectionVM = vm.GetValue(x => x.Groups); selectionVM.Load(x => x.SelectedItems); Assert.IsFalse(selectionVM.IsValid); var existingItem = selectionVM .AllItems .Single(x => x.Source == Group1); selectionVM.SelectedItems.Clear(); ValidationAssert.IsValid(selectionVM); }
public void ValidationResult_WhenExistingItemIsSelectedWhenCurrentItemDoesNotExist_BecomesValid() { var allDepartments = new[] { Department1 }; var allIncludingSelected = new[] { Department1, Department2 }; var vm = CreateUserVM( allDepartments: allDepartments, selectedDepartment: Department2 ); var selectionVM = vm.GetValue(x => x.Department); selectionVM.Load(x => x.SelectedItem); Assert.IsFalse(selectionVM.IsValid); var existingItem = selectionVM .AllItems .Single(x => x.Source == Department1); selectionVM.SetValue(x => x.SelectedItem, existingItem); ValidationAssert.IsValid(selectionVM); }
public void PropagateChildErrors_WithInvalidChildren_ParentHasError() { var error = "Child records are invalid"; var validItem = new ChildVM(); var invalidItem = new ChildVM(); var childDescriptor = CreateChildDescriptor(b => b.CheckViewModel(args => { if (args.Target == invalidItem) { args.AddError("Item error"); } })); ParentVM vm = CreateParent(b => b.PropagateChildErrors(error), childDescriptor); vm.Children.Add(validItem); ValidationAssert.IsValid(vm.ValidationResult); vm.Children.Add(invalidItem); var actualParentValidationState = vm.GetValidationResult(ValidationResultScope.Self); ValidationAssert.ErrorMessages(actualParentValidationState, error); }
public void ValueInRange_ForNullableIntergerProperty_ValidatesPropertyAccordingly() { var errorMessage = "Value not in range"; int min = 1; int max = 10; int valueOutOfRange = max + 1; var vm = CreateParent(b => b .Check(x => x.NullableIntegerProperty) .ValueInRange(min, max, errorMessage) ); vm.SetValue(x => x.NullableIntegerProperty, null); ValidationAssert.IsValid(vm); vm.SetValue(x => x.NullableIntegerProperty, valueOutOfRange); var expectedResult = CreateValidationResult( Error(errorMessage).For(vm, x => x.NullableIntegerProperty) ); ValidationAssert.AreEqual(expectedResult, vm.ValidationResult); }
public void ItemIsValid_NoErrorIsAdded() { ItemAB.Revalidate(x => x.ItemProperty);; ValidationAssert.IsValid(ItemAB); }
public void GetValue_OfUnvalidatedAndUnloadedDescendant_DoesNotValidateDescendant() { VM.GetValue(x => x.UnloadedChild); ValidationAssert.IsValid(VM); }