È possibile avere un'istanza Tomcat "in-process", a scopo di test?

Question

Ho un progetto di app Web basato su Maven che genera un WAR da eseguire in Tomcat. Supponiamo, per amor di discussione, che sia di vitale importanza per i test unitari di quel progetto inviare/ricevere effettivamente richieste sulla rete (piuttosto che chiamare semplicemente i metodi servlet con una richiesta fittizia).

Esiste un modo per il mio cablaggio di test per eseguire un'istanza di Tomcat nella stessa JVM, caricare il progetto corrente e lasciare che i casi di test lo raggiungano su localhost? In caso contrario, come potrei in realtà programmare in modo programmatico il progetto corrente (insieme alle dipendenze) in un WAR in modo da poter utilizzare Cargo per caricarlo programmaticamente su un'altra istanza di Tomcat? C'è un'alternativa migliore del semplice bombardamento a mvn?

so la mia richiesta è insolito e test di unità dovrebbe essere più autosufficiente, ecc, ma per favore facciamo solo giocare insieme :)

Answer 1

È possibile utilizzare un embedded Tomcat per esattamente questo scopo.È sufficiente impostare un'istanza statica nel cablaggio di prova e chiuderla alla fine. Ecco alcuni esempi di codice:

import org.apache.catalina.LifecycleException; 
import org.apache.catalina.startup.Tomcat; 
import org.junit.AfterClass; 
import org.junit.BeforeClass; 

public class TomcatIntegrationTest { 
    private static Tomcat t; 
    private static final int TOMCAT_PORT = 9999; 

    @BeforeClass 
    public static void setUp() throws LifecycleException { 
    t = new Tomcat(); 
    t.setBaseDir("."); 
    t.setPort(TOMCAT_PORT); 
    /* There needs to be a symlink to the current dir named 'webapps' */ 
    t.addWebapp("/service", "src/main/webapp"); 
    t.init(); 
    t.start(); 
    } 

    @AfterClass 
    public static void shutDownTomcat() throws LifecycleException { 
    t.stop(); 
    } 
} 

Answer 2

Jetty funziona davvero bene per questo scopo. Se non sei obbligato ad avere Tomcat, puoi usarlo abbastanza facilmente durante la fase di test di integrazione. Avere un molo di partenza pre-integrazione e l'integrazione post-interruzione lo interrompe e puoi lanciare una richiesta nel tuo file di guerra perché è in esecuzione in un contenitore reale.

Answer 3

Vorrei suggerire di creare test di integrazione appropriati e utilizzare la seguente configurazione per eseguire i test di integrazione durante la generazione di Maven.

È possibile utilizzare la seguente parte per scaricare tomcat o se è necessario utilizzare un artefatto dal repository.

<groupId>org.codehaus.cargo</groupId> 
<artifactId>cargo-maven2-plugin</artifactId> 
<configuration> 
    <wait>false</wait> 
    <container> 
     <containerId>tomcat${tomcat.major}x</containerId> 
     <zipUrlInstaller> 
      <url>http://archive.apache.org/dist/tomcat/tomcat-${tomcat.major}/v${tomcat.version}/bin/apache-tomcat-${tomcat.version}.tar.gz</url> 
      <extractDir>${project.build.directory}/extract/</extractDir> 
      <downloadDir>${project.build.directory}/download/</downloadDir> 
     </zipUrlInstaller> 
     <output>${project.build.directory}/tomcat${tomcat.major}x.log</output> 
     <log>${project.build.directory}/cargo.log</log> 
    </container> 
    <configuration> 
     <home>${project.build.directory}/tomcat-${tomcat.version}/container</home> 
     <properties> 
      <cargo.logging>high</cargo.logging> 
      <cargo.servlet.port>9080</cargo.servlet.port> 
      <cargo.tomcat.ajp.port>9008</cargo.tomcat.ajp.port> 
     </properties> 
    </configuration> 
</configuration> 

La parte successiva è utilizzato inizio e distribuire l'applicazione in data Tomcat (che lavora anche con molo).

<executions> 
    <execution> 
     <id>start-container</id> 
     <phase>pre-integration-test</phase> 
     <goals> 
      <goal>start</goal> 
      <goal>deploy</goal> 
     </goals> 
     <configuration> 
      <deployer> 
       <deployables> 
        <deployable> 
         <groupId>${project.groupId}</groupId> 
         <artifactId>mod-war</artifactId> 
         <type>war</type> 
         <pingURL>http://localhost:9080/mod-war</pingURL> 
         <pingTimeout>30000</pingTimeout> 
         <properties> 
          <context>mod-war</context> 
         </properties> 
        </deployable> 
       </deployables> 
      </deployer> 
     </configuration> 
    </execution> 

e, naturalmente, infine, per arrestare il server avviato tramite:

<execution> 
    <id>stop-container</id> 
    <phase>post-integration-test</phase> 
    <goals> 
     <goal>stop</goal> 
    </goals> 
</execution> 

La cosa migliore è quella di mettere questo tipo di configurazione, ecc in un modulo esperto di separato che potrebbe essere chiamata app-it (per il test di integrazione). Il ciclo completo di test può essere semplicemente chiamato da

mvn verify 

mentre nella verifica del ciclo di vita della fase di test di integrazione verrà eseguito e che inizia la configurazione di cui sopra. Ma è importante configurare lo maven-failsafe-plugin per far funzionare i test di integrazione. Descrizione dettagliata di questo può essere trovato in Maven Unit- and Integration Test Guide

<plugin> 
    <groupId>org.apache.maven.plugins</groupId> 
    <artifactId>maven-failsafe-plugin</artifactId> 
    <version>2.12</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> 
</plugin> 

Answer 4

Che cosa si può fare è quello di generare un archetipo con il plugin Maven Tomcat di Apache vedere http://tomcat.apache.org/maven-plugin-2.0/archetype.html.

Avrete vari campioni:

• embeded test JUnit
• avviare un'istanza di Tomcat con una guerra ed eseguire i test di selenio

HTH