proyecto - ¿Cómo organizar la canalización completa con Gulp, Maven y Jenkins, hasta las pruebas de integración?

jenkins ejemplos

Question

Tengo un proyecto que tiene:

• Cliente JS con un proceso de compilación algo interesante. Eso incluye compilar CSS, cateterizar y minificar JS y CSS, generar y procesar HTML, y algunos otros pasos. Las herramientas de nodo como Grunt o Gulp son geniales en esto.
• Servidor Java que es un WAR desplegado en Tomcat. Incluye estos activos, así como todo el código de Java. Tiene todo tipo de pruebas: pruebas unitarias, pruebas de integración que pueden instanciar un DAO y hablar con DB, y pruebas API de extremo a extremo que realmente hablan con la aplicación que se ejecuta en Tomcat.
• Pruebas de extremo a extremo con transportador. Si no está familiarizado, es otra herramienta de nodo que envuelve selenio.

¿Cómo puedo organizar todo este proceso de una manera sensata, robusta y automatizada?

Lo que tengo en este momento es Gulp y Maven, con Maven básicamente siendo el dueño de todo el proceso.

1. Llama a la generación de activos de Gulp en generar fuentes usando antrun (doh, ¡tercera herramienta de compilación!).
2. Ejecuta la construcción Java normal.
3. Comienza Tomcat con mi WAR en la prueba previa a la integración.
4. Ejecuta pruebas Java E2E hablando con ese tomcat con un plugin de failsafe.
5. Llama a Gulp nuevamente con antrun, esta vez para ejecutar pruebas de transportador.
6. Apaga Tomcat en post-integración-prueba.
7. Se supone que debe verificar los resultados de las pruebas en verificación.

Ese tipo de trabajo, a excepción de que Maven es generalmente muy rígido y siento que lo llevo demasiado lejos. Usar antrun para llamar a Gulp es un truco feo. Es muy difícil controlar las dependencias entre estos pasos y monitorear sus resultados. Es difícil controlar el orden de las cosas en la misma fase. La verificación de seguridad no parece procesar los archivos de informes JUnit externos que genera Gulp. Podría seguir.

Me pregunto si debería hacer más en mi servidor de compilación (Jenkins), tal vez usando un canal de compilación o activadores parametrizados, pero nunca lo hice y no estoy seguro si eso es realmente mejor.

Entonces, ¿cómo lo implementarías?

Answer 1

En mi experiencia, el plugin frontend maven es, de lejos, el mejor complemento para este tipo de proceso de compilación / implementación. https://github.com/eirslett/frontend-maven-plugin . Así es como lo uso para Grunt, pero también soporta Gulp.

<plugin>
    <groupId>com.github.eirslett</groupId>
    <artifactId>frontend-maven-plugin</artifactId>
    <version>...</version>

    <!-- optional -->
    <configuration>
        <workingDirectory>src/main/frontend</workingDirectory>
    </configuration>

   <execution>
    <id>grunt build</id>
    <goals>
        <goal>grunt</goal>
    </goals>

    <!-- optional: the default phase is "generate-resources" -->
    <phase>generate-resources</phase>

    <configuration>
        <!-- optional: if not specified, it will run Grunt''s default
        task (and you can remove this whole <configuration> section.) -->
        <arguments>build</arguments>
    </configuration>
</execution>
</plugin>

Una cosa a tener en cuenta es descargar el nodo para el sistema en el que se está ejecutando, por lo que si tiene un sistema operativo diferente en su servidor de compilación, deberá asegurarse de que esa es la versión que ha marcado en el control de la versión. su versión local (para mí OSX) tendrá que mantenerse localmente para su proyecto.

Answer 2

Este proyecto tiene aproximadamente 2 años pero hace mucho de lo que estás buscando.

https://github.com/pankajtandon/PointyPatient/blob/master/pointy-web/pom.xml

Haga el checkout del padre pom que básicamente ejecuta todos los subproyectos juntos desde la web al dominio al repositorio y falla si alguno (las pruebas Jasmine o SpringMVC o SpringServices) fallan. Y también crea una guerra para la implementación del lado del servidor.

Esto fue pre-transportador, por lo que sería una buena adición. Aunque el complemento maven frontend se parece ahora a la herramienta para el trabajo.

HTH Pankaj

Answer 3

Trataría de construir una especie de tubería para pobres.

1. Deje que grunt / gulp haga su trabajo primero (procese activos, ejecute pruebas frontales, etc., prepare artefactos para que se incluyan en WAR). Falla toda la compilación cuando este paso falla (generación de activos o pruebas).

2. Ejecuta maven build produciendo el archivo WAR con los activos creados en el paso 1. Ejecutará un conjunto propio de pruebas con el archivo WAR normal. No necesita saber cosas de gruñidos / tragos.

A continuación, tendrá dos lugares donde, por ejemplo, se ejecutan pruebas (frontend, ejecutado por grunt / gulp y backend por maven), pero la configuración de reporteros correctos permitirá que los servidores de CI detecten todos ellos (utilizamos TeamCity y lo maneja bien).

Guión un poco y debería ser mejor que llamar al nodo a través de antrun varias veces. Alternativamente, puede ejecutar el primer paso desde la construcción de Maven, pero puede ser difícil controlar cosas.

Answer 4

Voy a utilizar esto como un trozo porque he estado buscando hacer algo similar, y volveré más adelante para enriquecer mi respuesta. Mientras tanto, deberías buscar a JHipster . A pesar de que tienen una pila mucho más grande, y su stack ya está construido, básicamente están haciendo lo que yo creo que quieres dentro de su proceso de compilación.

Aunque no estoy totalmente de acuerdo con su proceso de construcción, volveré a explicar por qué y qué estoy haciendo en los proyectos en los que estoy trabajando actualmente.