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 OwnerResult_WhenInvalidItemIsInTwoCollections_ContainsItemErrorOnlyOnce()
{
var invalidItem = CreateInvalidItem();
Owner.CollectionOne.Add(invalidItem);
Owner.CollectionTwo.Add(invalidItem);
ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidItem.ErrorToReturn);
}
public void OwnerResult_WhenInvalidItemIsInCollectionAndReferencedByProperty_ContainsItemErrorOnlyOnce()
{
var invalidItem = CreateInvalidItem();
Owner.CollectionOne.Add(invalidItem);
Owner.ItemProperty = invalidItem;
ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidItem.ErrorToReturn);
}
public void SetValue_ViewModelValidationFails_AddsValidationErrorToViewModel()
{
var vm = EmployeeVM.Create(WithPropertyAndViewModelValidation);
ViewModelErrorToReturn = ExpectedViewModelError;
vm.SetValue(x => x.Name, "New value");
ValidationAssert.ErrorMessages(vm.ValidationResult, ExpectedViewModelError);
}
public void SetValue_PropertyAndViewModelValidationFail_ValidationResultContainsBothErrors()
{
var vm = EmployeeVM.Create(WithPropertyAndViewModelValidation);
NamePropertyErrorToReturn = ExpectedNamePropertyError;
ViewModelErrorToReturn = ExpectedViewModelError;
vm.SetValue(x => x.Name, "New value");
ValidationAssert.ErrorMessages(vm.ValidationResult, ExpectedNamePropertyError, ExpectedViewModelError);
}
public void OwnerResult_WhenInvalidItemIsInCollectionAndReferencedByPropertyAndPropertyIsSetToNull_StillContainsItemError()
{
var invalidItem = CreateInvalidItem();
Owner.CollectionOne.Add(invalidItem);
Owner.ItemProperty = invalidItem;
Owner.ItemProperty = null;
ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidItem.ErrorToReturn);
}
public void OwnerResult_WhenInvalidItemIsInTwoCollectionAndRemovedFromOne_StillContainsItemError()
{
var invalidItem = CreateInvalidItem();
Owner.CollectionOne.Add(invalidItem);
Owner.CollectionTwo.Add(invalidItem);
Owner.CollectionTwo.Remove(invalidItem);
ValidationAssert.ErrorMessages(Owner.ValidationResult, invalidItem.ErrorToReturn);
}
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 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 RevalidateLoadedDescendants_RevalidatesOnlyLoadedDescendants()
{
VM.Revalidate(ValidationScope.SelfAndLoadedDescendants);
Assert.IsFalse(VM.IsLoaded(x => x.UnloadedChild));
ValidationAssert.ErrorMessages(
VM.ValidationResult,
LoadedChildError,
LoadedGrandChildError
);
}
public void GetValueOfUnloadedChild_WhenRevalidateLoadedDescendantsWasCalledBefore_ValidatesChild()
{
VM.Revalidate(ValidationScope.SelfAndLoadedDescendants);
VM.GetValue(x => x.UnloadedChild);
ValidationAssert.ErrorMessages(
VM.ValidationResult,
LoadedChildError,
LoadedGrandChildError,
UnloadedChildError
);
}
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 RevalidateAllDescendants_LoadsAndValidatesAllDescendants()
{
VM.Revalidate(ValidationScope.SelfAndAllDescendants);
Assert.IsTrue(VM.IsLoaded(x => x.UnloadedChild));
ValidationAssert.ErrorMessages(
VM.ValidationResult,
LoadedChildError,
LoadedGrandChildError,
UnloadedChildError,
UnloadedGrandChildError
);
}
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 Refresh_OfViewModelProperty_RevalidatesPropertyValue()
{
ParameterizedTest
.TestCase("InstanceProperty", new Func <RootVMDescriptor, IVMPropertyDescriptor>(x => x.InstanceProperty))
.TestCase("MappedProperty", x => x.WrapperProperty)
.TestCase("DelegateProperty", x => x.DelegateProperty)
.Run(propertySelector => {
var property = propertySelector(VM.Descriptor);
var expectedError = "Validation error";
VM.ValidationErrors[property] = expectedError;
VM.Refresh(propertySelector);
ValidationAssert.ErrorMessages(VM.GetValidationResult(property), expectedError);
});
}
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_ToNewChild_RevalidatesOldAndNewChild()
{
var vm = new ParentVM();
var oldChild = new ChildVM();
var newChild = new ChildVM();
vm.SetValue(x => x.Child, oldChild);
oldChild.ChildPropertyErrorMessage = "Old validation error";
newChild.ChildPropertyErrorMessage = "New validation error";
vm.SetValue(x => x.Child, newChild);
ValidationAssert.ErrorMessages(oldChild.ValidationResult, oldChild.ChildPropertyErrorMessage);
ValidationAssert.ErrorMessages(newChild.ValidationResult, newChild.ChildPropertyErrorMessage);
}
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 ViewModelValidationDefinedOnParent_IsPerformedIfChildOnlyCallsEnableParentValidation()
{
var error = "Parent added error";
var parent = EmployeeVM.Create(b => {
b.ValidateDescendant(x => x.SelectedProject)
.CheckViewModel(args => args.AddError(error));
});
var child = ProjectVM.Create(b => {
b.EnableParentViewModelValidation();
});
parent.SetValue(x => x.SelectedProject, child);
parent.Revalidate(ValidationScope.SelfAndAllDescendants);
ValidationAssert.ErrorMessages(child.ValidationResult, error);
}
public void RefreshContainer_WhenItemIsAddedToSoureCollection_RevalidatesSelectionOfItemVMWhenLoaded()
{
Employee emp = new Employee();
EmployeeVM empVM = new EmployeeVM();
empVM.InitializeFrom(emp);
empVM.Load(x => x.Projects);
emp.AddProjekt();
empVM.RefreshContainer(x => x.Projects);
ProjectVM projectVM = empVM.GetValue(x => x.Projects).Single();
projectVM.Load(x => x.Department);
ValidationAssert.ErrorMessages(projectVM.GetValidationResult(ValidationResultScope.All), ProjectVM.ValidationError);
}
[TestMethod] // regression test
public void SetValue_WhenOldAndNewChildGetInvalid_ParentResultContainsOnlyErrorOfNewChild()
{
var parent = new ParentVM();
var oldChild = new ChildVM();
var newChild = new ChildVM();
parent.SetValue(x => x.Child, oldChild);
oldChild.ChildPropertyErrorMessage = "Old validation error";
newChild.ChildPropertyErrorMessage = "New validation error";
parent.SetValue(x => x.Child, newChild);
ValidationAssert.ErrorMessages(
parent.ValidationResult,
ParentVM.ChildInvalidMessage,
newChild.ChildPropertyErrorMessage
);
}
public void Min_ExecutedSecondTime_ReturnsUpdatedErrorMessage()
{
int min = 10;
int currentValue = 100;
var vm = CreateParent(b => b.Check(x => x.IntegerProperty).Min(x => min));
vm.SetValue(x => x.IntegerProperty, currentValue);
min = currentValue + 1;
vm.Revalidate();
min = currentValue + 2;
vm.Revalidate();
ValidationAssert.ErrorMessages(
vm.ValidationResult,
Localized.ValidationMin.FormatWith(min)
);
}
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);
}
