public ValidityResponse IsValid(Person inputData)
{
StringBuilder responseList = new StringBuilder();
List <bool> resultList = new List <bool>();
if (inputData is null)
{
return(new ValidityResponse(false, "Person is not instantiated"));
}
if (!stringIsNotNullOrEmptyRule.IsValid(inputData.FirstName).Result ||
!stringIsNotNullOrEmptyRule.IsValid(inputData.LastName).Result ||
!stringRepresentsNumberRule.IsValid(inputData.CNP).Result ||
!numberIsInIntervalRule.IsValid(inputData.Age).Result)
{
List <ValidityResponse> results = new List <ValidityResponse>
{
new ValidityResponse(stringIsNotNullOrEmptyRule.IsValid(inputData.FirstName).Result, stringIsNotNullOrEmptyRule.IsValid(inputData.FirstName).Reason),
new ValidityResponse(stringIsNotNullOrEmptyRule.IsValid(inputData.LastName).Result, stringIsNotNullOrEmptyRule.IsValid(inputData.LastName).Reason),
new ValidityResponse(stringRepresentsNumberRule.IsValid(inputData.CNP).Result, stringRepresentsNumberRule.IsValid(inputData.CNP).Reason),
new ValidityResponse(numberIsInIntervalRule.IsValid(inputData.Age).Result, numberIsInIntervalRule.IsValid(inputData.Age).Reason)
};
responseList.AppendLine(results.Where(r => r.Result is false).Select(r => r.Reason).ToString());
return(new ValidityResponse(false, responseList.ToString()));
}
return(new ValidityResponse(true, "Person is valid"));
}
public void IsValidReturnsTrueWhenGivenValidatorReturnsTrue()
{
string stringToValidate = string.Empty;
Expect.Call(_mockedValidator.IsValid(stringToValidate)).Return(true);
_mocks.ReplayAll();
Assert.IsTrue(_inheritedObjectRule.IsValid(stringToValidate));
_mocks.VerifyAll();
}
public void IsValidReturnsTrueWhenGivenValidatorReturnsTrue()
{
const string stringToValidate = "Foo";
Expect.Call(_mockedValidator.IsValid(stringToValidate.Length)).Return(true);
_mocks.ReplayAll();
Assert.IsTrue(_composedObjectRule.IsValid(stringToValidate));
_mocks.VerifyAll();
}
public bool IsPropertyValid(string propertyName, object value)
{
RemoveErrors(propertyName);
switch (propertyName)
{
case "FIO":
validationRule = new ValidateFIORule();
if (!validationRule.IsValid(value))
{
AddError(propertyName, validationRule.ErrorMessage);
return(false);
}
break;
case "Company":
validationRule = new ValidateCompanyRule();
if (!validationRule.IsValid(value))
{
AddError(propertyName, validationRule.ErrorMessage);
return(false);
}
break;
}
return(true);
}
public bool IsPropertyValid(string propertyName, object value)
{
RemoveErrors(propertyName);
switch (propertyName)
{
case "NameProject":
validationRule = new ValidateNameProjectRule();
if (!validationRule.IsValid(value))
{
AddError(propertyName, validationRule.ErrorMessage);
return(false);
}
break;
case "Customer":
validationRule = new ValidateCustomerRule();
if (!validationRule.IsValid(value))
{
AddError(propertyName, validationRule.ErrorMessage);
return(false);
}
break;
}
return(true);
}
public void IsValidReturnsTrueWhenOneRuleExistsAndIsValid()
{
string stringToValidate = string.Empty;
Expect.Call(_mockedValidationRuleFactory.CreateValidationRules()).Return(new List <IValidationRule <string> > {
_mockedValidationRule
});
Expect.Call(_mockedValidationRule.IsValid(stringToValidate)).Return(true);
_mocks.ReplayAll();
InitializeValidator();
bool isValid = _validator.IsValid(stringToValidate);
_mocks.VerifyAll();
Assert.IsTrue(isValid);
}
public void FigureValidation()
{
//Arrange
_validation = new FiguresRule <WineModel>(x => x.Price);
// Act
var result = _validation.IsValid(new WineModel {
ID = 1, Name = "Test", Price = 6.70M, Description = "nothing", RegionId = 1, Sparkling = false
});
// Assert
Assert.IsTrue(result);
}
public void Test_IsValid()
{
MockRepository mocks = new MockRepository();
string test = Guid.NewGuid().ToString();
IValidationRule rule = mocks.StrictMock <IValidationRule>();
Expect.Call(rule.IsValid(test)).Return(true);
mocks.ReplayAll();
Esapi.Validator.AddRule(test, rule);
Assert.ReferenceEquals(Esapi.Validator.GetRule(test), rule);
Assert.IsTrue(Esapi.Validator.IsValid(test, test));
mocks.VerifyAll();
}
public bool IsValid(T objectToValidate)
{
_invalidObjectErrorMessages.Clear();
if (objectToValidate != null)
{
foreach (N item in _collectionToValidate(objectToValidate))
{
if (!_validationRule.IsValid(item))
{
_invalidObjectErrorMessages.Add(_validationRule.GetErrorMessage(item));
}
}
}
else
{
_invalidObjectErrorMessages.Add("The object given to validate was null.");
}
return(_invalidObjectErrorMessages.IsEmpty());
}
public void IsValidReturnsTrueWhenSingleObjectValidatesToTrue()
{
const string stringToValidate = "Foo";
var fake = new FakeObjectToValidate {
ListOfStrings = new List <string> {
stringToValidate
}
};
Expect.Call(_mockedValidationRule.IsValid(stringToValidate)).Return(true);
_mocks.ReplayAll();
bool isValid = _collectionRule.IsValid(fake);
_mocks.VerifyAll();
Assert.IsTrue(isValid, "False returned for object single valid object.");
}
public void IsValidReturnsFalseWhenNullObjectProvided()
{
bool isValid = _collectionRule.IsValid(null);
Assert.IsFalse(isValid, "True returned for null object.");
}
public ExecutionResult ValidateCommand(object commandMessage, ICommandConfiguration commandConfiguration)
{
var totalResult = new ExecutionResult();
IEnumerable <ValidationRuleInstance> ruleInstances = commandConfiguration.GetValidationRules();
foreach (ValidationRuleInstance instance in ruleInstances)
{
if (instance.ShouldApply != null)
{
if (!(bool)instance.ShouldApply.DynamicInvoke(commandMessage))
{
continue;
}
}
Delegate compile = instance.ToCheckExpression.Compile();
object input = compile.DynamicInvoke(new object[] { commandMessage });
bool stopProcessing = false;
if (instance.ArrayRule)
{
var enumerable = (IEnumerable)input;
int i = 0;
foreach (object item in enumerable)
{
if (item == null)
{
continue;
}
IValidationRule rule = _ruleFactory.ConstructRule(instance);
string result = rule.IsValid(item);
bool ruleFailed = result != null;
if (ruleFailed)
{
var indexedUiExpression = new IndexReplacerVisitor(i).Visit(instance.UIAttributeExpression);
totalResult.AddMessage(result, instance.ToCheckExpression, (LambdaExpression)indexedUiExpression, instance.ToCompareExpression);
if (rule.StopProcessing)
{
stopProcessing = true;
break;
}
}
i++;
}
}
else
{
IValidationRule rule = _ruleFactory.ConstructRule(instance);
if (rule is ICrossReferencedValidationRule)
{
Delegate toCompareDelegate = instance.ToCompareExpression.Compile();
object toCompare = toCompareDelegate.DynamicInvoke(new object[] { commandMessage });
((ICrossReferencedValidationRule)rule).ToCompare = toCompare;
}
string result = rule.IsValid(input);
bool ruleFailed = result != null;
if (ruleFailed)
{
totalResult.AddMessage(result, instance.ToCheckExpression, instance.UIAttributeExpression, instance.ToCompareExpression);
if (rule.StopProcessing)
{
break;
}
}
}
if (stopProcessing)
{
break;
}
}
return(totalResult);
}
