public void CallsMethodOnRegisteredValidatorsCorrectly()
{
var compositeValidator = new CompositeValidator();
TestCompositeValidator(compositeValidator, validator => validator.ValidateBusinessRules(null, null),
() => compositeValidator.ValidateBusinessRules(null, null));
}
/// <summary>
/// Creates an instance of <see cref="Data.IValidator" /> from a collection of <see cref="FluentValidation.AbstractValidator{T}" /> types.
/// </summary>
/// <param name="validatorTypes">Collection of <see cref="FluentValidation.IValidator" /> types.</param>
/// <returns>An instance of a class the implements <see cref="Catel.Data.IValidator" />. If the collection contains one element an instance of <see cref="FluentValidatorToCatelValidatorAdapter" /> is returned otherwise
/// a <see cref="CompositeValidator" /> is created in order to aggregate the validators in a single one.</returns>
/// <exception cref="System.ArgumentException">Argument 'validatorTypes' must contains at least one element.</exception>
/// <exception cref="ArgumentNullException">If <paramref name="validatorTypes" /> is <c>null</c>.</exception>
internal static Data.IValidator From(IList <Type> validatorTypes)
{
Argument.IsNotNull("validatorTypes", validatorTypes);
if (validatorTypes.Count == 0)
{
throw new ArgumentException("Argument 'validatorTypes' must contains at least one element.");
}
Data.IValidator validator;
if (validatorTypes.Count > 1)
{
var compositeValidator = new CompositeValidator();
foreach (Type validatorType in validatorTypes)
{
compositeValidator.Add(From(validatorType));
}
validator = compositeValidator;
}
else
{
validator = From(validatorTypes.FirstOrDefault());
}
return(validator);
}
public void CallsMethodOnRegisteredValidatorsCorrectly()
{
var compositeValidator = new CompositeValidator();
TestCompositeValidator(compositeValidator, validator => validator.AfterValidation(null, null, null),
() => compositeValidator.AfterValidation(null, null, null));
}
public void DuplicatesAreEliminated()
{
var compositeValidator = new CompositeValidator(Enumerable.Repeat(JitOptimizationsValidator.DontFailOnError, 3).ToArray());
Assert.Single(
compositeValidator.Validators,
validator => ReferenceEquals(validator, JitOptimizationsValidator.DontFailOnError));
}
public void ValidateCallsOnEachSubInstance()
{
var validator = new CompositeValidator <int>(_validator1.Object, _validator2.Object);
validator.Validate(IntValue);
_validator1.Verify(m => m.Validate(IntValue), Times.Once);
_validator2.Verify(m => m.Validate(IntValue), Times.Once);
}
public void ReturnsFalseForNonExistingValidator()
{
var compositeValidator = new CompositeValidator();
var validatorMock = new Mock <IValidator>();
var validator = validatorMock.Object;
Assert.IsFalse(compositeValidator.Contains(validator));
}
public void AppendsAddsToInternalList()
{
var validator = new CompositeValidator <int>(_validator1.Object);
validator.Append(_validator2.Object);
validator.Validate(IntValue);
_validator1.Verify(m => m.Validate(IntValue), Times.Once);
_validator2.Verify(m => m.Validate(IntValue), Times.Once);
}
/// <inheritdoc />
protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
{
base.DeserializeElement(reader, serializeCollectionKey);
CompositeValidator validator = new CompositeValidator(
new ParameterlessConstructorValidator(),
new PublicConstructorValidator(),
new AssignableFromTypeValidator(typeof(ITaskWorker)));
validator.Validate(this.WorkerType);
}
public void ReturnsTrueForExistingValidator()
{
var compositeValidator = new CompositeValidator();
var validatorMock = new Mock <IValidator>();
var validator = validatorMock.Object;
compositeValidator.Add(validator);
Assert.IsTrue(compositeValidator.Contains(validator));
}
public void ThreatWarningsAsErrorsOverridesDefaultBehaviour()
{
var compositeValidator = new CompositeValidator(
new[]
{
ExecutionValidator.DontFailOnError,
ExecutionValidator.FailOnError
});
Assert.True(compositeValidator.TreatsWarningsAsErrors);
Assert.Contains(ExecutionValidator.FailOnError, compositeValidator.Validators);
Assert.DoesNotContain(ExecutionValidator.DontFailOnError, compositeValidator.Validators);
}
public void Should_invoke_each_validator()
{
// Given
var fakeValidators = A.CollectionOfFake <IModelValidator>(2);
var subject = new CompositeValidator(fakeValidators);
// When
subject.Validate("blah");
// Then
A.CallTo(() => fakeValidators[0].Validate(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => fakeValidators[1].Validate(A <object> .Ignored)).MustHaveHappened();
}
public void Should_invoke_each_validator()
{
// Given
var fakeValidators = A.CollectionOfFake <IModelValidator>(2);
var subject = new CompositeValidator(fakeValidators, typeof(object));
// When
subject.Validate("blah", new NancyContext());
// Then
A.CallTo(() => fakeValidators[0].Validate(A <object> ._, A <NancyContext> ._)).MustHaveHappened();
A.CallTo(() => fakeValidators[1].Validate(A <object> ._, A <NancyContext> ._)).MustHaveHappened();
}
public void DoesNotRemoveNonExistingValidator()
{
var compositeValidator = new CompositeValidator();
var validatorMock = new Mock <IValidator>();
var validator = validatorMock.Object;
Assert.IsFalse(compositeValidator.Contains(validator));
compositeValidator.Remove(validator);
Assert.IsFalse(compositeValidator.Contains(validator));
}
public void CombineWithCompositeAppends()
{
var v1Mock = new Mock <IValidator <int> >();
var v2Mock = new Mock <IValidator <int> >();
v1Mock.Setup(m => m.Validate(0)).Returns(true).Verifiable();
v2Mock.Setup(m => m.Validate(0)).Returns(true).Verifiable();
var composite = new CompositeValidator <int>(v1Mock.Object);
Validator.Combine(composite, v2Mock.Object);
composite.Validate(0);
v1Mock.Verify(m => m.Validate(0), Times.Once);
v2Mock.Verify(m => m.Validate(0), Times.Once);
}
/// <summary>
/// Gets the proper validator.
/// </summary>
/// <returns>Validator.</returns>
public override Validator GetValidator()
{
var validator =
new Validator <RollbarLoggerConfig, RollbarLoggerConfig.RollbarLoggerConfigValidationRule>()
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.DestinationOptionsRequired,
(config) => { return(this.RollbarDestinationOptions != null); }
)
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.HttpProxyOptionsRequred,
(config) => { return(this.HttpProxyOptions != null); }
)
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.DeveloperOptionsRequired,
(config) => { return(this.RollbarDeveloperOptions != null); }
)
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.DataSecurityOptionsRequired,
(config) => { return(this.RollbarDataSecurityOptions != null); }
)
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.PayloadAdditionOptionsRequired,
(config) => { return(this.RollbarPayloadAdditionOptions != null); }
)
.AddValidation(
RollbarLoggerConfig.RollbarLoggerConfigValidationRule.PayloadManipulationOptionsRequired,
(config) => { return(this.RollbarPayloadManipulationOptions != null); }
)
;
IValidatable[] validatableComponents =
{
this._rollbarDestinationOptions,
this._httpProxyOptions,
this._rollbarDeveloperOptions,
this._rollbarDataSecurityOptions,
this._rollbarPayloadAdditionOptions,
this._rollbarPayloadManipulationOptions,
};
Debug.Assert(validator.TotalValidationRules == (new HashSet <IValidatable>(validatableComponents)).Count);
CompositeValidator compositeValidator =
new CompositeValidator(
new Validator[] { validator },
validatableComponents
);
return(compositeValidator);
}
public void Should_yield_composite_description()
{
// Given
var fakeValidators = A.CollectionOfFake <IModelValidator>(2);
A.CallTo(() => fakeValidators[0].Description).Returns(new ModelValidationDescriptor(new[] { new ModelValidationRule("Test1", s => s, new[] { "Member1" }) }, typeof(object)));
A.CallTo(() => fakeValidators[1].Description).Returns(new ModelValidationDescriptor(new[] { new ModelValidationRule("Test2", s => s, new[] { "Member2" }) }, typeof(object)));
var subject = new CompositeValidator(fakeValidators, typeof(object));
// When
var result = subject.Description;
// Then
result.Rules.ShouldHaveCount(2);
result.Rules.First().Value.ShouldHave(r => r.RuleType == "Test1" && r.MemberNames.Contains("Member1"));
result.Rules.Last().Value.ShouldHave(r => r.RuleType == "Test2" && r.MemberNames.Contains("Member2"));
}
public void PreventsAddingDuplicateValidator()
{
var compositeValidator = new CompositeValidator();
var validatorMock = new Mock <IValidator>();
var validator = validatorMock.Object;
compositeValidator.Add(validator);
Assert.IsTrue(compositeValidator.Contains(validator));
compositeValidator.Add(validator);
Assert.IsTrue(compositeValidator.Contains(validator));
compositeValidator.Remove(validator);
Assert.IsFalse(compositeValidator.Contains(validator));
}
/// <summary>
/// Creates a composite validator with 2 validators and checks whether the method are called.
/// </summary>
/// <param name="compositeValidator">The composite validator.</param>
/// <param name="expression">The expression.</param>
/// <param name="actionToExecute">The action to execute.</param>
private static void TestCompositeValidator(CompositeValidator compositeValidator, Expression <Action <IValidator> > expression, Action actionToExecute)
{
var validator1Mock = new Mock <IValidator>();
validator1Mock.Setup(expression);
var validator1 = validator1Mock.Object;
var validator2Mock = new Mock <IValidator>();
validator2Mock.Setup(expression);
var validator2 = validator2Mock.Object;
compositeValidator.Add(validator1);
compositeValidator.Add(validator2);
actionToExecute();
validator1Mock.Verify(expression, Times.Once());
validator2Mock.Verify(expression, Times.Once());
}
private static void TestCompositeRethrowException <TException>(CompositeValidator compositeValidator, Expression <Action <IValidator> > expression, Action actionToExecute) where TException : Exception, new()
{
var validator1Mock = new Mock <IValidator>();
validator1Mock.Setup(expression);
var validator1 = validator1Mock.Object;
var validator2Mock = new Mock <IValidator>();
validator2Mock.Setup(expression).Throws(new TException());
var validator2 = validator2Mock.Object;
compositeValidator.Add(validator1);
compositeValidator.Add(validator2);
ExceptionTester.CallMethodAndExpectException <TException>(actionToExecute);
validator1Mock.Verify(expression, Times.Once());
validator2Mock.Verify(expression, Times.Once());
}
/// <summary>
/// Gets the proper validator.
/// </summary>
/// <returns>Validator.</returns>
public override Validator GetValidator()
{
var validator =
new Validator <RollbarInfrastructureConfig, RollbarInfrastructureConfig.RollbarInfrastructureConfigValidationRule>()
.AddValidation(
RollbarInfrastructureConfig.RollbarInfrastructureConfigValidationRule.LoggerConfigRequired,
(config) => { return(this.RollbarLoggerConfig != null); }
)
.AddValidation(
RollbarInfrastructureConfig.RollbarInfrastructureConfigValidationRule.InfrastructureOptionsRequred,
(config) => { return(this.RollbarInfrastructureOptions != null); }
)
.AddValidation(
RollbarInfrastructureConfig.RollbarInfrastructureConfigValidationRule.TelemetryOptionsRequired,
(config) => { return(this.RollbarTelemetryOptions != null); }
)
.AddValidation(
RollbarInfrastructureConfig.RollbarInfrastructureConfigValidationRule.OfflineStoreOptionsRequired,
(config) => { return(this.RollbarOfflineStoreOptions != null); }
)
;
IValidatable[] validatableComponents =
{
this._rollbarLoggerConfig,
this._rollbarInfrastructureOptions,
this._rollbarTelemetryOptions,
this._rollbarOfflineStoreOptions,
};
Debug.Assert(validator.TotalValidationRules == (new HashSet <IValidatable>(validatableComponents)).Count);
CompositeValidator compositeValidator =
new CompositeValidator(
new Validator[] { validator },
validatableComponents
);
return(compositeValidator);
}
public CollectionValidationBuilder(CompositeValidator compositeValidator)
{
_compositeValidator = compositeValidator;
}
public void ThrowsExceptionIfAnyValidatorDoes()
{
var compositeValidator = new CompositeValidator();
TestCompositeRethrowException <ArgumentNullException>(compositeValidator, validator => validator.AfterValidation(null, null, null), () => compositeValidator.AfterValidation(null, null, null));
}
public void CompositeValidatorModificationMustWaitUntilTheEnd()
{
var validatorMock = new Mock <IValidator>();
var validatorMock1 = new Mock <IValidator>();
var validatorMock2 = new Mock <IValidator>();
validatorMock.Setup(validator => validator.BeforeValidation(null, null, null));
validatorMock.Setup(validator => validator.AfterValidation(null, null, null));
validatorMock1.Setup(validator => validator.BeforeValidation(null, null, null));
validatorMock1.Setup(validator => validator.AfterValidation(null, null, null));
validatorMock2.Setup(validator => validator.BeforeValidation(null, null, null));
validatorMock2.Setup(validator => validator.AfterValidation(null, null, null));
var compositeValidator = new CompositeValidator();
var startEvent = new AutoResetEvent(false);
var alterEvent = new AutoResetEvent(false);
var syncEvents = new[] { new AutoResetEvent(false), new AutoResetEvent(false) };
// Validation loop thread
ThreadPool.QueueUserWorkItem(
delegate
{
startEvent.WaitOne();
compositeValidator.BeforeValidation(null, null, null);
alterEvent.Set();
ThreadHelper.Sleep(1000);
compositeValidator.AfterValidation(null, null, null);
syncEvents[0].Set();
});
// Alter validator composition thread.
ThreadPool.QueueUserWorkItem(
delegate
{
compositeValidator.Add(validatorMock.Object);
compositeValidator.Add(validatorMock1.Object);
startEvent.Set();
alterEvent.WaitOne();
// Try add a validator during a validation loop execution to the composition.
compositeValidator.Add(validatorMock2.Object);
syncEvents[1].Set();
});
syncEvents[0].WaitOne(TimeSpan.FromSeconds(10));
syncEvents[1].WaitOne(TimeSpan.FromSeconds(10));
validatorMock.Verify(validator => validator.BeforeValidation(null, null, null), Times.Exactly(1));
validatorMock.Verify(validator => validator.AfterValidation(null, null, null), Times.Exactly(1));
validatorMock1.Verify(validator => validator.BeforeValidation(null, null, null), Times.Exactly(1));
validatorMock1.Verify(validator => validator.AfterValidation(null, null, null), Times.Exactly(1));
validatorMock2.Verify(validator => validator.BeforeValidation(null, null, null), Times.Never());
validatorMock2.Verify(validator => validator.AfterValidation(null, null, null), Times.Never());
}
public void ThrowsExceptionIfAnyValidatorDoes()
{
var compositeValidator = new CompositeValidator();
TestCompositeRethrowException <ArgumentNullException>(compositeValidator, validator => validator.BeforeValidateBusinessRules(null, null), () => compositeValidator.BeforeValidateBusinessRules(null, null));
}
public void BaseLineValidatorIsMandatory()
{
var compositeValidator = new CompositeValidator(new IValidator[0]);
Assert.Contains(BaselineValidator.FailOnError, compositeValidator.Validators);
}
public void BaseLineValidatorIsMandatory()
{
var compositeValidator = new CompositeValidator(Array.Empty <IValidator>());
Assert.Contains(BaselineValidator.FailOnError, compositeValidator.Validators);
}
public void ThrowsArgumentNullExceptionForNullValidator()
{
var compositeValidator = new CompositeValidator();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => compositeValidator.Contains(null));
}
public ObjectValidationBuilder(CompositeValidator compositeValidator)
{
_compositeValidator = compositeValidator;
}
