static MessageProviderInfo GetMessageProviderInfo(MessageProviderInfo providerInfo, IHasFailureMessageUsageCriteria criteria)
{
var priorityIncrease = (criteria is AllowAllUsageCriteriaProvider) ? 0 : priorityIncreaseForImplementingCriteria;
var newPriority = providerInfo.Priority + priorityIncrease;
return(new LazyMessageProviderInfo(providerInfo, newPriority));
}
/// <summary>
/// Gets the usage criteria from the specified message provider and interface type.
/// </summary>
/// <remarks>
/// <para>
/// This method should never return <see langword="null" />. If the message provider cannot get a
/// suitable implementation of <see cref="IHasFailureMessageUsageCriteria"/> then a matches-all criteria
/// instance should be returned.
/// </para>
/// </remarks>
/// <param name="messageProviderInfo">Message provider info.</param>
/// <param name="ruleInterface">The interface used for the original validation rule.</param>
/// <returns>An instance of <see cref="IHasFailureMessageUsageCriteria"/>.</returns>
public IHasFailureMessageUsageCriteria GetNonGenericMessageCriteria(MessageProviderInfo messageProviderInfo, Type ruleInterface)
{
if (messageProviderInfo is null)
{
throw new ArgumentNullException(nameof(messageProviderInfo));
}
if (ruleInterface is null)
{
throw new ArgumentNullException(nameof(ruleInterface));
}
var ruleInterfaceInfo = ruleInterface.GetTypeInfo();
if (ImplementsDoubleGenericCriteriaInterface(messageProviderInfo.ProviderTypeInfo, ruleInterfaceInfo))
{
var method = getDoubleGenericCriteriaMethod.MakeGenericMethod(ruleInterfaceInfo.GenericTypeArguments[0],
ruleInterfaceInfo.GenericTypeArguments[1]);
return((IHasFailureMessageUsageCriteria)method.Invoke(this, new[] { messageProviderInfo.GetOriginalProvider() }));
}
if (ImplementsSingleGenericCriteriaInterface(messageProviderInfo.ProviderTypeInfo, ruleInterfaceInfo))
{
var method = getSingleGenericCriteriaMethod.MakeGenericMethod(ruleInterfaceInfo.GenericTypeArguments[0]);
return((IHasFailureMessageUsageCriteria)method.Invoke(this, new[] { messageProviderInfo.GetOriginalProvider() }));
}
if (nonGenericCriteriaTypeInfo.IsAssignableFrom(messageProviderInfo.ProviderTypeInfo))
{
return((IHasFailureMessageUsageCriteria)messageProviderInfo.GetOriginalProvider());
}
return(new AllowAllUsageCriteriaProvider());
}
/// <summary>
/// Initialises a new instance of <see cref="LazyMessageProviderInfo"/>.
/// </summary>
/// <param name="copyFrom">Message provider info to copy-from.</param>
/// <param name="priority">A new priority value, replacing that within <paramref name="copyFrom"/>.</param>
public LazyMessageProviderInfo(MessageProviderInfo copyFrom, int priority) : base(copyFrom)
{
this.messageProvider = new Lazy <IGetsFailureMessage>(() => copyFrom.MessageProvider);
Priority = priority;
}
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 }));
}
