title: Orika - How can I map abstract nested property's fields
body: <p>Hi I'm having a hard time mapping an abstract nested property's fields. Here I have the test case that explains it better:</p>
  
  <pre><code>package com.mycompany.asd;
  
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  
  import ma.glasnost.orika.MapperFactory;
  import ma.glasnost.orika.MappingException;
  import ma.glasnost.orika.impl.DefaultMapperFactory;
  
  /**
   * Tests the mapping of abstract nested property's fields
   */
  public class OrikaTest {
  
  private MapperFactory mapperFactory;
  
  @Before
  public void createMapperFactoryAndDefineMapping() {
      mapperFactory = new DefaultMapperFactory.Builder()
              .useAutoMapping(false).build();
      mapperFactory.classMap(FakeBeanA.class, FakeBeanB.class)
              .field("fieldA", "fieldB.nestedField")
              .field("fieldA2", "fieldB.nestedField2") // Problem here.
              .register();
  }
  
  @Test(expected = MappingException.class)
  public void cannotMapAbstractNestedPropertyWhenConcreteTypeIsNotRegistered() {
  
      // We expect to get a MappingException. Indeed, Orika doesn't know how
      // to create an
      // instance of AbstractNestedField (the type of FakeBeanB.fieldB)
      createAnInstanceOfFakeBeanAAndMapItToFakeBeanB();
  }
  
  @Test
  public void mapAbstractNestedPropertyWhenConcreteTypeIsRegistered() {
  
      // Register concrete type for AbstractNestedType
      mapperFactory.registerConcreteType(AbstractNestedType.class,
              NestedType.class);
  
      // Orika should be able to create an instance of FieldB abstract type
      // (as we have explicitly defined above the concrete type to create and
      // the SimpleConstructorResolverStrategy is normally able to create an
      // instance of this concrete type)
      // Therefore, the mapping should work !
      createAnInstanceOfFakeBeanAAndMapItToFakeBeanB();
  }
  
  private void createAnInstanceOfFakeBeanAAndMapItToFakeBeanB() {
  
      // Create an instance of FakeBeanA and assign a value to its fieldA
      FakeBeanA fakeBeanA = new FakeBeanA();
      fakeBeanA.fieldA = 42;
  
      // Try the mapping from fakeBeanA to FakeBeanB
      FakeBeanB fakeBeanB = mapperFactory.getMapperFacade().map(fakeBeanA,
              FakeBeanB.class);
  
      // Assert the fieldA has been correctly mapped to fieldB.nestedField
      Assert.assertEquals(fakeBeanA.fieldA, fakeBeanB.fieldB.nestedField);
  }
  
  public static class FakeBeanA {
      public int fieldA;
      public int fieldA2;
  }
  
  public static class FakeBeanB {
      public AbstractNestedType fieldB;
  }
  
  public static class NestedType extends AbstractNestedType {
      public int nestedField2; // NEW ADDED
  }
  
  public static abstract class AbstractNestedType {
      public int nestedField;
  }
  </code></pre>
  
  <p>}</p>