public void String_Email_Fails_For_Invalid_Email(string value)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => value, _ => _
.Email())
.For(_model)
.Validate();
result.Succeeded.ShouldBe(false, value);
}
public void Byte_IsEqualTo_Returns_Proper_Results_For_Nullable_Value_And_Not_Nullable_Value(bool useNullValue, byte value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Int32_IsPositive_Succeeds_When_Given_Value_Is_Postive()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.PositiveValue, _ => _
.IsPositive())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, true);
}
public void Decimal_IsPositive_Fails_When_Given_Value_Is_Negative()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NegativeValue, _ => _
.IsPositive())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, false);
}
public void Double_IsGreaterThan_Returns_Proper_Results_For_Nullable_Values(bool useNullValue, double?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue ? m.NullValue : m.NullableValue, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Float_IsNaN_Fails_When_NullableNaN_Is_Given()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableNaN, _ => _
.IsNaN())
.For(_model)
.Validate();
result.Succeeded.ShouldBeTrue();
}
public void Decimal_IsGreaterThan_Returns_Proper_Results_For_Nullable_Value_And_Not_Nullable_Value(bool useNullValue, decimal value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void UInt64_IsGreaterThan_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(ulong?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Boolean_IsFalse_Returns_Proper_Results_For_Nullable_Values(bool useTrueValue, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useTrueValue ? m.NullableTrueValue : m.NullableFalseValue, _ => _
.IsFalse())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Double_IsEqualTo_Returns_Proper_Results_For_NullableNaN_And_Value(double value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableNaN, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void String_MinLength_Returns_Proper_Result_For_Left_Null_Value(int value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullValue, _ => _
.MinLength(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Double_IsEqualTo_Returns_Proper_Results_For_Nullable_Values(bool useNullValue, double?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue ? m.NullValue : m.NullableValue, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Double_IsNumber_Fails_When_NullableNaN_Is_Given()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableNaN, _ => _
.IsNumber())
.For(_model)
.Validate();
result.Succeeded.ShouldBeFalse();
}
public void Double_IsNumber_Succeeds_When_Value_Is_Given()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsNumber())
.For(_model)
.Validate();
result.Succeeded.ShouldBeTrue();
}
public void Float_IsGreaterThanOrEqualTo_Returns_Proper_Results_For_NaN_And_Value(float value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NaN, _ => _
.IsGreaterThanOrEqualTo(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Int64_IsNonZero_Returns_Proper_Results_For_Nullable_Value(bool useZeroValue, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useZeroValue? m.NullableZeroValue : m.NullableValue, _ => _
.IsNonZero())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Float_IsNaN_Fails_When_Value_Is_Given()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsNaN())
.For(_model)
.Validate();
result.Succeeded.ShouldBeFalse();
}
public void Int64_IsNonZero_Fails_For_Null_Value()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullValue, _ => _
.IsNonZero())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, false);
}
public void UInt16_IsLessThanOrEqualTo_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(ushort?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Float_Required_Fails_For_NullValue()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullValue, _ => _
.Required())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, false);
}
public void Float_IsLessThanOrEqualTo_Returns_Proper_Results_For_NaN_And_NullableValue(float?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NaN, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Float_Required_Succeeds_For_NullableNaN()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableNaN, _ => _
.Required())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, true);
}
public void Int32_IsLessThanOrEqualTo_Returns_Proper_Results_For_Not_Nullable_Value_And_Nullable_Value(int?value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Int64_Required_Returns_Proper_Results_For_Nullable_Value(bool useNullValue, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.Required())
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Double_IsGreaterThan_Returns_Proper_Results_For_NullableNaN_And_Value(double value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableNaN, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void Float_IsGreaterThan_Returns_Proper_Results_For_Not_Nullable_Values(float value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsGreaterThan(value))
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, expected);
}
public void SByte_IsLessThanOrEqualTo_Returns_Proper_Results_For_Nullable_Value_And_Not_Nullable_Value(bool useNullValue, sbyte value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => useNullValue? m.NullValue : m.NullableValue, _ => _
.IsLessThanOrEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Int32_IsEqualTo_Returns_Proper_Results_For_Not_Nullable_Values(int value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsEqualTo(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
public void Int32_IsPositive_Fails_When_Given_Value_Is_NullableZero()
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.NullableZeroValue, _ => _
.IsPositive())
.For(_model)
.Validate();
Assert.Equal(result.Succeeded, false);
}
public void Byte_IsLessThan_Returns_Proper_Results_For_Not_Nullable_Values(byte value, bool expected)
{
IValitResult result = ValitRules <Model>
.Create()
.Ensure(m => m.Value, _ => _
.IsLessThan(value))
.For(_model)
.Validate();
result.Succeeded.ShouldBe(expected);
}
