A partir de un servidor de bases de H2 a partir de Maven?
https://stackoverflow.com/questions/2205126
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Supongamos que desea crear y utilizar una base de datos de H2 durante mis pruebas de integración.
Maven tiene un comando para ejecutar las pruebas:. mvn test
¿Hay una manera de saber experto para iniciar un servidor de base de datos de H2 para las pruebas y detenerlo cuando se hace?
Me imagino que este trabajo similar a la forma en que se puede ejecutar Tomcat a través de un comando de Maven (mvn tomcat:run).
Lo siento si esta pregunta no tiene sentido, todavía estoy envolviendo la cabeza en torno a nuevos conceptos.
Solución
Yo era capaz de conseguir que funcione sin necesidad de utilizar un servidor externo simplemente mediante la adición de la dependencia a H2 a través de Maven y luego usar este bean:
<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>
Por otra parte, esto requiere que utilizo una base de datos basada en archivos en lugar de en la memoria. Pero hace el truco.
Otros consejos
2 puede crear pequeñas clases con métodos principales que inician y detienen la base de datos. la idea es ejecutar la clase StartServer antes de las pruebas de integración se ejecutan y luego stopserver clase después de las pruebas se ejecute.
usted debe hacer lo mismo para el servidor de base de datos tal como se describe en algún lugar de esta documento (descripción es para iniciar y detener embarcadero en pruebas de integración)
en su pom.xml que debe definir el experto-exec-plugin para ejecutar el exec: meta java y crear ejecuciones 2 (1 para llamar StartServer y 1 para 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>
esperanza de que es lo que desea
Este plugin funciona bien para generar una nueva H2 DB con el modo TCP antes de las pruebas de integración (la fase de complemento por defecto): H2-maven-plugin en github
No está bien documentada, pero se puede comprobar las fuentes Mojo conocer las opciones de configuración. Se publica el experto central.
Básicamente, para las pruebas de integración, es posible que desee Maven para:
- puertos de red disponibles Reserva al azar, para el servidor Tomcat, y su H2 (para evitar conflictos de puerto)
- Inicie el servidor H2
- Inicie el servidor Tomcat
- Ejecutar pruebas de integración
- Detener el servidor Tomcat
- Detener el servidor H2
Esto se puede lograr con una configuración de Maven con este aspecto. Asumiendo que su test de integración están anotadas con una interfaz personalizada Categoría JUnit:
@Category(IntegrationTest.class)
Esta configuración Maven me da buenos resultados:
<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>
Es posible que desee utilizar filtros de Maven en el archivo de contexto Tomcat para que se sustituye el puerto:
<contextFile>src/main/java/META-INF/tomcat/webapp-test-context-using-h2.xml</contextFile>
Con el ser el contenido del archivo:
<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"/>
O si no desea que una fuente de datos JNDI, se puede utilizar un resorte declarada dataSource, usando la misma propiedad ...
Un viaje adicional si desea ser capaz de configurar su pruebas de integración Tomcat y ejecutar las pruebas de integración en su IDE:
Puede utilizar utilizar una propiedad que tenedor o no el servidor Tomcat:
<fork>${integrationTestsForkTomcatJvm}</fork>
Cuando se establece tenedor = false, el servidor se bloquee y experto no continuará, por lo que no se ejecutarán las pruebas de integración, pero usted será capaz de ejecutar desde el IDE.
He empezado proyecto para H2 plugin para el experto @ bitbucket. Agradeceré cualquier ayuda con ella.
https://bitbucket.org/dohque/maven-h2-plugin
Esperamos que sea útil.
En mi proyecto, para las pruebas unitarias, le pregunté a la primavera para manejar esta creación de bases de datos y la inicialización. Como se indica en la H2 documentación , puede crear un grano de que:
<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>
Usted sólo tendrá que iniciar el contexto de primavera con esta configuración al iniciar las pruebas unitarias.
se crea una base de datos basada en archivos H2 antes de ejecutar pruebas unitarias. El archivo reside en el directorio target y se puede retirar en cualquier momento utilizando mvn clean.
utilizo el maven-sql-plugin como sigue:
<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 datos puede ser creado mediante la ejecución de mvn process-test-resources. Si se ejecutan las pruebas, asegúrese de que se conecte a la base de datos en target/db/testdb través de las propiedades de hibernación.
<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="" />
También necesitará una dependencia de com.h2database.h2 en las dependencias de Maven.
Si desea hacerlo en la memoria, a continuación, sólo tiene que utilizar una URL diferente:
<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>
Puede dar opciones adicionales, tales como:; DB_CLOSE_DELAY = -1
Vea: http://www.h2database.com/html/features.html# in_memory_databases
Desde H2 no proporciona Maven plugin que debe comenzar usando Maven-antRun-plugin. Escribir código de arranque y parada del motor h2 en la tarea de hormigas y lo llaman cuando su integración prueba se inicia y parada.
Vea más detalles sobre http://docs.codehaus.org/ pantalla / MAVENUSER / Maven + y + + Prueba de Integración
siguiente hace el trabajo para mí (sólo usar la dependencia y la h2 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>
tenga en cuenta, en mi pom.xml la com.h2database:h2 fue no proyecta dependencia.
En caso de que tendría que es posible que no tenga que nombrar explícitamente como una dependencia del complemento.
