public void GetFailureMessageAsyncShouldCallWrappedServiceWithOneGenericType([Frozen] IGetsFailureMessage <string> wrapped,
FailureMessageProviderAdapter <string> sut,
[RuleResult] RuleResult ruleResult,
[ManifestModel] ManifestRule rule,
Type ruleInterface,
RuleIdentifier id,
string actualValue,
string expectedResult,
IValidationLogic validationLogic)
{
var context = new RuleContext(rule, id, actualValue, Enumerable.Empty <ValueContext>(), ruleInterface);
var validationRuleResult = new ValidationRuleResult(ruleResult, context, validationLogic);
Mock.Get(wrapped).Setup(x => x.GetFailureMessageAsync(actualValue, validationRuleResult, default)).Returns(Task.FromResult(expectedResult));
Assert.That(async() => await sut.GetFailureMessageAsync(validationRuleResult), Is.EqualTo(expectedResult));
}
/// <summary>
/// Initialises a new instance of <see cref="InstanceMessageProviderInfo"/>.
/// </summary>
/// <param name="copyFrom">Type info from which to copy.</param>
/// <param name="messageProvider">The message provider instance.</param>
/// <exception cref="System.ArgumentNullException">If any parameter is <see langword="null" />.</exception>
public InstanceMessageProviderInfo(MessageProviderTypeInfo copyFrom, IGetsFailureMessage messageProvider) : base(copyFrom)
{
MessageProvider = messageProvider ?? throw new System.ArgumentNullException(nameof(messageProvider));
}
/// <summary>
/// Initialises a new instance of <see cref="FailureMessageProviderAdapter{TValidated}"/>.
/// </summary>
/// <param name="wrapped">The wrapped service.</param>
/// <exception cref="System.ArgumentNullException">If <paramref name="wrapped"/> is <see langword="null" />.</exception>
public FailureMessageProviderAdapter(IGetsFailureMessage <TValidated> wrapped)
{
this.wrapped = wrapped ?? throw new System.ArgumentNullException(nameof(wrapped));
}
public void GetMessageProviderInfoShouldExcludeProviderInfosWhereTheProviderIsNull([Frozen] IGetsMessageProviderInfo wrapped,
NullExcludingMessageProviderInfoDecorator sut,
MessageProviderInfo provider1,
MessageProviderInfo provider2,
MessageProviderInfo provider3,
IGetsFailureMessage providerService,
[RuleResult] ValidationRuleResult ruleResult)
{
Mock.Get(provider1).SetupGet(x => x.MessageProvider).Returns(providerService);
Mock.Get(provider2).SetupGet(x => x.MessageProvider).Returns(() => null);
Mock.Get(provider3).SetupGet(x => x.MessageProvider).Returns(providerService);
Mock.Get(wrapped).Setup(x => x.GetMessageProviderInfo(ruleResult)).Returns(() => new[] { provider1, provider2, provider3 });
Assert.That(() => sut.GetMessageProviderInfo(ruleResult), Is.EquivalentTo(new[] { provider1, provider3 }));
}
public void GetNonGenericFailureMessageProviderShouldReturnTheProviderFromAServiceProvider([AutofixtureServices] IServiceProvider serviceProvider,
[Frozen] IGetsFailureMessage provider,
NonGenericMessageProviderStrategy sut,
Type ruleInterface)
{
Assert.That(() => sut.GetNonGenericFailureMessageProvider(new MessageProviderTypeInfo(typeof(IGetsFailureMessage), default), ruleInterface), Is.SameAs(provider));
}
public TestingMessageProviderInfo(IGetsFailureMessage messageProvider, int priority = default)
: base(new MessageProviderTypeInfo(messageProvider.GetType(), priority))
{
MessageProvider = messageProvider ?? throw new System.ArgumentNullException(nameof(messageProvider));
}
public void GetNonGenericFailureMessageProviderShouldCreateTheProviderFromAServiceProviderAndWrapIt([AutofixtureServices] IServiceProvider serviceProvider,
[Frozen] IGetsFailureMessage <string, int> wrapped,
DoubleGenericMessageProviderStrategy sut,
[RuleResult(ValidatedValue = "Foo", ParentValue = 5)] ValidationRuleResult ruleResult)
{
var result = sut.GetNonGenericFailureMessageProvider(new MessageProviderTypeInfo(typeof(IGetsFailureMessage <string, int>), default), typeof(IRule <string, int>));
result.GetFailureMessageAsync(ruleResult);
Mock.Get(wrapped).Verify(x => x.GetFailureMessageAsync("Foo", 5, ruleResult, default), Times.Once);
}
public void GetResultWithMessagesAsyncShouldNotAddMessagesToPassOrFailedDependencyResults([Frozen] IGetsFailureMessageProvider messageProviderFactory,
FailureMessageValidationResultPopulator sut,
[RuleResult(Outcome = RuleOutcome.Passed)] ValidationRuleResult ruleResult1,
[RuleResult] ValidationRuleResult ruleResult2,
[RuleResult(Outcome = RuleOutcome.DependencyFailed)] ValidationRuleResult ruleResult3,
IGetsFailureMessage messageProvider1,
IGetsFailureMessage messageProvider3,
string message1,
string message3)
{
var validationResult = new ValidationResult <object>(new[] { ruleResult1, ruleResult2, ruleResult3 }, new Manifest.ValidationManifest {
ValidatedType = typeof(object)
});
Mock.Get(messageProviderFactory).Setup(x => x.GetProvider(ruleResult1)).Returns(messageProvider1);
Mock.Get(messageProviderFactory).Setup(x => x.GetProvider(ruleResult2)).Returns(() => null);
Mock.Get(messageProviderFactory).Setup(x => x.GetProvider(ruleResult3)).Returns(messageProvider3);
Mock.Get(messageProvider1)
.Setup(x => x.GetFailureMessageAsync(ruleResult1, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(message1));
Mock.Get(messageProvider3)
.Setup(x => x.GetFailureMessageAsync(ruleResult3, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(message3));
Assert.That(async() => (await sut.GetResultWithMessagesAsync(validationResult, default)).RuleResults.Select(x => x.Message),
Is.EquivalentTo(new string[] { null, null, null }));
}
public async Task GetResultWithMessagesAsyncShouldCopyAllOtherPropertiesOfARuleResultWhenAddingAMessage([Frozen] IGetsFailureMessageProvider messageProviderFactory,
FailureMessageValidationResultPopulator sut,
[RuleResult] ValidationRuleResult ruleResult,
IGetsFailureMessage messageProvider,
string message)
{
var validationResult = new ValidationResult <object>(new[] { ruleResult }, new Manifest.ValidationManifest {
ValidatedType = typeof(object)
});
Mock.Get(messageProviderFactory).Setup(x => x.GetProvider(ruleResult)).Returns(messageProvider);
Mock.Get(messageProvider)
.Setup(x => x.GetFailureMessageAsync(ruleResult, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(message));
var results = await sut.GetResultWithMessagesAsync(validationResult);
var firstResult = results.RuleResults.First();
Assert.Multiple(() =>
{
Assert.That(firstResult.Exception, Is.EqualTo(ruleResult.Exception), $"{nameof(ValidationRuleResult.Exception)} should have been copied");
Assert.That(firstResult.Identifier, Is.EqualTo(ruleResult.Identifier), $"{nameof(ValidationRuleResult.Identifier)} should have been copied");
Assert.That(firstResult.IsPass, Is.EqualTo(ruleResult.IsPass), $"{nameof(ValidationRuleResult.IsPass)} should have been copied");
Assert.That(firstResult.Outcome, Is.EqualTo(ruleResult.Outcome), $"{nameof(ValidationRuleResult.Outcome)} should have been copied");
Assert.That(firstResult.RuleContext, Is.EqualTo(ruleResult.RuleContext), $"{nameof(ValidationRuleResult.RuleContext)} should have been copied");
Assert.That(firstResult.RuleInterface, Is.EqualTo(ruleResult.RuleInterface), $"{nameof(ValidationRuleResult.RuleInterface)} should have been copied");
Assert.That(firstResult.ValidatedValue, Is.EqualTo(ruleResult.ValidatedValue), $"{nameof(ValidationRuleResult.ValidatedValue)} should have been copied");
Assert.That(firstResult.ValidationLogic, Is.EqualTo(ruleResult.ValidationLogic), $"{nameof(ValidationRuleResult.ValidationLogic)} should have been copied");
});
}
public void GetMessageProviderInfoShouldCreateProviderUsingLazyResolutionFromTheFactory([Frozen] IGetsCandidateMessageTypes typeRegistry,
[Frozen] IGetsMessageProviderFactoryStrategy factoryStrategySelector,
MessageProviderInfoFactory sut,
int irrelevantPriority,
[RuleResult] ValidationRuleResult ruleResult,
IGetsNonGenericMessageProvider factory,
IGetsFailureMessage provider)
{
MessageProviderTypeInfo
type = new MessageProviderTypeInfo(typeof(string), irrelevantPriority);
Mock.Get(typeRegistry).Setup(x => x.GetCandidateMessageProviderTypes(ruleResult)).Returns(new[] { type });
Mock.Get(factoryStrategySelector).Setup(x => x.GetMessageProviderFactory(type, ruleResult.RuleInterface)).Returns(factory);
Mock.Get(factory).Setup(x => x.GetNonGenericFailureMessageProvider(type, ruleResult.RuleInterface)).Returns(provider);
var result = sut.GetMessageProviderInfo(ruleResult);
Assert.Multiple(() =>
{
Mock.Get(factory).Verify(x => x.GetNonGenericFailureMessageProvider(type, It.IsAny <Type>()),
Times.Never,
"Because the provider hasn't been accessed, the factory should not have yet been used");
Assert.That(result.Single().MessageProvider,
Is.SameAs(provider),
"The returned message provider is the same as the expected one.");
Mock.Get(factory).Verify(x => x.GetNonGenericFailureMessageProvider(type, ruleResult.RuleInterface),
Times.Once,
"Now that the provider has been accessed, the factory should have been executed");
});
}
