public void Guid_IsEqualTo_Returns_Proper_Result_For_Nullable_Left_Value(string strValue, bool expected)
{
Guid value = Guid.Parse(strValue);
var result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableValue, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void DateTime_IsAfterOrSameAs_Returns_Proper_Results_For_Nullable_Values(bool useNullValue, string stringValue, bool expected)
{
DateTime?value = stringValue.AsNullableDateTime();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsAfterOrSameAs(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Decimal_IsLessThan_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(string stringValue, bool expected)
{
decimal?value = stringValue.AsNullableDecimal();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsLessThan(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void TimeSpan_IsLessThanOrEqualTo_Returns_Proper_Result_For_Nullable_Values(string strValue, bool expected, bool useNull = false)
{
TimeSpan?value = useNull ? (TimeSpan?)null : TimeSpan.Parse(strValue);
var result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableValue, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Decimal_IsLessThanOrEqualTo_Returns_Proper_Results_For_Nullable_Values(bool useNullValue, string stringValue, bool expected)
{
decimal?value = stringValue.AsNullableDecimal();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void DateTimeOffset_IsAfter_Returns_Proper_Results_For_Nullable_Value_And_Not_Nullable_Value(bool useNullValue, string stringValue, bool expected)
{
var value = stringValue.AsDateTimeOffset();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue ? m.NullValue : m.NullableValue, _ => _
.IsAfter(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Guid_IsEqualTo_Returns_Proper_Result_For_Nullable_Right_Value(string strValue, bool expected, bool useNull = false)
{
Guid?value = useNull ? (Guid?)null : Guid.Parse(strValue);
var result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void DateTime_IsAfter_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(string stringValue, bool expected)
{
DateTime?value = stringValue.AsNullableDateTime();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsAfter(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void DateTime_IsBefore_Returns_Proper_Results_For_Nullable_Values(bool useNullValue, string stringValue, bool expected)
{
DateTime?value = stringValue.AsNullableDateTime();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsBefore(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void TimeSpan_IsGreaterThan_Returns_Proper_Result_For_Not_Nullable_Values(string strValue, bool expected)
{
TimeSpan value = TimeSpan.Parse(strValue);
var result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Decimal_IsGreaterThanOrEqualTo_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(string stringValue, bool expected)
{
decimal?value = stringValue.AsNullableDecimal();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsGreaterThanOrEqualTo(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void TimeSpan_IsLessThanOrEqualTo_Returns_Proper_Result_For_Null_Left_Value(string strValue, bool expected)
{
TimeSpan value = TimeSpan.Parse(strValue);
var result = ValitRules <Model>
.Create()
.Ensure(m => m.NullValue, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Property_Tag_Throws_When_Null_Tags_Set_Is_Given()
{
var exception = Record.Exception(() => {
ValitRules <Model>
.Create()
.Ensure(m => m.Value1, _ => _
.Tag(null))
.For(_model)
.Validate();
});
exception.ShouldBeOfType(typeof(ValitException));
}
public void DateTimeOffset_IsBefore_Returns_Proper_Results_For_Not_Nullable_Values(string stringValue, bool expected)
{
var value = stringValue.AsDateTimeOffset();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsBefore(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Validation_With_FailFast_Strategy_Succeeds_When_Valid_Collection_Is_Given()
{
var rootObject = Model.GetValid();
var result = ValitRules <Model>
.Create()
.WithStrategy(picker => picker.FailFast)
.EnsureFor(m => m.NestedObjectCollection, _modelValitator)
.For(rootObject)
.Validate();
result.Succeeded.ShouldBeTrue();
}
public void DateTimeOffset_IsBeforeOrSameAs_Returns_Proper_Results_For_Nullable_Value_And_Not_Nullable_Value(bool useNullValue, string stringValue, bool expected)
{
var value = stringValue.AsDateTimeOffset();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsBeforeOrSameAs(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void DateTimeOffset_IsAfterOrSameAs_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(string stringValue, bool expected)
{
DateTimeOffset?value = stringValue.AsNullableDateTimeOffset();
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsAfterOrSameAs(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Validation_Returns_Proper_Messages_When_Invalid_NestedObject_Is_Given()
{
var rootObject = Model.GetInvalid();
var result = ValitRules <Model>
.Create()
.Ensure(m => m.NestedObject, _modelValitator)
.For(rootObject)
.Validate();
result.ErrorMessages.ShouldNotContain("One");
result.ErrorMessages.ShouldContain("Two");
result.ErrorMessages.ShouldContain("Three");
}
public void Validation_With_Complete_Strategy_Succeeds_When_Valid_Collection_Is_Given()
{
var result = ValitRules <Model>
.Create()
.EnsureFor(m => m.ValidValuesCollection, _ => _
.Required()
.WithMessage("One")
.Email()
.WithMessage("Two"))
.For(_model)
.Validate();
result.Succeeded.ShouldBeTrue();
}
protected override bool Validate()
{
var result = ValitRules <AddUserCommand>
.Create()
.Ensure(c => c.User, _ => _
.Required()
.WithMessage(WeatherAttackNotifications.Command.UserIsRequired))
.For(this)
.Validate();
AddNotification(WeatherAttackNotifications.Get(result.ErrorMessages));
return(Notifications.Count == 0);
}
public void Validation_With_FailFast_Strategy_Succeeds_When_Valid_Collection_Is_Given()
{
var result = ValitRules <Model>
.Create()
.WithStrategy(picker => picker.FailFast)
.EnsureFor(m => m.ValidValuesCollection, _ => _
.Required()
.WithMessage("One")
.Email()
.WithMessage("Two"))
.For(_model)
.Validate();
Assert.True(result.Succeeded);
}
public void Validation_With_FailFast_Strategy_Fails_When_Invalid_Collection_Is_Given()
{
var rootObject = Model.GetInvalid();
var result = ValitRules <Model>
.Create()
.WithStrategy(picker => picker.FailFast)
.EnsureFor(m => m.NestedObjectCollection, new NestedModelRulesProvider())
.For(rootObject)
.Validate();
Assert.False(result.Succeeded);
result.ErrorMessages.Count().ShouldBe(1);
result.ErrorMessages.First().ShouldBe("Two");
}
public static IValitRules <UserModel> GetUserValidator()
{
var Validator = ValitRules <UserModel>
.Create()
.Ensure(m => m.Email, _ => _
.Required()
.Email())
.Ensure(m => m.Password, _ => _
.Required()
.MinLength(10))
.Ensure(m => m.Age, _ => _
.IsGreaterThan(16));
return(Validator);
}
public void Validation_With_Complete_Strategy_Fails_When_Invalid_Collection_Is_Given()
{
var rootObject = Model.GetInvalid();
var result = ValitRules <Model>
.Create()
.EnsureFor(m => m.NestedObjectCollection, new NestedModelRulesProvider())
.For(rootObject)
.Validate();
Assert.False(result.Succeeded);
result.ErrorMessages.Count(m => m == "One").ShouldBe(1);
result.ErrorMessages.Count(m => m == "Two").ShouldBe(1);
result.ErrorMessages.Count(m => m == "Three").ShouldBe(2);
}
public void DefaultMessage_Is_Overriten_If_ErrorMessage_Is_Given()
{
var result = ValitRules <Model> .Create()
.Ensure(m => m.Value, _ => _
.IsNegative()
.WithMessage("1"))
.Ensure(m => m.NullValue, _ => _
.Required()
.WithMessage("2"))
.For(_model)
.Validate();
result.ErrorMessages.Length.ShouldBe(2);
result.ErrorMessages.ShouldContain("1");
result.ErrorMessages.ShouldContain("2");
}
public void ValitRules_GetUntaggedRules_Returns_Correct_Number_Of_Rules()
{
var rules = ValitRules <Model>
.Create()
.Ensure(m => m.Value1, _ => _
.Email()
.Tag("Tag1"))
.Ensure(m => m.Value2, _ => _
.Email())
.Ensure(m => m.NullValue, _ => _
.Required()
.Tag("Tag2"))
.GetUntaggedRules();
rules.Count().ShouldBe(1);
}
public void Validation_With_Complete_Strategy_Fails_When_Invalid_Collection_Is_Given()
{
var result = ValitRules <Model>
.Create()
.EnsureFor(m => m.InvalidValuesCollection, _ => _
.Required()
.WithMessage("One")
.Email()
.WithMessage("Two"))
.For(_model)
.Validate();
result.Succeeded.ShouldBeFalse();
result.ErrorMessages.Count(m => m == "One").ShouldBe(1);
result.ErrorMessages.Count(m => m == "Two").ShouldBe(3);
}
public IValitResult Validate(MovieDto dto, IValitStrategy strategy = null)
=> ValitRules <MovieDto>
.Create()
.WithStrategy(s => s.Complete)
.Ensure(m => m.Id, _ => _
.IsNotEmpty())
.Ensure(m => m.Title, _ => _
.Required())
.Ensure(m => m.AgeRestriction, _ => _
.IsGreaterThanOrEqualTo(3))
.Ensure(m => m.Length, _ => _
.IsPositive())
.Ensure(m => m.Genre, _ => _
.Required())
.For(dto)
.Validate();
public IValitResult Validate(CinemaDto dto, IValitStrategy strategy = null)
=> ValitRules <CinemaDto>
.Create()
.WithStrategy(s => s.Complete)
.Ensure(c => c.Id, _ => _
.IsNotEmpty())
.Ensure(c => c.Name, _ => _
.Required())
.Ensure(c => c.Address, _ => _
.Required())
.Ensure(c => c.Address, new AddressDtoValidator())
.Ensure(c => c.Halls, _ => _
.MinItems(1))
.EnsureFor(c => c.Halls, new HallDtoValidator())
.For(dto)
.Validate();
public bool Validate(out ImmutableArray <string> errors, CRUDOperation operation = CRUDOperation.Create)
{
var builder = ImmutableArray.CreateBuilder <string>();
var result = ValitRules <OpenVPNConfigUpdateRequest>
.Create()
// Ensure the listeners array exists in the request.
.Ensure(m => m.Listeners, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "listeners"))
.MinItems(1)
.WithMessage(FormatValidationError(Errors.FIELD_MINLENGTH, "1")))
// IPAddress / IPNetwork validation, after this, no further "TryParse" is required.
.EnsureFor(m => m.Listeners, OpenVPNListener.validator)
.Ensure(m => m.AllowMultipleConnectionsFromSameClient, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "allowMultipleConnectionsFromSameClient")))
.Ensure(m => m.ClientToClient, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "clientToClient")))
.Ensure(m => m.MaxClients, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "maxClients"))
.IsGreaterThanOrEqualTo(512)
.WithMessage(FormatValidationError(Errors.FIELD_MINLENGTH, "512"))
.IsLessThanOrEqualTo(2048)
.WithMessage(FormatValidationError(Errors.FIELD_MAXLENGTH, "2048")))
.Ensure(m => m.DhcpOptions, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "dhcpOptions")))
.Ensure(m => m.PushedNetworks, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "pushedNetworks")))
.EnsureFor(m => m.PushedNetworks, _ => _
.Satisfies(x => IPNetwork.TryParse(x, out var _))
.WithMessage(FormatValidationError(Errors.FIELD_INVALID, "pushedNetworks")))
.Ensure(m => m.RedirectGateway, _ => _
.Required()
.WithMessage(FormatValidationError(Errors.FIELD_REQUIRED, "redirectGateway")))
.For(this)
.Validate();
errors = result.ErrorMessages;
return(result.Succeeded);
}
