Test autonomo utilizzando un database in memoria

1. Panoramica

In questo tutorial, creeremo una semplice applicazione Spring che si basa su un database in memoria per i test .

Per il profilo standard, l'applicazione avrà una configurazione del database MySQL autonoma, che richiede l'installazione e l'esecuzione del server MySQL, con un utente e una configurazione del database adeguati.

Per rendere più facile il test dell'applicazione, rinunceremo alla configurazione aggiuntiva richiesta da MySQL e utilizzeremo invece un database in memoria H2 per eseguire i test JUnit.

2. Dipendenze di Maven

Per lo sviluppo, abbiamo bisogno delle seguenti dipendenze:

 org.springframework spring-test 5.1.5.RELEASE   org.springframework.data spring-data-jpa 2.1.5.RELEASE   com.h2database h2 1.4.194   org.hibernate hibernate-core 5.2.17.Final 

Le ultime versioni di spring-test, spring-data-jpa, h2 e hibernate-core possono essere scaricate da Maven Central.

3. Modello di dati e repository

Creiamo una semplice classe Student che verrà contrassegnata come entità:

@Entity public class Student { @Id private long id; private String name; // standard constructor, getters, setters }

Successivamente, creiamo un'interfaccia di repository basata su Spring Data JPA:

public interface StudentRepository extends JpaRepository { }

Ciò consentirà a Spring di creare il supporto per la manipolazione degli oggetti Student .

4. Fonti di proprietà separate

Per consentire l'uso di diverse configurazioni di database per la modalità standard e la modalità di test, possiamo leggere le proprietà del database da un file la cui posizione è diversa a seconda della modalità di esecuzione dell'applicazione.

Per la modalità normale, il file delle proprietà risiederà in src / main / risorse , e per il metodo di prova, useremo un file di proprietà della src / test / risorse cartella .

Quando si esegue un test, l'applicazione cercherà prima i file nella cartella src / test / resources . Se il file non viene trovato in questa posizione, utilizzerà quello definito nella cartella src / main / resources . Se il file è presente è il percorso di prova , sovrascriverà quello dal percorso principale .

4.1. Definizione dei file delle proprietà

Creiamo un file persistence-student.properties nella cartella src / main / resources che definisce le proprietà per un'origine dati MySQL:

dbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/myDb jdbc.user=tutorialuser jdbc.pass=tutorialpass hibernate.dialect=org.hibernate.dialect.MySQL5Dialect hibernate.hbm2ddl.auto=create-drop

Nel caso della configurazione precedente, sarà necessario creare il database myDb e impostare l'utente tutorialuser / tutorialpass .

Poiché vogliamo utilizzare un database in memoria per il test, creeremo un file simile con lo stesso nome nella cartella src / test / resources , contenente proprietà con le stesse chiavi e valori specifici del database H2 :

jdbc.driverClassName=org.h2.Driver jdbc.url=jdbc:h2:mem:myDb;DB_CLOSE_DELAY=-1 hibernate.dialect=org.hibernate.dialect.H2Dialect hibernate.hbm2ddl.auto=create

Abbiamo configurato il database H2 per vivere in memoria ed essere creato automaticamente, quindi chiuso e rilasciato quando la JVM esce.

4.2. Configurazione JPA

Creiamo una classe @Configuration che cerchi un file chiamato persistence-student.properties come origine della proprietà e crei un DataSource utilizzando le proprietà del database definite al suo interno:

@Configuration @EnableJpaRepositories(basePackages = "com.baeldung.persistence.dao") @PropertySource("persistence-student.properties") @EnableTransactionManagement public class StudentJpaConfig { @Autowired private Environment env; @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName")); dataSource.setUrl(env.getProperty("jdbc.url")); dataSource.setUsername(env.getProperty("jdbc.user")); dataSource.setPassword(env.getProperty("jdbc.pass")); return dataSource; } // configure entityManagerFactory // configure transactionManager // configure additional Hibernate Properties }

5. Creazione di un test JUnit

Scriviamo un semplice test JUnit basato sulla configurazione sopra descritta che utilizza StudentRepository per salvare e recuperare un'entità Student :

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration( classes = { StudentJpaConfig.class }, loader = AnnotationConfigContextLoader.class) @Transactional public class InMemoryDBTest { @Resource private StudentRepository studentRepository; @Test public void givenStudent_whenSave_thenGetOk() { Student student = new Student(1, "john"); studentRepository.save(student); Student student2 = studentRepository.findOne(1); assertEquals("john", student2.getName()); } }

Il nostro test verrà eseguito in modo completamente autonomo : creerà un database H2 in memoria , eseguirà istruzioni, quindi chiuderà la connessione e rilascia il database, come possiamo vedere nel registro:

INFO: HHH000400: Using dialect: org.hibernate.dialect.H2Dialect Hibernate: drop table Student if exists Hibernate: create table Student (id bigint not null, name varchar(255), primary key (id)) Mar 24, 2017 12:41:51 PM org.hibernate.tool.schema.internal.SchemaCreatorImpl applyImportSources INFO: HHH000476: Executing import script 'org.hiber[email protected]1b8f9e2' Hibernate: select student0_.id as id1_0_0_, student0_.name as name2_0_0_ from Student student0_ where student0_.id=? Hibernate: drop table Student if exists

6. Conclusione

In questo rapido esempio, abbiamo mostrato come eseguire un test autonomo utilizzando un database in memoria.

Come sempre, il codice sorgente completo può essere trovato su GitHub.