spring jpa - At least one JPA metamodel must be present*

Question

Anybody know why it doesn\'t work?

Error starting ApplicationContext. To display the auto-configuration report re-run your application with \'debug\' enabled         


        

Answer 1

Unfortunately, most of the springboot guides on JPA integration test often lack a piece of configuration here and there.

So here is an example that hopefully should just work for you.

Point 1. My local environment is currently setup to use springboot version:

<version.spring.boot>1.5.9.RELEASE</version.spring.boot>

That being said, I am currently setting up my local environment to be able to run integration tests against multiple databases (e.g. postgres, hsql, h2). Therefore, I start by googling any random toturial that approaches this problem.

The next link is one such example:

https://www.baeldung.com/spring-testing-separate-data-source

The above example is a good starting point. It allows you to scoop up a valid Entity and a Valid repository. The springboot test class itself, on the other hand, leaves a lot ot be desired.

With the above example, you will immediately struggle with the integration test. You will get the usuable problems about the example not giving you the application.class to configure the integration test, and you are left hanging clueless as to what springboot annotations you need to put "where" to make the test to finally run without explosions.

So now I give you a MINIMAL set of 3 classes (Entity + Repository + SpringbootTest) that should hopefully have 100 percent of the configuration you need. This will serve as a basis of any JPA based integration test you will need to do in the future, then you can swap your entities and repositories, and continue testing with the same type of srpingboot configuration.

I start by giving you the IRRELEVANT classes. The stuff that is always the same, the stuff that you want to test, and that has nothing to do with configuration. I am referring to REPOSITORY + ENTITY.

In eclipse create your java package: tutorial.www.baeldung.com.tutorial001jpa.separateDS

Dump into this package the following trivial entity and repository classes, that are based on the tutorial reference I gave above.

Tutorial001GenericEntity

package tutorial.www.baeldung.com.tutorial001jpa.separateDS;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "TUTORIAL_001_GENERIC_ENTITY")
public class Tutorial001GenericEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String value;

    public Tutorial001GenericEntity() {
        super();
    }

    public Tutorial001GenericEntity(String value) {
        super();
        this.value = value;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    // standard constructors, getters, setters

}

Then we go for the second trivial code snippet. The spring repository boiler plate code.

Tutorial001GenericEntityRepository


package tutorial.www.baeldung.com.tutorial001jpa.separateDS;

import org.springframework.data.jpa.repository.JpaRepository;

public interface Tutorial001GenericEntityRepository extends JpaRepository<Tutorial001GenericEntity, Long> {

}

At this point your maven project, src/test/java has a total of two classes. The basic stuff. An entity and a repository, that serve as an example of any integration test you will ever need to do.

So now you go to the only important class in the example, the stuff that always gives a lot of problems, and that is the springboot test class which more then being responsible to test your business logic also has the complex task of CONFIGURING your test.

In this case, this test class has ALL IN ONE the annotations that allow springboot to disocver your entities, repositories, etc...

package tutorial.www.baeldung.com.tutorial001jpa.separateDS;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {
        tutorial.www.baeldung.com.tutorial001jpa.separateDS.Tutorial001GenericEntityIntegrationTest.ConfigureJpa.class })
@SpringBootTest()
public class Tutorial001GenericEntityIntegrationTest {

    @EntityScan(basePackageClasses = { Tutorial001GenericEntity.class })
    @EnableJpaRepositories(basePackageClasses = Tutorial001GenericEntity.class)
    @EnableAutoConfiguration()
    public static class ConfigureJpa {

    }

    @Autowired
    private Tutorial001GenericEntityRepository genericEntityRepository;

    @Test
    public void givenTutorial001GenericEntityRepository_whenSaveAndRetreiveEntity_thenOK() {
        Tutorial001GenericEntity genericEntity = genericEntityRepository.save(new Tutorial001GenericEntity("test"));
        Tutorial001GenericEntity foundEntity = genericEntityRepository.findOne(genericEntity.getId());

        assertNotNull(foundEntity);
        assertEquals(genericEntity.getValue(), foundEntity.getValue());
    }
}

The important thing, you see, is that this spring boot test has a class level annotation to provide to the springboot test the configuration context.

What we are doing is dumping one and only one class reference that represents our test configuration. tutorial.www.baeldung.com.tutorial001jpa.separateDS.Tutorial001GenericEntityIntegrationTest.ConfigureJpa.class

And then on this little guy, you put all of the additional annotations in the world you need that springboot offers to configure applications.

In this case we have a dedicated annotation to mention entities. Another to mention repositories. And another to tell springboot to activate its auto configuration.

This springboot auto configuration annotation then does additional vodoo, like looking at your classpath and seeing that you have in the classpath say:

   <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>test</scope>
        <version>2.3.4</version>
    </dependency>

And it will immediately know how to configure an in memory data source for this database.

Behind the scenes, there might be additional configuration that is getting used. For example, if you create an application.properties file in your src/test/resources that file will be considered. It is very to see that the appliction.properties is considered by your running test.

If you want to verify this, make sure that in your test setup you do not have, for example, any dependency on the JDBC driver for postgres. And then put into your application.properties something liek this:

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

This dialect is not compatible with HSQL or H2, so it will immediately make your green passing integration test blow up.

To be honest, I do not know if there is a simpler combo of annotations to properly configure the springboot scanning for an integration test.

As a rule, I would recommend that you try avoiding having hundreds of thousands of configuration classes in your src/test/resources. Because if at some point you want to toggle all of your integration tests from using applicat-postgres.proeprties to application-hsql.properties, you might find yourself needing to tweak multiple configuration classes instead of just one.

So as rule, per maven component you write, I would try to have the tests that check repositories extend some sort of MyBaseINtegrationTestClass, and in there put this

@ContextConfiguration(classes = {
        tutorial.www.baeldung.com.tutorial001jpa.separateDS.Tutorial001GenericEntityIntegrationTest.ConfigureJpa.class })

So that you only need to play with one configuration for testing for the hole project.

IN any case, hopefully the triplet of classes given here helps you.

One finel thing, for maven dependencies for integration testing, here is what I am using:

<!-- Test Dependencies JPA REPOSITORY TESTS -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

The reason why i am using hsql and h2 is beacuse I want my integration tests to be able to be tunned to either use application-hsql or application-h2.properties.

Answer 2

Spring does not find any JPA Entities, so no JPA Meta Model is created, that is why you face the exception.

The cause of this problem may be a wrong persistence-api version on your class path.

You are using

<dependency> 
    <groupId>javax.persistence</groupId> 
    <artifactId>persistence-api</artifactId> 
    <version>1.0.2</version> 
</dependency> 

but I am pretty shure your spring version uses persistence-api version 2.

Could it be, you are using @Entity annotation from version 1 ? At runtime spring uses version 2, and this is searching for Entites using @Entity from version 2 only !

Remove the dependencies

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>    
<dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-jpa</artifactId>
   <version>1.11.1.RELEASE</version>
</dependency>

Instead add

  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>

This will give you all JPA dependencies in the right version.

Answer 3

I solved it by adding 2 annotations

@EnableAutoConfiguration
@EntityScan(basePackages = { "com.wt.rds" })

and my dependency was in gradle

compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '2.0.4.RELEASE'