Comment faire deploy-maven-plugin jetée une guerre qui est récupéré à partir d'un référentiel?

Question

Je suis mise en place d'un module de test d'intégration pour un projet Web de bonne taille. Le module de test d'intégration est séparée du projet Web lui-même, et il a son propre pom.

L'idée est d'utiliser le maven-plugin-SoapUI pour envoyer des requêtes et vérifier la réponse. Mise en place du SoapUI-plugin est sans tracas. Cependant, je vais avoir du mal à comprendre comment je peux dire la jetée-maven-plugin pour déployer une guerre depuis un dépôt distant.

Si je comprends bien, la jetée-maven-plugin a une propriété appelée « / » qui me permet de spécifier le fichier de guerre à déployer. Le problème est que le fichier de guerre n'est pas présent dans le module lui-même.

J'ai entendu dire que je peux utiliser le plugin Maven Assembly pour récupérer la guerre à partir d'un référentiel via l'artifactId projets, mais je suis encore à comprendre comment j'aller sur le faire.

Voici un résumé de ce que je veux:

1. Récupérer une guerre spécifique à partir d'un référentiel ou similaire, dans l'exemple via son artifactId.
2. Déployer cette guerre à la jetée-maven-plugin (but deploy-guerre?)
3. get-maven-plugin SoapUI pour exécuter des tests et communiquer les résultats dans la phase test d'intégration.

Je suis assez sûr que j'ai pas 3 couvert, mais je suis très incertain comment atteindre l'étape 1 et 2.

Toute aide est grandement appréciée

Answer 1

Il est peut-être possible d'utiliser dependency:copy pour récupérer la guerre, déballer et d'obtenir la chose à travailler avec le plugin Maven Jetty, mais ce serait un peu hacky et laid. Une solution plus propre serait d'utiliser le plugin Maven Cargo et ceci est ma suggestion. Ci-dessous, un échantillon POM montrant comment récupérer un artefact WAR en utilisant ses coordonnées et comment le déployer sur un conteneur Jetty intégré à l'aide du fret:

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

Enfin, juste lier le plugin SoapUI sur la phase integration-test.

Answer 2

Je fais la même chose, John, mais je pris une approche différente avec le plugin Jetty. Je pense que le résultat final est le même. Je développe une suite test d'intégration à courir contre plusieurs WARs de service Web. J'utilise dependency:copy dans la phase de package puis une liste de <contextHandler/>s configurés pour 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>

Je préfère déclarer les différentes guerres comme des dépendances et ensuite utiliser dependency:copy-dependencies pour configurer le répertoire wars-to-be-tested; cela permettrait au réacteur Maven de comprendre qu'il a besoin de construire mon module intégration test après la guerre, il va tester. Le problème que je courais en était que le plugin Jetty pensé que je voulais « overlay » toutes les guerres qui ont été répertoriées comme des dépendances (un concept que je ne l'avais jamais entendu parler avant même que je l'ai vu arriver); Je ne sais pas si en permettant que cela se produise aurait quelque chose de mal, mais je ne l'aimais pas, alors je suis allé avec la méthode dependency:copy.

Ceci est juste une alternative à l'utilisation du fret. Je vais regarder en moi-même, mais je voulais juste donner une autre façon de le faire.