Démarrage d'une base de données H2 Server à partir Maven?
https://stackoverflow.com/questions/2205126
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Supposons que je veux créer et utiliser une base de données de H2 pour mes tests d'intégration.
Maven a une commande pour exécuter des tests. mvn test
Est-il possible de dire Maven pour démarrer un serveur de base de données de H2 pour les tests et l'arrêter quand il est fait?
J'imagine que ce travail similaire à la façon dont je peux courir tomcat via une commande Maven (de mvn tomcat:run).
Désolé si cette question est absurde, je suis toujours envelopper ma tête autour de nouveaux concepts.
La solution
J'ai pu le faire fonctionner sans utiliser un serveur externe en ajoutant simplement la dépendance à H2 via Maven et en utilisant ce haricot:
<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>
Là encore, cela exigeait que j'utiliser un DB basé sur des fichiers au lieu de mémoire. Mais il fait l'affaire.
Autres conseils
vous pouvez créer 2 petites classes avec des méthodes principales qui commencent et arrêter la base de données. l'idée est de lancer la classe StartServer avant que les tests d'intégration sont exécutés et classe StopServer après les essais ont exécuté.
vous devriez faire la même chose pour votre serveur DB comme décrit quelque part dans ce Document (description pour le démarrage et l'arrêt de la jetée dans les tests d'intégration)
dans votre pom.xml vous devez définir le plugin maven-exec pour exécuter le exec: java but et créer 2 exécutions (1 pour appeler StartServer et 1 pour 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>
espoir que ce que vous voulez
Ce plugin fonctionne très bien pour frayer un nouveau H2 DB avec le mode tcp avant les tests d'intégration (la phase de plug-in par défaut): h2-maven-plugin sur github
Il est pas bien documenté mais vous pouvez vérifier les sources Mojo pour connaître les options de configuration. Il est publié sur le centre Maven.
En fait, pour les tests d'intégration, vous voudrez peut-être Maven à:
- Réserve de ports réseau disponibles au hasard, pour votre serveur Tomcat, et votre H2 (pour éviter les conflits de port)
- Démarrer le serveur H2
- Démarrez le serveur Tomcat
- Exécuter des tests d'intégration
- Arrêtez le serveur Tomcat
- Arrêtez le serveur H2
Ceci peut être réalisé avec une configuration Maven qui ressemble à ceci. En supposant que vos tests d'intégration sont annotées avec une interface personnalisée JUnit Catégorie:
@Category(IntegrationTest.class)
Cette configuration Maven fonctionne bien pour moi:
<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>
Vous pouvez utiliser les filtres de Maven sur le fichier de contexte tomcat de telle sorte que le port est remplacé:
<contextFile>src/main/java/META-INF/tomcat/webapp-test-context-using-h2.xml</contextFile>
Avec le contenu du fichier étant:
<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"/>
Ou si vous ne voulez pas une source de données JNDI, vous pouvez utiliser un ressort déclaré dataSource, en utilisant la même propriété ...
Un voyage supplémentaire si vous voulez être en mesure de configurer vos tests d'intégration tomcat, et exécuter les tests d'intégration de votre IDE:
Vous pouvez utiliser utiliser une propriété à la fourchette ou non le serveur Tomcat:
<fork>${integrationTestsForkTomcatJvm}</fork>
Lorsque vous définissez fork = false, le serveur se bloque et Maven ne continuera pas, de sorte que les tests d'intégration ne seront pas exécutées, mais vous serez en mesure de les exécuter à partir de votre ide.
Je viens juste de commencer projet pour le plugin H2 pour maven @ bitbucket. Je vous saurais gré de toute aide avec elle.
https://bitbucket.org/dohque/maven-h2-plugin
espère que ce sera utile.
Dans mon projet, pour les tests unitaires, j'ai demandé printemps pour gérer cette création et l'initialisation base de données. Comme indiqué dans le documentation H2 , vous pouvez créer un haricot pour cela:
<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>
Il vous suffit de démarrer le contexte du printemps avec cette configuration lorsque vous démarrez vos tests unitaires.
Je crée une base de données H2 basé sur des fichiers avant que les tests unitaires sont exécutés. Le fichier se trouve dans le répertoire target et peut être retiré à tout moment en utilisant mvn clean.
J'utilise le maven-plugin-sql comme suit:
<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>
La base de données peut être créée en exécutant mvn process-test-resources. Lorsque les tests sont exécutés, assurez-vous de vous connecter à la base de données en target/db/testdb via les propriétés de mise en veille prolongée.
<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="" />
Vous aurez également besoin d'une dépendance à l'égard com.h2database.h2 dans les dépendances de Maven.
Si vous voulez faire dans la mémoire, puis il suffit d'utiliser une autre URL:
<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>
Vous pouvez donner des options supplémentaires, telles que:; DB_CLOSE_DELAY = -1
voir: http://www.h2database.com/html/features.html# in_memory_databases
Puisque H2 ne fournit pas le plugin Maven, vous devriez commencer à l'aide maven-plugin-antrun. Ecrire du code pour le démarrage et l'arrêt du moteur h2 dans la tâche de fourmi et l'appeler au démarrage de votre essai d'intégration et de l'arrêt.
Voir les détails sur http://docs.codehaus.org/ affichage / MAVENUSER / Maven + et + intégration + Test
suivant fait le travail pour moi (juste en utilisant la dépendance h2 et 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>
S'il vous plaît noter, dans mon pom.xml la com.h2database:h2 n'a pas projeter la dépendance.
Dans le cas où vous auriez ce que vous pourriez ne pas besoin de nommer explicitement comme une dépendance de plug-in.
