¿Cómo parar de Maven verificar fase de reconstrucción del artefacto?

StackOverflow https://stackoverflow.com/questions/4330518

Pregunta

Imagine un proyecto Java construido utilizando Maven para los que tengo:

  • algunas corrientes rápidas de pruebas unitarias que:
    • Los desarrolladores deben ejecutar antes de comprometerse
    • mi servidor CI (Hudson, Fwiw) debe ejecutarse a partir de la detección de un nuevo commit, dar retroalimentación casi instantánea en caso de fallos
  • algunas pruebas de aceptación automatizados de marcha lenta que:
    • los desarrolladores pueden ejecutar si así lo desean, por ejemplo, para reproducir y fracasos fix
    • mi servidor de CI debe ejecutar después de ejecutar con éxito las pruebas de unidad

Esto parece como un escenario típico. Actualmente, estoy corriendo:

  • las pruebas de unidad en la fase de "prueba"
  • las pruebas de aceptación en la fase de "verificar"

Hay dos puestos de trabajo configurados CI, ambos apuntando a la rama VCS del proyecto:

  1. "Commit Etapa", que se ejecuta "mvn package" (compilación y prueba de la unidad del código, construir el artefacto), que si tiene éxito, factores desencadenantes:
  2. "Pruebas Automatizado aceptación", que se ejecuta "MVN verificar" (configurar, ejecutar, y derribar las pruebas de aceptación)

El problema es que las pruebas de la unidad de trabajo 2 y construye el artefacto bajo prueba de nuevo (ya que la fase de verificación, se invoca automáticamente la fase de paquete). Esto no es deseable por varias razones (en la disminución de importancia):

  • el artefacto creado por trabajo 2 podría no ser idéntica a la creada por el trabajo 1 (por ejemplo, si se ha producido un nuevo commit en el ínterin)
  • alarga el ciclo de retroalimentación para el desarrollador que hizo el envío de datos (es decir, toma más tiempo para que se enteran de que rompieron la construcción)
  • desperdicia recursos en el servidor IC

Así que mi pregunta es, ¿Cómo puedo configurar el trabajo 2 para usar el artefacto creado por el trabajo 1?

Me doy cuenta de que sólo podía tener un puesto de trabajo de CI que se ejecuta "MVN verificar", lo que crearía el artefacto sólo una vez, pero yo quiero tener los empleos de CI separadas descritas anteriormente con el fin de implantar una distribución de estilo Farley tubería.

En caso de que ayuda a nadie, aquí está la completa Maven 2 POM del "Proyecto 2" en la respuesta aceptada: 

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example.cake</groupId>
    <artifactId>cake-acceptance</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <name>Cake Shop Acceptance Tests</name>
    <description>
        Runs the automated acceptance tests for the Cake Shop web application.
    </description>
    <build>
        <plugins>
            <!-- Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <!-- Suppress the normal "test" phase; there's no unit tests -->
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- Cargo (starts and stops the web container) -->
            <plugin>
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.0.5</version>
                <executions>
                    <execution>
                        <id>start-container</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>start</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>stop-container</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- Don't wait for CTRL-C after starting the container -->
                    <wait>false</wait>

                    <container>
                        <containerId>jetty7x</containerId>
                        <type>embedded</type>
                        <timeout>20000</timeout>
                    </container>

                    <configuration>
                        <properties>
                            <cargo.servlet.port>${http.port}</cargo.servlet.port>
                        </properties>
                        <deployables>
                            <deployable>
                                <groupId>${project.groupId}</groupId>
                                <artifactId>${target.artifactId}</artifactId>
                                <type>war</type>
                                <properties>
                                    <context>${context.path}</context>
                                </properties>
                            </deployable>
                        </deployables>
                    </configuration>
                </configuration>
            </plugin>
            <!-- Failsafe (runs the acceptance tests) -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <id>integration-test</id>
                        <goals>
                            <goal>integration-test</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>verify</id>
                        <goals>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <includes>
                        <include>**/*Test.java</include>
                    </includes>
                    <skipTests>false</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
            <!-- Add your tests' dependencies here, e.g. Selenium or Sahi,
                with "test" scope -->
        <dependency>
            <!-- The artifact under test -->
            <groupId>${project.groupId}</groupId>
            <artifactId>${target.artifactId}</artifactId>
            <version>${target.version}</version>
            <type>war</type>
        </dependency>
    </dependencies>
    <properties>
        <!-- The artifact under test -->
        <target.artifactId>cake</target.artifactId>
        <target.version>0.1.0-SNAPSHOT</target.version>
        <context.path>${target.artifactId}</context.path>
        <http.port>8081</http.port>
        <java.version>1.6</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

Tenga en cuenta que a pesar de que este proyecto "pruebas" no crea un artefacto, se ha de utilizar algún tipo de envases (utilicé "tarro" aquí), de lo contrario no hay pruebas se ejecutan en la fase de verificación.

¿Fue útil?

Solución

Trate de dos experta en proyectos. El primero contiene las pruebas de la estructura y de la unidad. Instalar los artefactos en su repositorio local. La segunda tarea se ejecuta el segundo proyecto experto que declara los artefactos del primer proyecto como dependencias y ejecuta las pruebas funcionales.

No está seguro de si el escenario que acabo de describir es posible, pero creo que es.

Para una rápida mejoría que puede pasar por alto la prueba de la unidad con -Dmaven.test.skip=true. Si pasa el número de revisión de su código en su SCM para el segundo trabajo, usted debe ser capaz de pago y envío el mismo código fuente.

También pueden alojarse en el plugin Clon espacio de trabajo SMC. Esto le podría ofrecer algunas opciones adicionales.

Otros consejos

Sé que ha pasado mucho tiempo, pero esto es bien indexado y hacer lo que pidieron ninguna de las respuestas, pero he encontrado algo que funciona: 

mvn failsafe:integration-test

Esto ejecuta las pruebas directamente, sin pasar por todos los pasos intermedios de la construcción del proyecto. Es posible que desee añadir failsafe:verify después de ella.

  

Así que mi pregunta es: ¿Cómo se configura   Job 2 de usar el artefacto creado por   Job 1?

No se puede.

No es necesario. El Maven Construir ciclo de vida está configurado de manera que los sonidos al igual que se adapta a sus necesidades. El ciclo de vida de la prueba sólo se ejecutará las junits rápidas. Paquete construir su estado final sin ejecutar la verificación.

Sólo es necesario un trabajo de CI. Cuando el CI corre el despliegue del experto / instalar ciclo de vida, si los junits no pasan la generación falla, los scripts de verificación no se ejecutará.

Puede definir un perfil de Maven que se utilizará para ejecutar solamente las pruebas de integración. Lo hago mucho.

Algo como esto: 

<profiles>
    <profile>
        <id>integration</id>
        <activation>
            <activeByDefault>false</activeByDefault>
        </activation>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId><version>2.17</version>
                    <configuration>
                        <skipTests>true</skipTests>
                    </configuration>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId><version>2.4</version>
                    <configuration>
                        <outputDirectory>/tmp</outputDirectory>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

invocaría esto con: 

mvn verify -Pintegration

Desafortunadamente el plugin guerra no puede ser omitido, pero usted puede enviar su salida a algún lugar fuera del camino (He usado / tmp). Si realmente desea guardar milisegundos, también se puede hacer caso omiso de los recursos web (excepto web.xml, no va a funcionar sin eso).

También puede usar el perfil para saltar cualquier otro plugin que puede ser que funcione, por ejemplo, el plug-in de montaje, Cobertura, el PMD, etc.

perfil Maven que ejecuta sólo las pruebas de integración ( como se sugiere aquí ) no es suficiente. También es necesario asegurarse de que la configuración de -compilador maven-plugin tiene useIncrementalCompilation = false . Ejecutar el perfil de esta manera, no va a volver a compilar de forma automática, por ejemplo:. 

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.3</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <useIncrementalCompilation>false</useIncrementalCompilation>
    </configuration>
</plugin>
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top