/// <summary>
/// Registers the check for null reference:
/// <list type="bullet">
/// <item>
/// <description>
/// If source is <c>null</c>, then destination must also be <c>null</c>.
/// </description>
/// </item>
/// <item>
/// <description>
/// If source is NOT <c>null</c>, then destination must also be NOT <c>null</c>.
/// </description>
/// </item>
/// </list>
/// </summary>
/// <returns>
/// This <see cref="MappingAccordances{TSource,TDestination}"/> instance.
/// </returns>
/// <remarks>
/// In case when the null reference check is registered, if both source and destinaton
/// passed to <see cref="AssertAll(TSource,TDestination)"/> are <c>null</c>, then
/// assertions for all the registered mappings are skipped and the
/// <see cref="AssertAll(TSource,TDestination)"/> call is deemed successful.
/// </remarks>
public MappingAccordances <TSource, TDestination> RegisterNullReferenceCheck()
{
if (_nullReferenceAssertion == null)
{
_nullReferenceAssertion =
(source, destination) =>
{
var isSourceNull = MappingAccordances.IsNullReference(source);
var isDestinationNull = MappingAccordances.IsNullReference(destination);
Assert.That(
isDestinationNull,
Is.EqualTo(isSourceNull),
MappingAccordances.NullMismatchMessage);
return(isSourceNull && isDestinationNull);
};
}
return(this);
}
public MappingAccordances <TSource, TDestination> Register <TSourceItem, TDestinationItem>(
[NotNull] Expression <Func <TSource, IList <TSourceItem> > > sourcePropertySelectorExpression,
[NotNull] Expression <Func <TDestination, IList <TDestinationItem> > > destinationPropertySelectorExpression,
[NotNull] MappingAccordances <TSourceItem, TDestinationItem> innerMappingAccordances)
{
Assert.That(sourcePropertySelectorExpression, Is.Not.Null);
Assert.That(destinationPropertySelectorExpression, Is.Not.Null);
Assert.That(innerMappingAccordances, Is.Not.Null);
var sourcePropertySelector = sourcePropertySelectorExpression.Compile();
var destinationPropertySelector = destinationPropertySelectorExpression.Compile();
var sourceExpression = MappingAccordances.ToReadableString(sourcePropertySelectorExpression);
var destinationExpression = MappingAccordances.ToReadableString(destinationPropertySelectorExpression);
_assertions.Add(
(source, destination, parentFailureMessage) =>
{
var sourcePropertyValue = sourcePropertySelector(source);
var destinationPropertyValue = destinationPropertySelector(destination);
var isSourcePropertyValueNull = MappingAccordances.IsNullReference(sourcePropertyValue);
var isDestinationPropertyValueNull = MappingAccordances.IsNullReference(destinationPropertyValue);
var nullMismatchMessage = MappingAccordances.CreateDetailedFailureMessage(
MappingAccordances.ListValueNullMismatchMessage,
sourceExpression,
destinationExpression,
parentFailureMessage);
Assert.That(
isDestinationPropertyValueNull,
Is.EqualTo(isSourcePropertyValueNull),
nullMismatchMessage);
if (isSourcePropertyValueNull && isDestinationPropertyValueNull)
{
return;
}
var itemCount = destinationPropertyValue.Count;
var countMismatchMessage = MappingAccordances.CreateDetailedFailureMessage(
MappingAccordances.ListValueCountMismatchMessage,
sourceExpression,
destinationExpression,
parentFailureMessage);
Assert.That(itemCount, Is.EqualTo(sourcePropertyValue.Count), countMismatchMessage);
for (var index = 0; index < itemCount; index++)
{
var sourceItem = sourcePropertyValue[index];
var destinationItem = destinationPropertyValue[index];
var itemMismatchMessage = MappingAccordances.CreateDetailedFailureMessage(
$@"The source and destination must have the matching item at index {index}",
sourceExpression,
destinationExpression,
parentFailureMessage);
innerMappingAccordances.AssertAllInternal(sourceItem, destinationItem, itemMismatchMessage);
}
});
return(this);
}