Avvio di un server di database H2 da Maven?
https://stackoverflow.com/questions/2205126
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Supponiamo che io voglio creare e utilizzare un database H2 per il mio test di integrazione.
Maven ha un comando per eseguire i test:. mvn test
C'è un modo per dire Maven per avviare un server di database H2 per le prove e arrestarlo quando è fatto?
Immagino che questo lavoro simile a come posso fare funzionare Tomcat tramite un comando Maven (mvn tomcat:run).
Scusate se questa domanda è priva di senso, sto ancora confezionamento mia testa intorno nuovi concetti.
Soluzione
Sono riuscito a farlo funzionare senza utilizzare un server esterno solo con l'aggiunta della dipendenza da H2 via Maven e quindi utilizzando questo fagiolo:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.h2.Driver"/>
<property name="url" value="jdbc:h2:file:h2\db"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
</bean>
Poi di nuovo, questo ha richiesto che io uso un DB basato su file invece che in memoria. Ma lo fa il trucco.
Altri suggerimenti
è possibile creare 2 piccole classi con metodi principali che iniziano e fermano il database. l'idea è quella di eseguire la classe StartServer prima che i test di integrazione vengono eseguiti e quindi di classe stopServer dopo i test hanno eseguito.
si dovrebbe fare lo stesso per il server di DB come descritto da qualche parte nel questo documento (descrizione è per avviare e arrestare molo in test di integrazione)
nel vostro pom.xml si dovrebbe definire il Maven-exec-plugin per eseguire il exec: java obiettivo e creare 2 esecuzioni (1 per chiamare StartServer e 1 per stopServer):
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.1.1</version>
<executions>
<execution>
<!-- start server before integration tests -->
<id>start</id>
<phase>pre-integration-test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>com.foo.StartServer</mainClass>
</configuration>
</execution>
<execution>
<!-- stop server after integration tests -->
<id>stop</id>
<phase>post-integration-test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>com.foo.StopServer</mainClass>
</configuration>
</execution>
</executions>
</plugin>
speranza che è quello che vuoi
Questo plugin funziona bene per deporre le uova un nuovo H2 DB con modalità TCP prima di test di integrazione (la fase plugin di default): H2-maven-plugin su github
Non è ben documentato, ma è possibile controllare le fonti Mojo per conoscere le opzioni di configurazione. E 'pubblicato sul centrale Maven.
In sostanza, per il test di integrazione, si consiglia Maven a:
- porte di rete Reserve in modo casuale a disposizione, per il server Tomcat, e la vostra H2 (per evitare conflitti di porta)
- Avvia il server H2
- Avvia il server Tomcat
- Esegui i test di integrazione
- Arrestare il server Tomcat
- Arrestare il server H2
Ciò può essere ottenuto con una configurazione Maven simile a questo. Assumendo che il test di integrazione sono annotata con un'interfaccia personalizzata JUnit Categoria:
@Category(IntegrationTest.class)
Questa configurazione Maven funziona bene per me:
<profile>
<id>it</id>
<build>
<plugins>
<!-- Reserve randomly available network ports -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<executions>
<execution>
<id>reserve-network-port</id>
<goals>
<goal>reserve-network-port</goal>
</goals>
<phase>process-resources</phase>
<configuration>
<portNames>
<portName>tomcat.test.http.port</portName>
<portName>h2.test.tcp.port</portName>
</portNames>
</configuration>
</execution>
</executions>
</plugin>
<!-- Start H2 before integration tests, accepting tcp connections on the randomly selected port -->
<plugin>
<groupId>com.edugility</groupId>
<artifactId>h2-maven-plugin</artifactId>
<version>1.0</version>
<configuration>
<port>${h2.test.tcp.port}</port>
</configuration>
<executions>
<execution>
<id>Spawn a new H2 TCP server</id>
<goals>
<goal>spawn</goal>
</goals>
</execution>
<execution>
<id>Stop a spawned H2 TCP server</id>
<goals>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>
<!-- Start Tomcat before integration tests on the -->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>
<systemProperties>
<spring.profiles.active>integration_tests</spring.profiles.active>
<httpPort>${http.test.http.port}</httpPort>
<h2Port>${h2.test.tcp.port}</h2Port>
</systemProperties>
<port>${http.test.http.port}</port>
<contextFile>src/main/java/META-INF/tomcat/webapp-test-context-using-h2.xml</contextFile>
<fork>true</fork>
</configuration>
<executions>
<execution>
<id>run-tomcat</id>
<phase>pre-integration-test</phase>
<goals>
<goal>run</goal>
</goals>
</execution>
<execution>
<id>stop-tomcat</id>
<phase>post-integration-test</phase>
<goals>
<goal>shutdown</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>${h2.version}</version>
</dependency>
</dependencies>
</plugin>
<!-- Run the integration tests annotated with @Category(IntegrationTest.class) -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<!-- Bug in 2.12.x -->
<version>2.11</version>
<dependencies>
<dependency>
<groupId>org.apache.maven.surefire</groupId>
<artifactId>surefire-junit47</artifactId>
<version>2.12.4</version>
</dependency>
</dependencies>
<configuration>
<groups>com.mycompany.junit.IntegrationTest</groups>
<failIfNoTests>false</failIfNoTests>
<junitArtifactName>junit:junit-dep</junitArtifactName>
<systemPropertyVariables>
<httpPort>${tomcat.test.http.port}</httpPort>
<h2Port>${h2.test.tcp.port}</h2Port>
</systemPropertyVariables>
</configuration>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
Si consiglia di utilizzare i filtri Maven sul file di contesto Tomcat in modo che la porta è sostituita:
<contextFile>src/main/java/META-INF/tomcat/webapp-test-context-using-h2.xml</contextFile>
Con l'essere contenuto del file:
<Resource name="jdbc/dataSource"
auth="Container"
type="javax.sql.DataSource"
maxActive="100"
maxIdle="30"
maxWait="10000"
username=""
password=""
driverClassName="org.h2.Driver"
url="jdbc:h2:tcp://localhost:${h2.test.tcp.port}/mem:db;DB_CLOSE_ON_EXIT=FALSE;MODE=MySQL"/>
Se non si desidera un DataSource JNDI, è possibile utilizzare una molla dichiarato dataSource, utilizzando la stessa proprietà ...
Un viaggio in più se si vuole essere in grado di impostare il test di integrazione Tomcat, ed eseguire i test di integrazione presso il vostro IDE:
È possibile utilizzare utilizzare una proprietà a forcella o meno il server Tomcat:
<fork>${integrationTestsForkTomcatJvm}</fork>
Quando si imposta forchetta = false, il server bloccare e Maven non continuerà, quindi non verranno eseguiti i test di integrazione, ma si sarà in grado di eseguirli presso il vostro IDE.
Ho appena iniziato progetto H2 plug-in per Maven @ bitbucket. Io apprezzo di aiuto con esso.
https://bitbucket.org/dohque/maven-h2-plugin
Spero che sarà utile.
Nel mio progetto, per unit test, ho chiesto a primavera per gestire questa creazione del database e l'inizializzazione. Come indicato nel H2 documentazione , è possibile creare un fagiolo per questo:
<bean id = "org.h2.tools.Server"
class="org.h2.tools.Server"
factory-method="createTcpServer"
init-method="start"
destroy-method="stop">
<constructor-arg value="-tcp,-tcpAllowOthers,true,-tcpPort,8043" />
</bean>
È sufficiente avviare il contesto primavera con questa configurazione quando si avvia il test di unità.
creo un database H2 basato su file prima di unit test vengono eseguiti. Il file risiede nella directory target e può essere rimossa in qualsiasi momento tramite mvn clean.
Io uso il Maven-sql-plugin come segue:
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>sql-maven-plugin</artifactId>
<version>1.5</version>
<dependencies>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.3.166</version>
</dependency>
</dependencies>
<configuration>
<driver>org.h2.Driver</driver>
<url>jdbc:h2:file:target/db/testdb</url>
<username>sa</username>
<password></password>
<autocommit>true</autocommit>
<skip>${maven.test.skip}</skip>
</configuration>
<executions>
<execution>
<id>create-db</id>
<phase>process-test-resources</phase>
<goals>
<goal>execute</goal>
</goals>
<configuration>
<srcFiles>
<srcFile>${sql.dir}/drop_db.sql</srcFile>
<srcFile>${sql.dir}/tables.sql</srcFile>
<srcFile>${sql.dir}/constraints.sql</srcFile>
... etc ...
</srcFiles>
</configuration>
</execution>
</executions>
</plugin>
Il database può essere creato eseguendo mvn process-test-resources. Quando i test vengono eseguiti, assicurarsi che si connette al database in target/db/testdb tramite le proprietà di Hibernate.
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="org.h2.Driver"
p:url="jdbc:h2:file:target/db/testdb"
p:username="sa"
p:password="" />
Si avrà bisogno anche di una dipendenza da com.h2database.h2 in dipendenze di Maven.
Se si vuole fare in memoria, poi basta usare un URL diverso:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.h2.Driver"/>
<property name="url" value="jdbc:h2:mem:db"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
</bean>
Si può dare opzioni aggiuntive, come ad esempio:; DB_CLOSE_DELAY = -1
vedi: http://www.h2database.com/html/features.html# in_memory_databases
Dato H2 non fornisce Maven plug-in si dovrebbe iniziare utilizzando Maven-antrun-plugin. Scrivere il codice per start e stop del motore h2 nel compito formica e chiamarla quando il test si avvia e blocca l'integrazione.
Vedi i dettagli su http://docs.codehaus.org/ display / MAVENUSER / Maven + e + + Integrazione Testing
dopo fa il lavoro per me (usando solo la dipendenza h2 e la exec-maven-plugin):
<build>
<plugins>
<!-- start/stop H2 DB as a server -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<executions>
<execution>
<id>start-h2</id>
<phase>pre-integration-test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>org.h2.tools.Server</mainClass>
<arguments>
<argument>-tcp</argument>
<argument>-tcpDaemon</argument>
</arguments>
</configuration>
</execution>
<execution>
<id>stop-h2</id>
<phase>post-integration-test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>org.h2.tools.Server</mainClass>
<arguments>
<argument>-tcpShutdown</argument>
<argument>tcp://localhost:9092</argument>
</arguments>
</configuration>
</execution>
</executions>
<configuration>
<includeProjectDependencies>true</includeProjectDependencies>
<includePluginDependencies>true</includePluginDependencies>
<executableDependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</executableDependency>
</configuration>
<dependencies>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.3.173</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
Si prega di notare che, a mio pom.xml il com.h2database:h2 non era proiettare dipendenza.
Nel caso in cui si avrebbe che si potrebbe non c'è bisogno di nominare esplicitamente come una dipendenza plugin.
