public void When_No_From_Definition_Then_Invalid()
{
// Arrange
var memberInfo = typeof(SimpleTo).GetMember("StringProp").Single();
var mapper = new Mapper();
var sut = new Binding(memberInfo, BindingType.Explicit, mapper);
// Act
var res = BindingValidator.Validate(sut, new Mapper());
// Assert
Assert.AreEqual("Binding definition does not define a 'from' source.", res[0].Reason);
}
public void When_Bound_From_Definition_Then_Valid()
{
// Arrange
var memberInfo = typeof(SimpleTo).GetMember("StringProp").Single();
var mapper = new Mapper();
var sut = new Binding(memberInfo, BindingType.Explicit, mapper);
sut.FromDefinition = new FromMemberDefinition("StringProp", typeof(string),
ReflectionHelpers.CreateSafeWeakMemberChainGetter(new[] {memberInfo}));
// Act
var res = BindingValidator.Validate(sut, new Mapper());
// Assert
Assert.AreEqual(0, res.Count);
}
public void When_Explicit_From_Definition_Then_Valid()
{
// Arrange
var memberInfo = typeof(SimpleTo).GetMember("StringProp").Single();
var mapper = new Mapper();
var sut = new Binding(memberInfo, BindingType.Explicit, mapper)
{
FromDefinition = new FromCustomDefinition(context => "Wow", typeof(string))
};
// Act
var res = BindingValidator.Validate(sut, new Mapper());
// Assert
Assert.AreEqual(0, res.Count);
}
public static ReadOnlyCollection<MemberDefinitionError> Validate(Binding definition, Mapper mapper)
{
var memberDefinitionErrors = new List<MemberDefinitionError>();
if (definition.IsIgnore)
return new ReadOnlyCollection<MemberDefinitionError>(memberDefinitionErrors);
if (definition.FromDefinition == FromUndefinedDefinition.Default)
memberDefinitionErrors.Add(MemberDefinitionError.Create(definition.ToDefinition, "Binding definition does not define a 'from' source."));
// if (definition.FromDefinition != null && definition.ConvertUsing == null)
// {
// var fromMemberType = definition.FromDefinition.MemberType;
// var toMemberType = definition.toToMemberDefinition.MemberType;
//
// if (!mapper.HasProjection(fromMemberType, toMemberType))
// {
// memberDefinitionErrors.Add(
// MemberDefinitionError.Create(definition.toToMemberDefinition, "Mapped from '{0}' but no {1} defined between '{2}'->'{3}'.",
// definition.FromDefinition.memberPath,
// toMemberType.IsClass ? "ClassMap" : "conversion",
// fromMemberType.Name, toMemberType.Name));
// }
// }
//
// if (definition.FromDefinition != null && definition.ConvertUsing != null)
// {
// // TODO validate conversion or make it so instantiation implies validity.
//
// if (definition.toToMemberDefinition.MemberType != definition.ConvertUsing.ProjectionType.ToType)
// memberDefinitionErrors.Add(MemberDefinitionError.Create(definition.toToMemberDefinition,
// "To member type {0} does not match the defined conversion output type ({1})", definition.FromDefinition.MemberType,
// definition.ConvertUsing));
//
// if (definition.FromDefinition.MemberType != definition.ConvertUsing.ProjectionType.FromType)
// memberDefinitionErrors.Add(MemberDefinitionError.Create(definition.toToMemberDefinition,
// "From member type {0} does not match the defined conversion input type ({1})", definition.FromDefinition.MemberType,
// definition.ConvertUsing));
// }
return new ReadOnlyCollection<MemberDefinitionError>(memberDefinitionErrors);
}
private Tuple<ReadOnlyCollection<Binding>, ReadOnlyCollection<MemberDefinitionError>> GenerateAutoMemberBindings(
IEnumerable<Binding> excludedBindings)
{
var autoMemberBindings = new List<Binding>();
var memberDefinitionErrors = new List<MemberDefinitionError>();
// Discover which 'to' class members do not already have definitions, so that they may be automapped.
var undefinedToMemberInfos = ReflectionHelpers.GetMemberInfos(ProjectionType.ToType)
.Where(m => excludedBindings.All(b => b.ToDefinition.MemberName != m.Name));
// Iterate these the undefined members and try to automatically create matches from inspecting members on the 'from' class.
foreach (var toMemberInfo in undefinedToMemberInfos)
{
var unflattenedMemberInfos = ExpressionHelpers.UnflattenMemberNamesToMemberInfos(ProjectionType.FromType, toMemberInfo.Name);
if (unflattenedMemberInfos.Any())
{
var fromMemberType = unflattenedMemberInfos.Last().GetMemberType();
var fromMemberPath = String.Join(".", unflattenedMemberInfos.GetMemberNames());
var fromMemberGetter = ReflectionHelpers.CreateSafeWeakMemberChainGetter(unflattenedMemberInfos);
var memberGetterDefinition = new FromMemberDefinition(fromMemberPath, fromMemberType, fromMemberGetter);
var memberBindingDefinition = new Binding(toMemberInfo, BindingType.Auto, Mapper)
{
FromDefinition = memberGetterDefinition
};
autoMemberBindings.Add(memberBindingDefinition);
}
else
{
memberDefinitionErrors.Add(MemberDefinitionError.Create(toMemberInfo, "No binding defined and unable to auto-match."));
}
}
return Tuple.Create(new ReadOnlyCollection<Binding>(autoMemberBindings),
new ReadOnlyCollection<MemberDefinitionError>(memberDefinitionErrors));
}
public Binding GetMemberBindingDefinition(MemberInfo toMemberInfo)
{
Binding binding;
if (!explicitBindings.TryGetValue(toMemberInfo.Name, out binding))
{
binding = new Binding(toMemberInfo, BindingType.Explicit, Mapper);
explicitBindings[toMemberInfo.Name] = binding;
}
// Reset the cache as we have mutated the bindings.
cachedBindings = null;
return binding;
}
