maven - with - jenkins examples

Prueba de integración con la aplicación del servidor cliente en el proyecto de varios módulos de Maven

Question

Tengo un proyecto compuesto por varios módulos que usa maven y se carga y despliega automáticamente en una aplicación de Jenkins que ejecuta la compilación y sus pruebas.

Hay, por ejemplo, un módulo API, un servidor y un cliente.

Tanto el cliente como el servidor usan la API como dependencia para poder trabajar correctamente. El cliente se conecta a los servicios web del servidor a través de HTTP (s) en uso normal.

Para poder funcionar, el servidor necesita ejecutarse en Jetty.

Tengo pruebas unitarias que funcionan y prueban al cliente llamando a la funcionalidad del servidor con solicitudes HTTP burladas.

Me gustaría poder realizar algunas pruebas de integración, para probar, por ejemplo, la conexión HTTP (y HTTPS) entre las 2 entidades, probar los tiempos de espera y demás, y reproducir las pruebas unitarias sin recurrir a solicitudes falsas, para estar más cerca de las reales casos de uso.

Parece que tal cosa debería ser fácil de hacer, pero no puedo encontrar una forma de hacerlo de manera sencilla y automatizada.

Por ejemplo, la prueba manual en mi IDE se hace haciendo clic en "ejecutar guerra" en el proyecto del servidor y "ejecutar pruebas" en mi aplicación.

¿Hay alguna forma de reproducir este proceso simple en Jenkins, por lo que se realiza de forma automática, mediante la configuración de Maven o incluso con un plugin de Jenkins?

ACTUALIZAR:

Intento crear otro módulo que use la guerra resultante del empaquetado de mi servidor y ejecutarlo con Jetty. Como la configuración de Jetty de mi servidor es bastante complicada, con la configuración de Spring y https filtrada por Maven, tengo algunos problemas para que funcione en mi nuevo módulo porque faltan clases y rutas relativas que no funcionan en ese contexto.

¿Es posible ejecutar esa guerra como si hubiera sido iniciada en el otro módulo sin saltar a través de aros de recursos duplicados y otros trucos sucios?

Para información, la parte específica de Jetty war de mi pom.xml es:

<configuration>
                    <contextHandlers>
                        <contextHandler implementation="org.eclipse.jetty.webapp.WebAppContext">
                            <war>${project.parent.basedir}/cmp-service/cmp-webapp/target/cmp-webapp-1.0-SNAPSHOT.war</war>
                            <contextPath>/cmp</contextPath>
                            <persistTempDirectory>true</persistTempDirectory>
                            <allowDuplicateFragmentNames>true</allowDuplicateFragmentNames>
                        </contextHandler>
                    </contextHandlers>
</configuration>

ACTUALIZACIÓN 2:

Me las arreglé para construir un módulo de funcionamiento que comienza embarcadero y ejecutar mi prueba de integración con este pom.xml.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.project.test</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.project.test.integration-testing</groupId>

    <artifactId>integration-testing</artifactId>
    <packaging>jar</packaging>

    <name>integration-testing</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <build>
        <plugins>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.3.0.M2</version>
                <configuration>
                    <contextHandlers>
                        <contextHandler implementation="org.eclipse.jetty.webapp.WebAppContext">
                            <war>
                                ${project.parent.basedir}/myserver/myservice/target/myservice-${project.parent.version}.war
                            </war>
                            <contextPath>/cmp</contextPath>
                            <persistTempDirectory>true</persistTempDirectory>
                            <allowDuplicateFragmentNames>true</allowDuplicateFragmentNames>
                        </contextHandler>
                    </contextHandlers>

                    <contextXml>
                        ${project.parent.basedir}/myserver/myservice/src/test/resources/jetty/jetty-context.xml
                    </contextXml>
                    <jettyXml>
                        ${project.parent.basedir}/myserver/myservice/src/test/resources/jetty/jetty.xml,${project.parent.basedir}/myserver/myservice/src/test/resources/jetty/jetty-ssl.xml,${project.parent.basedir}/myserver/myservice/src/test/resources/jetty/jetty-http.xml,${project.parent.basedir}/myserver/myservice/src/test/resources/jetty/jetty-https.xml
                    </jettyXml>
                    <systemProperties>
                        <systemProperty>
                            <name>scsf.configuration.file</name>
                            <value>
                                ${project.parent.basedir}/myserver/myservice/src/main/resources/config/cmpserver.properties
                            </value>
                        </systemProperty>
                        <systemProperty>
                            <name>org.eclipse.jetty.annotations.maxWait</name>
                            <value>180</value>
                        </systemProperty>
                    </systemProperties>
                    <systemPropertiesFile>
                        ${project.parent.basedir}/myserver/myservice/src/main/resources/config/cmpserver.properties
                    </systemPropertiesFile>
                    <daemon>true</daemon>

                    <stopKey>STOP</stopKey>
                    <stopPort>10001</stopPort>
                </configuration>
                <executions>
                    <execution>
                        <id>start-jetty</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>start</goal>
                        </goals>
                        <configuration>
                            <scanIntervalSeconds>0</scanIntervalSeconds>
                        </configuration>
                    </execution>
                    <execution>
                        <id>stop-jetty</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.18.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <dependencies>
       ...
    </dependencies>
</project>

Necesitas agregar la dependencia a tu guerra como se provee también.

Pero (siempre hay un pero) hay un problema al ejecutar el objetivo de verificación. Cuando ejecuto verificar en mi módulo de prueba de integración, funciona. Pero cuando ejecuto el objetivo de verificación en el padre, que se supone que llama exactamente el mismo objetivo de verificación de mi módulo de prueba de integración (si entiendo correctamente cómo funciona), algunas rutas se tratan de manera diferente y se resuelven como, por ejemplo, parent / src / ... en lugar de parent / integration-test / src ...

Parece que cuando ejecuto mi objetivo por parte del padre, el contexto de la ejecución cambia y hace que mi aplicación se rompa al buscar recursos y tal.

¿Hay algo que no entendí sobre cómo funciona todo el proceso y hay alguna manera de hacerlo funcionar?

ACTUALIZACIÓN 3

Resolví hackear mi camino para convertir todos mis caminos en rutas absolutas, funciona, pero no explica ese comportamiento.

Answer 1

Hola Jay,

Realmente me gustaría simplificar las cosas aquí, ¿por qué no ejecutas estos trabajos en sucesión? Primero sería su compilación, pruebas de unidad y tareas de implementación con Maven. Para sus pruebas de integración, cree otro trabajo que use complementos como Selenium (para su aplicación web) y JMeter (para sus servicios web). También puede probar otro paquete de prueba de licencia como Openscript.

Las pruebas del servicio web serán complicadas, ya que el consumidor de su servicio web se ejecuta en otro cliente. ¿Tiene agentes esclavos ejecutándose en la aplicación cliente? Si tiene uno, ejecute esos trabajos dentro del esclavo.

Answer 2

Ya has descifrado los pasos básicos por ti mismo:

• crear un módulo separado para pruebas de integración
• inicie una aplicación o servidor web (por ejemplo, jetjet) a través de un complemento maven adecuado (por ejemplo, carga , wildfly-maven-plugin , etc.) en la fase de prueba previa a la integración
• ejecutar pruebas a través del maven-failsafe-plugin:integration-test mojo
• verificar los resultados a través del maven-failsafe-plugin:verify mojo

Stephen Connolly, un desarrollador maven, ya escribió una gran respuesta sobre este tema en .

No sé muy bien el plugin jetty-maven , pero parece que no es compatible con la implementación de un artefacto existente. Especificar la ruta relativa o absoluta definitivamente no es el camino a seguir aquí. Probablemente deberías usar carga para desplegar en el embarcadero. La configuración de la carga podría verse así:

<configuration>
  <configuration>
    <type>runtime</type>
    <properties>
      <cargo.hostname>testserver</cargo.hostname>
      <cargo.servlet.port>8080</cargo.servlet.port>
    </properties>
  </configuration>
  <container>
    <containerId>jetty9x</containerId>
  </container>
  <deployables>
    <deployable>
      <groupId>your.group.id</groupId>
      <artifactId>your-war</artifactId>
      <type>war</type>
      <properties>
        <context>/cmp</context>
      </properties>
    </deployable>
  </deployables>
  <deployer>
    <type>remote</type>
  </deployer>
</configuration>

La documentación de carga tiene más detalles.

hth,
- Martin