Easiest way of programatically checking that a class has a valid JPA defintion

Question

I'm working with many classes which are annotated with javax.persistence.Entity and the like. My project is about generating metadata about JPA-annotated classes rather than persistence by itself, so I'm using them as test cases.

Rather than firing up Hibernate or some other JPA provider, I'd like to programatically check - part of my unit tests - that my JPA declarations are indeed valid.

What's the easiest way of doing that?

Answer 1

I'm not sure if there's an easier way but you can use Reflection to access the annotations of a class

Class class = Example.class;
Annotation[] annotations = class.getAnnotations();

Answer 2

Just create the simplest possible SessionFactory or whatever EclipseLink or OpenJPA provide behind the EntityManagerFactory and let them validate it (using some dummy in-memory database, if needed). It's too complex to reinvent it.

For Hibernate this can be done using Configuration.buildMappings:

@RunWith(Theories.class)
public class EntitiesAreValidTest {

    @DataPoints
    public static Class<?>[] entities = new Class[] {
        SimpleEntity.class,
        SimpleEntityWithTransientField.class,
        TwoFieldEntity.class
    };

    @Theory
    public void classHasValidConfiguration(Class<?> entityClass) {

        new AnnotationConfiguration().addAnnotatedClass(entityClass).buildMappings();
    }
}

Answer 3

Whats wrong about using a concrete JPA-provider in your tests? In combination with an embedded database (e.g. Apache Derby) you could reuse logic that has indeed already been implemented. Another idea would be to check the sources of EclipseLink, Hibernate, OpenJPA, ... to see whether you can directly use it.

Answer 4

If you don't trust JPA providers (or don't want to use them) then try to reconcile JPA annotations (metadata) retrieved using reflection with JDBC metadata retrieved using ResultSetMetaData (for example see here).

I don't mean this to be simple, but with right approach you should have rather compact set of helper methods to check basic definitions for each entity. And mileage may vary depending on how much JPA functionality you want to cover.