Como hacer embarcadero maven-plugin-desplegar una guerra que se recupera de un repositorio?

Question

Soy la creación de un módulo de prueba de integración para un buen proyecto web de tamaño. El módulo de prueba de integración está separado del proyecto web en sí, y tiene su propio pom.

La idea es utilizar el experto-soapUI-plugin para enviar solicitudes y comprobar la respuesta. Configuración de la soapUI-plugin es ninguna molestia. Sin embargo, estoy teniendo problemas con averiguar cómo puedo decirle al embarcadero-maven-plugin para desplegar una guerra de un repositorio remoto.

Si he entendido bien, el muelle-maven-plugin tiene una propiedad llamada ' / ', que me permite especificar el archivo de la guerra de desplegar. El problema es que el archivo de la guerra no está presente en el propio módulo.

He oído que puedo usar el plugin de Maven montaje para recuperar la guerra desde un depósito a través de la artifactId proyectos, pero estoy aún de averiguar cómo iba a ir sobre hacerlo.

He aquí un resumen de lo que quiero:

1. Recuperar una guerra específica de un repositorio o similar, en el ejemplo a través de su artifactId.
2. Implementar esta guerra hasta el embarcadero-maven-plugin (objetivo implementar la guerra?)
3. get experto-soapUI-plugin para ejecutar las pruebas e informar de los resultados de vuelta en la fase de pruebas de integración.

Estoy bastante seguro de que tienes el paso 3 cubierto, pero estoy muy seguro de como hacer el paso 1 y 2.

Cualquier ayuda es muy apreciada

Answer 1

tal vez posible uso dependency:copy para recuperar la guerra, descomprimirlo y conseguir todo el trabajo con el experto embarcadero plugin, pero esto sería hacky y un poco feo. Una solución más limpia sería utilizar la Maven plugin de carretera y esta es mi sugerencia. A continuación, un POM ejemplo que muestra cómo recuperar un artefacto GUERRA utilizando sus coordenadas y cómo implementarlo en un recipiente embarcadero incrustado usando carga:

<dependencies>
  <dependency>
    <groupId>war group id</groupId>
    <artifactId>war artifact id</artifactId>
    <type>war</type>
    <version>war version</version>
  </dependency>
  ...
</dependencies>
...
<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.cargo</groupId>
      <artifactId>cargo-maven2-plugin</artifactId>
      <configuration>
        <!-- Container configuration -->
        <container>
          <containerId>jetty6x</containerId>
          <type>embedded</type>
        </container>
        <!-- Configuration to use with the container or the deployer -->
        <configuration>
          <deployables>
            <deployable>
              <groupId>war group id</groupId>
              <artifactId>war artifact id</artifactId>
              <type>war</type>
              <properties>
                <context>war context</context>
              </properties>
            </deployable>
          </deployables>
        </configuration>
        <!-- Don't wait, execute the tests after the container is started -->
        <wait>false</wait>
      </configuration>
      <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>
    </plugin>
    ...
  </plugins>
  ...
</build>

Finalmente, justo bind el plugin soapUI en la fase integration-test.

Answer 2

Estoy haciendo lo mismo, John, pero me tomó un enfoque diferente con el plugin embarcadero. Creo que el resultado final es el mismo. Estoy desarrollando una suite de prueba de integración para ejecutar varias guerras contra los servicios web. Estoy usando dependency:copy en la fase package y luego una lista de <contextHandler/>s configurados para maven-jetty-plugin:

<project>
    …
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-wars</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>

                        <configuration>
                            <outputDirectory>${project.build.directory}/wars-to-be-tested</outputDirectory>
                            <stripVersion>true</stripVersion>
                            <artifactItems>
                                …
                                <artifactItem>
                                    <groupId>groupId</groupId>
                                    <artifactId>artifactId</artifactId>
                                    <version>version</version>
                                    <type>war</type>
                                </artifactItem>
                                …
                            </artifactItems>
                        </configuration>
                    </execution>
               </executions>
            </plugin>

            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>7.1.3.v20100526</version>
                <configuration>
                    …
                    <contextHandlers>
                        …
                        <contextHandler implementation="org.mortbay.jetty.plugin.JettyWebAppContext">
                            <war>${project.build.directory}/wars-to-be-tested/artifactId.war</war>
                            <contextPath>/context</contextPath>
                        </contextHandler>
                    </contextHandlers>
                </configuration>

                <executions>
                    <execution>
                        <id>start-jetty</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <scanIntervalSeconds>0</scanIntervalSeconds>
                            <daemon>true</daemon>
                        </configuration>
                    </execution>

                    <execution>
                        <id>stop-jetty</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Yo preferiría para declarar las diversas guerras como dependencias y luego usar dependency:copy-dependencies para configurar el directorio wars-to-be-tested; esto permitiría que el reactor de Maven para darse cuenta de que se necesita para construir mi módulo de prueba de integración después de las guerras que va a ser la prueba. El problema que encontré fue que el plugin embarcadero pensó que quería "superposición" todas las guerras que figuraban como dependencias (un concepto que nunca había oído hablar de hasta que vi que suceda); No sé si lo que permite que esto suceda tendría duele nada, pero yo no le gustó, así que fui con el método dependency:copy.

Esto es sólo una alternativa al uso de cargas. Voy a estar buscando en que yo, pero yo sólo quería proporcionar otra manera de hacerlo.