Come rendere molo-Maven-plug implementare una guerra che viene recuperato da un repository?

Question

Sono la creazione di un modulo di test di integrazione per un buon progetto web dimensioni. Il modulo di test di integrazione è separata dal progetto web stesso, ed ha il proprio pom.

L'idea è quella di utilizzare il Maven-SoapUI-plugin per inviare richieste e verificare la risposta. Impostazione del SoapUI-plugin è alcun fastidio. Tuttavia, sto avendo problemi con capire come posso dire molo-Maven-plug per implementare una guerra da un repository remoto.

Se ho capito bene, il pontile-Maven-plugin ha una proprietà chiamata ' / ' che mi permette di specificare il file WAR da distribuire. Il problema è che il file di guerra non è presente nel modulo stesso.

Ho sentito che posso usare l'esperto di assemblaggio plugin per recuperare la guerra da un repository tramite progetti artifactId, ma sono ancora da capire come vorrei andare a fare così.

Ecco un riassunto di ciò che voglio:

1. Recuperare una guerra specifica da un repository o simili, nel esempio attraverso la sua artifactId.
2. Deploy questa guerra al molo-Maven-plugin (obiettivo deploy-guerra?)
3. get Maven-SoapUI-plugin per eseguire test e riferire i risultati di nuovo in fase di integrazione-test.

Sono abbastanza sicuro che devo fase 3 coperto, ma sono molto sicuri di come realizzare la fase 1 e 2.

Ogni aiuto è molto apprezzato

Answer 1

È forse possibile utilizzare dependency:copy per recuperare la guerra, scompattarlo e per ottenere il tutto a lavorare con il Maven pontile plug-in, ma questo sarebbe hacky e un pò brutto. Una soluzione più pulita sarebbe quella di utilizzare il Maven Cargo plug e questo è il mio suggerimento. Qui di seguito, un esempio che mostra POM come recuperare un manufatto GUERRA utilizzando le sue coordinate e come distribuire su un contenitore Jetty incorporato utilizzando Cargo:

<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>

Infine, proprio legano il plugin SoapUI sulla fase integration-test.

Answer 2

che sto facendo la stessa cosa, John, ma ho preso un approccio diverso con il plugin Jetty. Penso che il risultato finale è lo stesso. Sto sviluppando una suite di integrazione-test per correre contro diverse guerre di servizi web. Sto utilizzando dependency:copy nella fase di package e poi un elenco di <contextHandler/>s configurate per 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>

preferirei dichiarare le varie guerre come dipendenze e quindi utilizzare dependency:copy-dependencies per impostare la directory wars-to-be-tested; ciò permetterebbe il reattore Maven per capire che ha bisogno di costruire il mio modulo di integrazione-test dopo le guerre che sarà la prova. Il problema che ho incontrato è stato che il plugin Jetty pensato che volevo "overlay" tutte le guerre che sono stati elencati come dipendenze (un concetto che non avevo mai nemmeno sentito parlare di fino a quando ho visto accadere); Non so se permettere che ciò accada avrebbe male a nessuno, ma non mi piaceva, così sono andato con il metodo dependency:copy.

Questa è solo un'alternativa all'utilizzo Cargo. Sarò alla ricerca in quel me stesso, ma volevo solo fornire un altro modo di farlo.