public void Should_HaveEmptyInitialValues()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b);
Assert.Null(validator.SingleError);
Assert.Empty(validator.Scopes);
}
public void Should_AddMemberScope_When_Member()
{
Predicate <string> isValid = c => true;
var args = new[] { Arg.Text("test", "test123") };
MemberSpecification <MemberClass, string> memberSpecification = c => c.Valid(isValid, "message", args);
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Member(m => m.MemberField, memberSpecification)
);
Assert.IsType <MemberScope <MemberClass, string> >(validator.Scopes.Single());
var memberScope = (MemberScope <MemberClass, string>)validator.Scopes.Single();
Assert.Null(memberScope.RuleSingleError);
Assert.Equal("MemberField", memberScope.MemberPropertyInfo.Name);
Assert.Equal(typeof(string), memberScope.MemberPropertyInfo.PropertyType);
Assert.IsType <ValidRule <string> >(memberScope.MemberValidator.Rules.Single());
var memberRule = (ValidRule <string>)memberScope.MemberValidator.Rules.Single();
Assert.Same(isValid, memberRule.IsValid);
Assert.Equal("message", memberRule.Error.Message);
Assert.Same(args, memberRule.Error.Arguments);
Assert.Null(memberRule.RuleSingleError);
}
public void Should_ThrowException_When_SingleError_Added_With_NullMessage()
{
Assert.Throws <ArgumentNullException>(() =>
{
ValidatorCreator.Create <MemberClass>(b => b
.SetSingleError(null));
});
}
public void Should_ThrowException_When_SingleError_Added_MultipleTimes()
{
Assert.Throws <InvalidCommandDuplicationException>(() =>
{
ValidatorCreator.Create <MemberClass>(b => b
.SetSingleError("message1")
.SetSingleError("message2"));
});
}
public void Should_ThrowException_When_Valid_And_NullPredicate()
{
Assert.Throws <ArgumentNullException>(() =>
{
ValidatorCreator.Create <MemberClass>(b => b
.Valid(null)
);
});
}
public void Should_ThrowException_When_WithMessage_AtTheBeginning()
{
Assert.Throws <InvalidCommandOrderException>(() =>
{
ValidatorCreator.Create <MemberClass>(b => b
.WithMessage("message")
);
});
}
public void Should_SetSingleError_BeAdded()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b
.SetSingleError("message")
);
Assert.Equal("message", validator.SingleError.Message);
Assert.Null(validator.SingleError.Arguments);
}
public void Should_ThrowException_When_Member_And_NullMemberSelector()
{
Assert.Throws <ArgumentNullException>(() =>
{
ValidatorCreator.Create <MemberClass>(b => b
.Member <string>(null, c => c)
);
});
}
public void Should_WithMessage_SetRuleSingleError_In_ModelScope()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Valid(x => false)
.WithMessage("message"),
out var commands
);
AssertSingleRuleSet(validator, commands);
}
public void Should_WithMessage_SetRuleSingleError_In_MemberScope()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Member(m => m.MemberField)
.WithMessage("message"),
out var commands
);
AssertSingleRuleSet(validator, commands);
}
public void Should_WithMessage_ApplyLastMessage_When_MultipleInRow()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Member(m => m.MemberField)
.WithMessage("message3")
.WithMessage("message2")
.WithMessage("message1")
.WithMessage("message"),
out var commands
);
AssertSingleRuleSet(validator, commands, 5);
}
public void Should_OutputCommands()
{
ValidatorCreator.Create <MemberClass>(b => b
.Valid(m => true)
.WithMessage("message")
.SetSingleError("single")
.Member(m => m.MemberField)
, out var commands);
Assert.Equal(4, commands.Count);
Assert.IsType <ModelScope <MemberClass> >(commands.ElementAt(0));
Assert.IsType <WithMessageCommand>(commands.ElementAt(1));
Assert.IsType <SetSingleErrorCommand>(commands.ElementAt(2));
Assert.IsType <MemberScope <MemberClass, string> >(commands.ElementAt(3));
}
public void Should_AddModelScope_When_Valid()
{
Predicate <MemberClass> isValid = c => true;
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Valid(isValid)
);
Assert.IsType <ModelScope <MemberClass> >(validator.Scopes.Single());
var modelScope = (ModelScope <MemberClass>)validator.Scopes.Single();
Assert.Same(isValid, modelScope.Rule.IsValid);
Assert.Null(modelScope.RuleSingleError);
Assert.Null(modelScope.Rule.Error);
}
public void Should_AddMemberScope_When_Member_WithoutSpecification()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b
.Member(m => m.MemberField)
);
Assert.IsType <MemberScope <MemberClass, string> >(validator.Scopes.Single());
var memberScope = (MemberScope <MemberClass, string>)validator.Scopes.Single();
Assert.Null(memberScope.RuleSingleError);
Assert.Equal("MemberField", memberScope.MemberPropertyInfo.Name);
Assert.Equal(typeof(string), memberScope.MemberPropertyInfo.PropertyType);
Assert.False(memberScope.MemberValidator.IsOptional);
Assert.Null(memberScope.MemberValidator.RequiredError);
Assert.Empty(memberScope.MemberValidator.Rules);
}
/// <summary>
/// Recupera o criador de validadores.
/// </summary>
/// <param name="validationType">Tipo de validação.</param>
/// <param name="culture"></param>
/// <returns></returns>
private IValidatorCreator GetValidatorCreator(ValidationType validationType, System.Globalization.CultureInfo culture)
{
IValidatorCreator creator = null;
bool found = false;
lock (_validatorCreators)
found = _validatorCreators.TryGetValue(validationType.ValidationTypeId, out creator);
if (!found)
{
System.Reflection.Assembly assembly = null;
if (Reflection.AssemblyLoader.Instance.TryGet(validationType.Type.AssemblyName.Name, out assembly))
{
Type validatorType = null;
try
{
validatorType = assembly.GetType(validationType.Type.FullName, true, false);
}
catch (Exception ex)
{
_logger.Error(ResourceMessageFormatter.Create(() => Properties.Resources.GeneralValidationManager_ValidationTypeGetTypeError, validationType.Type.FullName, validationType.Name, Diagnostics.ExceptionFormatter.FormatException(ex, true)), ex);
}
if (validationType != null)
{
creator = ValidatorCreator.CreateCreator(validatorType, culture);
lock (_validatorCreators)
if (!_validatorCreators.ContainsKey(validationType.ValidationTypeId))
{
_validatorCreators.Add(validationType.ValidationTypeId, creator);
}
}
}
else
{
_logger.Error(ResourceMessageFormatter.Create(() => Properties.Resources.GeneralValidationManager_ValidationTypeAssemblyNotFound, validationType.Type.AssemblyName.Name, validationType.Name));
}
}
return(creator);
}
public void Should_ThrowException_When_ReferenceChanged()
{
Assert.Throws <InvalidProcessedReferenceException>(() => { ValidatorCreator.Create <MemberClass>(b => { return(new SpecificationBuilder <MemberClass>()); }); });
}
public static Validator GetValidator(JsonValidationRule rule)
{
ValidatorCreator creator = (ValidatorCreator)Validators[rule.ValidationType];
return((creator != null) ? creator(rule) : null);
}
public void Should_SetSingleError_NotBeAdded_When_NoMethod()
{
var validator = ValidatorCreator.Create <MemberClass>(b => b);
Assert.Null(validator.SingleError);
}