public void AlterCpf(string cpf)
{
ValidatorRule.New()
.With(string.IsNullOrEmpty(cpf) || !Validators.IsCpf(cpf), Resource.CpfInvalid)
.ThrowExceptionIfExist();
Cpf = cpf;
}
public void AlterEmail(string email)
{
ValidatorRule.New()
.With(string.IsNullOrEmpty(email) || !Validators.IsEmail(email), Resource.EmailInvalid)
.ThrowExceptionIfExist();
Email = email;
}
public void AlterName(string name)
{
ValidatorRule.New()
.With(string.IsNullOrEmpty(name), Resource.NameInvalid)
.ThrowExceptionIfExist();
Name = name;
}
public PersonModel(string name, string cpf, string email)
{
ValidatorRule.New()
.With(string.IsNullOrEmpty(name), Resource.NameInvalid)
.With(string.IsNullOrEmpty(cpf) || !Validators.IsCpf(cpf), Resource.CpfInvalid)
.With(string.IsNullOrEmpty(email) || !Validators.IsEmail(email), Resource.EmailInvalid)
.ThrowExceptionIfExist();
Name = name;
Cpf = cpf;
Email = email;
}
public void Should_validate_against_validator()
{
var validator = CreateMock<IValidator<Person, string>>();
var person = new Person {Name = "Bob"};
var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name);
validator.Expect(v => v.Validate(person, "Bob")).Return(true);
rule.Validate(person);
VerifyAll();
}
public void Should_return_valid_result_if_validator_returned_valid()
{
var validator = CreateMock<IValidator<Person, string>>();
var person = new Person { Name = "Bob" };
var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name);
validator.Stub(v => v.Validate(person, "Bob")).Return(true);
var result = rule.Validate(person);
Assert.That(result.IsValid, Is.True);
}
public async Task InsertAsync(PersonViewModel personViewModel)
{
var personWithSameCpf = await _personRepository.GetbyCpfAsync(personViewModel.Cpf);
ValidatorRule.New()
.With(personWithSameCpf != null, Resource.CpfExist)
.ThrowExceptionIfExist();
var person = new PersonModel(personViewModel.Name, personViewModel.Cpf, personViewModel.Email);
await _personRepository.InsertAsync(person);
}
public ValidatorNode(RuleBuilder <TInstance> builder, Func <TInstance, TValue> valueFunction, string propertyKey, string propertyName, IValidator <TInstance, TValue> validator)
{
this.builder = builder;
this.valueFunction = valueFunction;
this.propertyKey = propertyKey;
this.propertyName = propertyName;
Validator = validator;
Rule = new ValidatorRule <TInstance, TValue>(propertyKey, propertyName, validator, valueFunction);
builder.AddRule(Rule);
}
public void Should_return_invalid_result_with_broken_rule_if_validator_returned_invalid()
{
var validator = CreateMock<IValidator<Person, string>>();
var person = new Person { Name = "Bob" };
var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name) { Message = "Invalid name" };
validator.Stub(v => v.Validate(person, "Bob")).Return(false);
var result = rule.Validate(person);
Assert.That(result.IsValid, Is.False);
Assert.That(result.BrokenRules[0].Message, Is.EqualTo("Invalid name"));
}
public void Should_return_valid_result_if_validator_returned_valid()
{
var validator = CreateMock <IValidator <Person, string> >();
var person = new Person {
Name = "Bob"
};
var rule = new ValidatorRule <Person, string>("", "", validator, p => p.Name);
validator.Stub(v => v.Validate(person, "Bob")).Return(true);
var result = rule.Validate(person);
Assert.That(result.IsValid, Is.True);
}
public void Should_validate_against_validator()
{
var validator = CreateMock <IValidator <Person, string> >();
var person = new Person {
Name = "Bob"
};
var rule = new ValidatorRule <Person, string>("", "", validator, p => p.Name);
validator.Expect(v => v.Validate(person, "Bob")).Return(true);
rule.Validate(person);
VerifyAll();
}
public void Should_return_invalid_result_with_broken_rule_if_validator_returned_invalid()
{
var validator = CreateMock <IValidator <Person, string> >();
var person = new Person {
Name = "Bob"
};
var rule = new ValidatorRule <Person, string>("", "", validator, p => p.Name)
{
Message = "Invalid name"
};
validator.Stub(v => v.Validate(person, "Bob")).Return(false);
var result = rule.Validate(person);
Assert.That(result.IsValid, Is.False);
Assert.That(result.BrokenRules[0].Message, Is.EqualTo("Invalid name"));
}
private static void FindValidPasswords(ValidatorRule ruleType)
{
Func <string, bool> validatorRule = null;
switch (ruleType)
{
case ValidatorRule.ORIGINAL:
validatorRule = PasswordValidator.ValidateOriginalRule;
break;
case ValidatorRule.POSITIONAL:
validatorRule = PasswordValidator.ValidatePositionalRule;
break;
default:
throw new ArgumentException("Validator rule not supported");
}
;
var passwords = DataSeed.GetData();
var validCount = 0;
foreach (var password in passwords)
{
var valid = validatorRule(password);
if (valid)
{
validCount++;
}
Console.WriteLine($"{password} => {valid}");
}
Console.WriteLine($"\nTotal passwords: {passwords.Count()}");
Console.WriteLine($"Total valid passwords: {validCount}");
}
