/// <summary>
/// Creates the validator.
/// </summary>
/// <param name="modelMetadata">The model metadata.</param>
/// <param name="context">The context.</param>
/// <returns></returns>
protected override ModelValidator CreateValidatorCore(ExtendedModelMetadata modelMetadata, ControllerContext context)
{
var attribute = new RequiredIfAttribute(OtherProperty, Operator, DependentValue);
PopulateErrorMessage(attribute);
return(new FoolproofValidator(modelMetadata, context, attribute));
}
public void verify_validators_caching()
{
const int testLoops = 10;
var generatedCode = Enumerable.Repeat(0, 100).Select(x => "true")
.Aggregate("true", (accumulator, item) => $"({accumulator} && {item} && !false)"); // give the parser some work (deep dive)
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assertThat = new AssertThatAttribute(generatedCode);
var requiredIf = new RequiredIfAttribute(generatedCode);
var nonCached = MeasureExecutionTime(() => new AssertThatValidator(metadata, controllerContext, assertThat));
for (var i = 0; i < testLoops; i++)
{
var cached = MeasureExecutionTime(() => new AssertThatValidator(metadata, controllerContext, assertThat));
Assert.True(nonCached > cached);
}
nonCached = MeasureExecutionTime(() => new RequiredIfValidator(metadata, controllerContext, requiredIf));
for (var i = 0; i < testLoops; i++)
{
var cached = MeasureExecutionTime(() => new RequiredIfValidator(metadata, controllerContext, requiredIf));
Assert.True(nonCached > cached);
}
}
public void throw_when_no_httpcontext_is_available()
{
HttpContext.Current = null;
var model = new Model();
var assertAttribute = new AssertThatAttribute("true");
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws <ValidationException>(() => new AssertThatValidator(metadata, controllerContext, assertAttribute).GetClientValidationRules().Single());
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType <ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
e = Assert.Throws <ValidationException>(() => new RequiredIfValidator(metadata, controllerContext, requirAttribute).GetClientValidationRules().Single());
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType <ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
}
private static void AssertErrorMessage(string input, string assertThatOutput, string requiredIfOutput)
{
var assertThat = new AssertThatAttribute("1!=1");
var requiredIf = new RequiredIfAttribute("1==1");
var isValid = typeof(ExpressiveAttribute).GetMethod("IsValid", BindingFlags.NonPublic | BindingFlags.Instance);
var context = new ValidationContext(new MsgModel
{
Value1 = 0,
Internal = new MsgModel
{
Value1 = 1,
Internal = new MsgModel {
Value1 = 2
}
}
})
{
MemberName = "#{Value1}#"
};
if (input != null)
{
assertThat.ErrorMessage = requiredIf.ErrorMessage = input;
}
var assertThatResult = (ValidationResult)isValid.Invoke(assertThat, new[] { new object(), context });
var requiredIfResult = (ValidationResult)isValid.Invoke(requiredIf, new[] { null, context });
Assert.Equal(assertThatOutput, assertThatResult.ErrorMessage);
Assert.Equal(requiredIfOutput, requiredIfResult.ErrorMessage);
}
public void throw_when_no_httpcontext_is_available()
{
HttpContext.Current = null;
var model = new Model();
var assertAttribute = new AssertThatAttribute("true");
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws<ValidationException>(() => new AssertThatValidator(metadata, controllerContext, assertAttribute).GetClientValidationRules().Single());
Assert.Equal(
"AssertThatValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
e = Assert.Throws<ValidationException>(() => new RequiredIfValidator(metadata, controllerContext, requirAttribute).GetClientValidationRules().Single());
Assert.Equal(
"RequiredIfValidator: collecting of client validation rules for Value field failed.",
e.Message);
Assert.IsType<ApplicationException>(e.InnerException);
Assert.Equal(
"HttpContext not available.",
e.InnerException.Message);
}
public void Ctor_WithName()
{
var expected = "Name";
var target = new RequiredIfAttribute(expected);
//Assert
target.PropertyName.Should().Be(expected);
}
public void ShallThrowIfValidationContextIsNull()
{
var attr = new RequiredIfAttribute("test", "value");
Assert.Throws <ArgumentNullException>(() =>
{
attr.GetValidationResult("value", null);
});
}
public void SuccessfulValidationWithoutTargetedValue()
{
var model = new Mock {
Property = "not the expected target"
};
var context = new ValidationContext(model);
var attr = new RequiredIfAttribute("Property", "value");
var result = attr.GetValidationResult("value", context);
Assert.Equal(ValidationResult.Success, result);
}
public void InvalidIfValueIsNull()
{
var model = new Mock {
Property = "value"
};
var context = new ValidationContext(model);
var attr = new RequiredIfAttribute("Property", "value");
var result = attr.GetValidationResult(null, context);
Assert.Equal("'Mock' is required because 'Property' has a value 'value'.", result.ErrorMessage);
}
public void throw_when_priority_is_not_provided_but_requested_explicitly()
{
var assertThat = new AssertThatAttribute("1!=1");
var requiredIf = new RequiredIfAttribute("1==1");
Assert.Null(assertThat.GetPriority());
Assert.Null(requiredIf.GetPriority());
var e = Assert.Throws <InvalidOperationException>(() => assertThat.Priority);
Assert.Equal("The Priority property has not been set. Use the GetPriority method to get the value.", e.Message);
e = Assert.Throws <InvalidOperationException>(() => requiredIf.Priority);
Assert.Equal("The Priority property has not been set. Use the GetPriority method to get the value.", e.Message);
}
public void verify_attributes_equality()
{
var assertThat = new AssertThatAttribute("1 != 1");
var requiredIf = new RequiredIfAttribute("1 == 1");
var assertThat2 = new AssertThatAttribute("1 != 1");
var requiredIf2 = new RequiredIfAttribute("1 == 1");
Assert.True(assertThat.Equals(assertThat2));
Assert.True(requiredIf.Equals(requiredIf2));
Assert.False(assertThat.Equals(null));
Assert.False(requiredIf.Equals(null));
}
public void ShallThrowIfPropertyIsNotFound()
{
var model = new Mock {
Property = null
};
var context = new ValidationContext(model);
var attr = new RequiredIfAttribute("UnknownProperty", "value");
Assert.Throws <ArgumentNullException>(() =>
{
attr.GetValidationResult("value", context);
});
}
public void RequiredIfAttribute_Test()
{
object passingValueBothPopulated = new { NewPassword = "******", Password = "******" };
object failingValue = new { NewPassword = "******" };
object passingValueNewPasswordNull = new { Password = "******" };
object passingValueBothNull = new { };
RequiredIfAttribute attribute = new RequiredIfAttribute("Password", "NewPassword");
//this does not test the model just the RequiredIfAttribute object's logic.
Assert.IsTrue(attribute.IsValid(passingValueBothPopulated), "Assertion of positive case being true failed");
Assert.IsFalse(attribute.IsValid(failingValue), "Assertion of negative case being false failed");
Assert.IsTrue(attribute.IsValid(passingValueNewPasswordNull), "Assertion of positive case (Field being false failed");
Assert.IsTrue(attribute.IsValid(passingValueBothNull), "Assertion of negative case being false failed");
}
public void verify_attributes_identification()
{
var assertThat = new AssertThatAttribute("1 != 1"); // spaces on purpose
var requiredIf = new RequiredIfAttribute("1 == 1");
const string assertThatRepresentation = "ExpressiveAnnotations.Attributes.AssertThatAttribute[1!=1]";
const string requiredIfRepresentation = "ExpressiveAnnotations.Attributes.RequiredIfAttribute[1==1]";
Assert.Equal(assertThatRepresentation, assertThat.TypeId);
Assert.Equal(requiredIfRepresentation, requiredIf.TypeId);
Assert.Equal(assertThatRepresentation, assertThat.ToString());
Assert.Equal(requiredIfRepresentation, requiredIf.ToString());
Assert.Equal(assertThatRepresentation.GetHashCode(), assertThat.GetHashCode());
Assert.Equal(requiredIfRepresentation.GetHashCode(), requiredIf.GetHashCode());
}
public void throw_when_requirement_is_applied_to_field_of_non_nullable_value_type()
{
var model = new MisusedRequirementModel();
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws <ValidationException>(() => new RequiredIfValidator(metadata, controllerContext, requirAttribute));
Assert.Equal(
"RequiredIfValidator: validation applied to Value field failed.",
e.Message);
Assert.IsType <InvalidOperationException>(e.InnerException);
Assert.Equal(
"RequiredIfAttribute has no effect when applied to a field of non-nullable value type 'System.Int32'. Use nullable 'System.Int32?' version instead, or switch to AssertThatAttribute otherwise.",
e.InnerException.Message);
}
public void verify_attributes_equality()
{
var assertThat = new AssertThatAttribute("1 != 1");
var requiredIf = new RequiredIfAttribute("1 == 1");
var assertThat2 = new AssertThatAttribute("1 != 1");
var requiredIf2 = new RequiredIfAttribute("1 == 1");
Assert.True(assertThat.Equals(assertThat2));
Assert.True(requiredIf.Equals(requiredIf2));
Assert.False(assertThat.Equals(null));
Assert.False(requiredIf.Equals(null));
}
public void verify_validators_caching()
{
const int testLoops = 10;
var generatedCode = Enumerable.Repeat(0, 100).Select(x => "true")
.Aggregate("true", (accumulator, item) => $"({accumulator} && {item} && !false)"); // give the parser some work (deep dive)
var model = new Model();
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var assertThat = new AssertThatAttribute(generatedCode);
var requiredIf = new RequiredIfAttribute(generatedCode);
var nonCached = MeasureExecutionTime(() => new AssertThatValidator(metadata, controllerContext, assertThat));
for (var i = 0; i < testLoops; i++)
{
var cached = MeasureExecutionTime(() => new AssertThatValidator(metadata, controllerContext, assertThat));
Assert.True(nonCached > cached);
}
nonCached = MeasureExecutionTime(() => new RequiredIfValidator(metadata, controllerContext, requiredIf));
for (var i = 0; i < testLoops; i++)
{
var cached = MeasureExecutionTime(() => new RequiredIfValidator(metadata, controllerContext, requiredIf));
Assert.True(nonCached > cached);
}
}
private static void AssertErrorMessage(string input, string assertThatOutput, string requiredIfOutput)
{
var assertThat = new AssertThatAttribute("1!=1");
var requiredIf = new RequiredIfAttribute("1==1");
var isValid = typeof(ExpressiveAttribute).GetMethod("IsValid", BindingFlags.NonPublic | BindingFlags.Instance);
var context = new ValidationContext(new MsgModel
{
Value1 = 0,
Internal = new MsgModel
{
Value1 = 1,
Internal = new MsgModel {Value1 = 2}
}
})
{
MemberName = "Value1"
};
if (input != null)
assertThat.ErrorMessage = requiredIf.ErrorMessage = input;
var assertThatResult = (ValidationResult) isValid.Invoke(assertThat, new[] {new object(), context});
var requiredIfResult = (ValidationResult) isValid.Invoke(requiredIf, new[] {null, context});
Assert.Equal(assertThatOutput, assertThatResult.ErrorMessage);
Assert.Equal(requiredIfOutput, requiredIfResult.ErrorMessage);
}
public void throw_when_priority_is_not_provided_but_requested_explicitly()
{
var assertThat = new AssertThatAttribute("1!=1");
var requiredIf = new RequiredIfAttribute("1==1");
Assert.Null(assertThat.GetPriority());
Assert.Null(requiredIf.GetPriority());
var e = Assert.Throws<InvalidOperationException>(() => assertThat.Priority);
Assert.Equal("The Priority property has not been set. Use the GetPriority method to get the value.", e.Message);
e = Assert.Throws<InvalidOperationException>(() => requiredIf.Priority);
Assert.Equal("The Priority property has not been set. Use the GetPriority method to get the value.", e.Message);
}
public void throw_when_requirement_is_applied_to_field_of_non_nullable_value_type()
{
var model = new MisusedRequirementModel();
var requirAttribute = new RequiredIfAttribute("true");
var metadata = GetModelMetadata(model, m => m.Value);
var controllerContext = GetControllerContext();
var e = Assert.Throws<ValidationException>(() => new RequiredIfValidator(metadata, controllerContext, requirAttribute));
Assert.Equal(
"RequiredIfValidator: validation applied to Value field failed.",
e.Message);
Assert.IsType<InvalidOperationException>(e.InnerException);
Assert.Equal(
"RequiredIfAttribute has no effect when applied to a field of non-nullable value type 'System.Int32'. Use nullable 'System.Int32?' version instead.",
e.InnerException.Message);
}
public void verify_attributes_identification()
{
var assertThat = new AssertThatAttribute("1 != 1"); // spaces on purpose
var requiredIf = new RequiredIfAttribute("1 == 1");
const string assertThatRepresentation = "ExpressiveAnnotations.Attributes.AssertThatAttribute[1!=1]";
const string requiredIfRepresentation = "ExpressiveAnnotations.Attributes.RequiredIfAttribute[1==1]";
Assert.Equal(assertThatRepresentation, assertThat.TypeId);
Assert.Equal(requiredIfRepresentation, requiredIf.TypeId);
Assert.Equal(assertThatRepresentation, assertThat.ToString());
Assert.Equal(requiredIfRepresentation, requiredIf.ToString());
Assert.Equal(assertThatRepresentation.GetHashCode(), assertThat.GetHashCode());
Assert.Equal(requiredIfRepresentation.GetHashCode(), requiredIf.GetHashCode());
}
