public void StaticMappingScenarioTest()
{
const string GLOBAL_MAPPING_NAME_VALUE = "GLOBAL MAPPING VALUE";
Assert.False(Mapper.GlobalContainer.HasMappingFor <SourceClass, TargetClass>());
Mappings.Configure <SourceClass, TargetClass>(map => {
map.Property(t => t.Name, s => GLOBAL_MAPPING_NAME_VALUE);
});
Assert.True(Mapper.GlobalContainer.HasMappingFor <SourceClass, TargetClass>());
var source = new SourceClass();
var target = new TargetClass();
var container = Mappings.CreateContainer();
source.ApplyTo(target, container);
// containers don't use global mappings by default
Assert.NotEqual(GLOBAL_MAPPING_NAME_VALUE, target.Name);
Assert.Equal(source.Name, target.Name);
container = Mappings.CreateContainer(enableGlobalMappings: true);
source = new SourceClass();
target = new TargetClass();
source.ApplyTo(target, container);
// container should have accessed the global mappings
Assert.Equal(GLOBAL_MAPPING_NAME_VALUE, target.Name);
}
public void TargetIsReturnedFromApplyTo()
{
var source = new SourceClass();
var target = new TargetClass();
var container = Mappings.CreateContainer();
var appliedTarget = source.ApplyTo(target, container);
Assert.Same(target, appliedTarget);
Assert.Equal(source.Name, target.Name);
}
public void MappingConfigurationsAreCached()
{
var source = new SourceClass();
var target = new TargetClass();
var container = Mappings.CreateContainer();
Assert.False(container.HasMappingFor <SourceClass, TargetClass>());
source.ApplyTo(target, container);
Assert.True(container.HasMappingFor <SourceClass, TargetClass>());
}
public void MappingReadOnlyTargetPropertyThrowsException()
{
Assert.Throws <ReadOnlyPropertyException>(() => {
var source = new SourceClass();
var target = new ReadOnlyClass();
var container = Mappings.CreateContainer();
source.ApplyTo(target, container, map => {
map.Property(t => t.ReadOnlyProperty, s => s.Id);
});
});
}
public void InternalPropertiesAreMappedByDefault()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.InternalState, target.InternalState);
var container = Mappings.CreateContainer();
source.ApplyTo(target, container);
Assert.Equal(source.InternalState, target.InternalState);
}
public void PropertiesOfDifferingTypesCanBeMapped()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.Id.ToString(CultureInfo.InvariantCulture), target.Id);
var container = Mappings.CreateContainer();
source.ApplyTo(target, container, map => {
map.Property(t => t.Id, s => s.Id.ToString(CultureInfo.InvariantCulture));
});
Assert.Equal(source.Id.ToString(CultureInfo.InvariantCulture), target.Id);
}
public void PropertiesAreMatchedByNameAndTypes()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.Name, target.Name);
Assert.NotEqual(source.SourceDescription, target.TargetDescription);
var container = Mappings.CreateContainer();
source.ApplyTo(target, container);
Assert.Equal(source.Name, target.Name);
Assert.NotEqual(source.SourceDescription, target.TargetDescription);
}
public void IgnoredPropertiesAreNotMapped()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.Name, target.Name);
var container = Mappings.CreateContainer();
container.Configure <SourceClass, TargetClass>(map => {
map.Ignore(t => t.Name);
});
source.ApplyTo(target, container);
Assert.NotEqual(source.Name, target.Name);
}
public void UnmatchedPropertiesCanBeMapped()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.Name, target.Name);
Assert.NotEqual(source.SourceDescription, target.TargetDescription);
var container = Mappings.CreateContainer();
source.ApplyTo(target, container, map => {
map.Property(t => t.TargetDescription, s => s.SourceDescription);
});
Assert.Equal(source.Name, target.Name);
Assert.Equal(source.SourceDescription, target.TargetDescription);
}
public void LocalMappingOverrideConfigurationsAreNotCached()
{
var source = new SourceClass();
var target = new TargetClass();
var container = Mappings.CreateContainer();
source.ApplyTo(target, container, map => {
map.Property(p => p.TargetDescription, s => s.SourceDescription);
});
Assert.Equal(source.SourceDescription, target.TargetDescription);
source = new SourceClass();
target = new TargetClass();
source.ApplyTo(target, container);
Assert.NotEqual(source.SourceDescription, target.TargetDescription);
}
public void GracefullyHandlesNullsOnBothSides()
{
var source = new SourceClass();
var target = new TargetClass();
var container = Mappings.CreateContainer();
source.ApplyTo((TargetClass)null, container);
((SourceClass)null).ApplyTo(target, container);
((SourceClass)null).ApplyTo((TargetClass)null, container);
var newSource = new SourceClass();
var newTarget = new TargetClass();
Assert.Equal(newSource.Id, source.Id);
Assert.Equal(newSource.Name, source.Name);
Assert.Equal(newSource.SourceDescription, source.SourceDescription);
Assert.Equal(newTarget.Id, target.Id);
Assert.Equal(newTarget.Name, target.Name);
Assert.Equal(newTarget.TargetDescription, target.TargetDescription);
}
public void ContainersAreThreadSafe()
{
var container = Mappings.CreateContainer();
Parallel.For(0, 100000, i => {
var source = new SourceClass();
var target = new TargetClass();
container.Configure <SourceClass, TargetClass>(map => {
map.Property(t => t.Id, s => s.Id.ToString(CultureInfo.InvariantCulture));
});
source.ApplyTo(target, container, map => {
map.Property(t => t.TargetDescription, s => s.SourceDescription);
});
Assert.Equal(source.Id.ToString(CultureInfo.InvariantCulture), target.Id);
Assert.Equal(source.Name, target.Name);
Assert.Equal(source.SourceDescription, target.TargetDescription);
});
}
public void ConfiguredContainerWithAdditionalsTest()
{
var source = new SourceClass();
var target = new TargetClass();
Assert.NotEqual(source.Id.ToString(CultureInfo.InvariantCulture), target.Id);
Assert.NotEqual(source.Name, target.Name);
Assert.NotEqual(source.SourceDescription, target.TargetDescription);
var container = Mappings.CreateContainer();
container.Configure <SourceClass, TargetClass>(map => {
map.Property(t => t.Id, s => s.Id.ToString(CultureInfo.InvariantCulture));
});
source.ApplyTo(target, container, map => {
map.Property(t => t.TargetDescription, s => s.SourceDescription);
});
Assert.Equal(source.Id.ToString(CultureInfo.InvariantCulture), target.Id);
Assert.Equal(source.Name, target.Name);
Assert.Equal(source.SourceDescription, target.TargetDescription);
}
