public void CanUpdate_should_throw_exception_if_pattern_exists()
{
var id1 = DomainId.NewGuid();
var id2 = DomainId.NewGuid();
var patterns_1 = patterns_0.Add(id1, "Pattern1", "[0-5]", "Message");
var patterns_2 = patterns_1.Add(id2, "Pattern2", "[0-4]", "Message");
var command = new UpdatePattern {
PatternId = id2, Name = "Pattern2", Pattern = "[0-5]"
};
ValidationAssert.Throws(() => GuardAppPatterns.CanUpdate(patterns_2, command),
new ValidationError("This pattern already exists but with another name."));
}
public async Task CanChangeStatus_should_throw_exception_if_due_date_in_past()
{
var schema = CreateSchema(false);
var content = CreateContent(Status.Draft);
var command = new ChangeContentStatus {
Status = Status.Published, DueTime = dueTimeInPast, User = user
};
A.CallTo(() => contentWorkflow.CanMoveToAsync(content, content.Status, command.Status, user))
.Returns(true);
await ValidationAssert.ThrowsAsync(() => GuardContent.CanChangeStatus(schema, content, contentWorkflow, command),
new ValidationError("Due time must be in the future.", "DueTime"));
}
public async Task CanAssign_should_throw_exception_if_contributor_max_reached()
{
A.CallTo(() => appPlan.MaxContributors)
.Returns(2);
var command = new AssignContributor {
ContributorId = "3"
};
var contributors_1 = contributors_0.Assign("1", Role.Owner);
var contributors_2 = contributors_1.Assign("2", Role.Editor);
await ValidationAssert.ThrowsAsync(() => GuardAppContributors.CanAssign(command, App(contributors_2), users, appPlan),
new ValidationError("You have reached the maximum number of contributors for your plan."));
}
public void Join_WhenResultsContainEqualErrors_DoesNotFiltersErrors()
{
var firstEqualError = CreateValidationError("Equal error");
var secondEqualError = CreateValidationError("Equal error");
Assert.AreEqual(firstEqualError, secondEqualError, "Assumption failed");
var s1 = CreateValidationResult(firstEqualError);
var s2 = CreateValidationResult(secondEqualError);
var joined = ValidationResult.Join(s1, s2);
var expected = new ValidationResult(new[] { firstEqualError, secondEqualError });
ValidationAssert.AreEqual(expected, joined);
}
public async Task CanChangeStatus_should_throw_exception_if_status_flow_not_valid()
{
var schema = CreateSchema(false);
var content = CreateContent(Status.Draft);
var command = new ChangeContentStatus {
Status = Status.Published, User = user
};
A.CallTo(() => contentWorkflow.CanMoveToAsync(content, content.Status, command.Status, user))
.Returns(false);
await ValidationAssert.ThrowsAsync(() => GuardContent.CanChangeStatus(schema, content, contentWorkflow, command),
new ValidationError("Cannot change status from Draft to Published.", "Status"));
}
public async Task CanCreate_should_throw_exception_if_trigger_null()
{
var command = new CreateRule
{
Trigger = null !,
Action = new TestAction
{
Url = validUrl
},
AppId = appId
};
await ValidationAssert.ThrowsAsync(() => GuardRule.CanCreate(command, appProvider),
new ValidationError("Trigger is required.", "Trigger"));
}
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 GetValueOfUnloadedGrandChild_WhenRevalidateLoadedDescendantsWasCalledBefore_ValidatesGrandchild()
{
VM.Revalidate(ValidationScope.SelfAndLoadedDescendants);
VM.GetValue(x => x.UnloadedChild);
VM.GetValue(x => x.UnloadedChild).GetValue(x => x.Items);
ValidationAssert.ErrorMessages(
VM.ValidationResult,
LoadedChildError,
LoadedGrandChildError,
UnloadedChildError,
UnloadedGrandChildError
);
}
public async Task CanCreate_should_throw_exception_if_action_null()
{
var command = new CreateRule
{
Trigger = new ContentChangedTriggerV2
{
Schemas = ReadOnlyCollection.Empty <ContentChangedTriggerSchemaV2>()
},
Action = null !,
AppId = appId
};
await ValidationAssert.ThrowsAsync(() => GuardRule.CanCreate(command, appProvider),
new ValidationError("Action is required.", "Action"));
}
public void CanUpdate_should_throw_exception_if_name_exists()
{
var id1 = DomainId.NewGuid();
var id2 = DomainId.NewGuid();
var patterns_1 = patterns_0.Add(id1, "Pattern1", "[0-5]", "Message");
var patterns_2 = patterns_1.Add(id2, "Pattern2", "[0-4]", "Message");
var command = new UpdatePattern {
PatternId = id2, Name = "Pattern1", Pattern = "[0-4]"
};
ValidationAssert.Throws(() => GuardAppPatterns.CanUpdate(command, App(patterns_2)),
new ValidationError("A pattern with the same name already exists."));
}
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 CanUpdate_should_throw_exception_if_text_not_defined()
{
var commentId = DomainId.NewGuid();
var command = new UpdateComment {
CommentId = commentId, Actor = user1
};
var events = new List <Envelope <CommentsEvent> >
{
Envelope.Create <CommentsEvent>(new CommentCreated {
CommentId = commentId, Actor = user1
}).To <CommentsEvent>()
};
ValidationAssert.Throws(() => GuardComments.CanUpdate(commentsId, events, command),
new ValidationError("Text is required.", "Text"));
}
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 async Task CanMove_should_throw_exception_when_adding_to_its_own_child()
{
var id = Guid.NewGuid();
var command = new MoveAssetFolder {
ParentId = Guid.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(command.ParentId))
.Returns(new List <IAssetFolderEntity>
{
CreateFolder(id),
CreateFolder(command.ParentId)
});
await ValidationAssert.ThrowsAsync(() => GuardAssetFolder.CanMove(command, assetQuery, id, Guid.NewGuid()),
new ValidationError("Cannot add folder to its own child.", "ParentId"));
}
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 async Task CanMove_should_throw_exception_if_adding_to_its_own_child()
{
var id = DomainId.NewGuid();
var command = new MoveAssetFolder {
AppId = appId, ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId, A <CancellationToken> ._))
.Returns(new List <IAssetFolderEntity>
{
AssetFolder(id),
AssetFolder(command.ParentId)
});
await ValidationAssert.ThrowsAsync(() => GuardAssetFolder.CanMove(command, AssetFolder(id), assetQuery),
new ValidationError("Cannot add folder to its own child.", "ParentId"));
}
[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 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);
}
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 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 CanCreate_should_throw_exception_if_field_name_invalid()
{
var command = CreateCommand(new CreateSchema
{
Fields = new[]
{
new UpsertSchemaField
{
Name = "invalid name",
Properties = new StringFieldProperties(),
Partitioning = Partitioning.Invariant.Key
}
},
Name = "new-schema"
});
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Name is not a Javascript property name.",
"Fields[0].Name"));
}
public void Revalidate_WhenDescendantAddsValidationError_AddsErrorToAncestorValidationResult()
{
Results.SetupFailing().PropertyValidation
.Targeting(Child, x => x.ChildProperty)
.On(Child);
Results.SetupFailing().ViewModelValidation
.Targeting(Child)
.On(Child);
Child.Revalidate(x => x.ChildProperty);
Results.VerifySetupValidationResults();
var expectedAncestorResult = new ValidationResult(
Results.ValidatorSetups.SelectMany(x => x.Result.Errors)
);
ValidationAssert.AreEqual(expectedAncestorResult, Grandparent.ValidationResult);
}
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 SetIsSelectedProperty_WhenSelectedItemGetsInvalid_CorrectlyUpdatesIsSelectedOfAllItems()
{
var vm = CreateUserVM(
allDepartments: new[] { Department1, Department2 },
selectedDepartment: DepartmentNotInSource
);
vm.Department.Load(x => x.SelectedItem);
ValidationAssert.IsInvalid(vm);
Department[] areSelected = vm
.Department
.AllItems
.Where(x => x.IsSelected)
.Select(x => x.Source)
.ToArray();
CollectionAssert.AreEquivalent(new[] { DepartmentNotInSource }, areSelected);
vm.Department.SelectedItem = vm
.Department
.AllItems
.Single(x => x.Source == Department1);
vm
.Department
.AllItems
.Where(x => x.Source == DepartmentNotInSource)
.Single()
.IsSelected = true;
areSelected = vm
.Department
.AllItems
.Where(x => x.IsSelected)
.Select(x => x.Source)
.ToArray();
Assert.AreEqual(1, areSelected.Length);
Assert.AreEqual(DepartmentNotInSource, areSelected[0]);
}
public void CanCreate_should_throw_exception_if_field_name_invalid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <UpsertSchemaField>
{
new UpsertSchemaField
{
Name = "invalid name",
Properties = new StringFieldProperties(),
Partitioning = Partitioning.Invariant.Key
}
},
Name = "new-schema"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Field name must be a valid javascript property name.",
"Fields[1].Name"));
}
public Task CanCreate_should_throw_exception_if_field_properties_null()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "field1",
Properties = null,
Partitioning = Partitioning.Invariant.Key
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Field properties is required.",
"Fields[1].Properties")));
}
public Task CanCreate_should_throw_exception_if_field_partitioning_not_valid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "field1",
Properties = new StringFieldProperties(),
Partitioning = "INVALID"
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Field partitioning is not valid.",
"Fields[1].Partitioning")));
}
public void CanCreate_should_throw_exception_if_field_partitioning_not_valid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <UpsertSchemaField>
{
new UpsertSchemaField
{
Name = "field1",
Properties = new StringFieldProperties(),
Partitioning = "INVALID"
}
},
Name = "new-schema"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Partitioning is not a valid value.",
"Fields[1].Partitioning"));
}
