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);
}
