Come faccio ad avere Emma o Cobertura, con Maven, alla copertura relazione sul codice sorgente in altri moduli?

Question

Ho una configurazione Maven multi-modulo con il codice Java.

Il mio test di unità, in uno dei moduli, codice di esercizio di più moduli. Naturalmente, i moduli hanno interdipendenze, e il codice in tutti i moduli pertinenti sono compilati come necessario prima dell'esecuzione del test.

Quindi: Come posso ottenere un rapporto sulla copertura di tutta la codebase

---

Nota: Non sto chiedendo come combinare i risultati di copertura per i test in più moduli. Mi sto chiedendo come ottenere la copertura per i test in un singolo modulo utilizzando il codice strumentato da più moduli. Chiunque sia interessato a l'ex potrebbe fare riferimento a questi other questions , e le raccomandazioni di Crowne per Maven Dashboard e Sonar .

sono riuscito a ottenere un rapporto completo di copertura utilizzando puro Ant . [EDIT:] Ho strumentato tutti i barattoli dalla directory di sviluppo-runtime in una directory temporanea; anteporre la directory temporanea al classpath; poi corse test da Ant con Batch-test .

Ant può essere eseguito da Maven, ma la sfida qui è l'integrazione senza soluzione di continuità (vale a dire, l'alimentazione di tutti gli elementi del percorso di classe e SourcePath da Maven a Ant automaticamente), motivo per cui non ho usato strutture di Maven per questo scopo.

Ci sono anche altro domande sui test di integrazione. Tuttavia, per impostazione predefinita, il rapporto di ogni progetto di default riporta solo la copertura sul codice nel stesso di progetto, mentre il mio codice di test da sforzo in più progetti.

Questo articolo in spagnolo potrebbe essere rilevante. Ecco un altro Seam-specifico articolo .

---

Answer 1

recente post sul blog di Thomas Sundberg contiene un metodo che risolve parzialmente il problema utilizzando formica per le chiamate COBERTURA, invece di utilizzare l'esperto cobertura plugin.

Si basa sul seguente approccio di base con i file pom.xml e build.xml specializzate:

Inizia con un tipico compilazione esperto di pom sul genitore, che compila tutte le classi nei moduli bambino.

mvn clean compile # maven-compile-plugin called for compiling

strumento Poi tutte le classi di modulo:

ant instrument # cobertura called for instrumentation

Quindi chiamare il Maven-infallibile-plugin chiamato per il test utilizzando le classi di strumentazione, con cobertura come un test di dipendenza

mvn test 

Quindi utilizzare una chiamata report personalizzato a tirare in tutti i risultati di diversi moduli:

ant report # cobertura called for reporting

Gli elementi chiave del file build.xml formica sono allo strumento tutti i moduli separatamente e poi a rapporto su tutti i moduli dopo la fusione i risultati. Questo deve funzione da chiamare per ogni modulo nel suo esempio:

<target name="instrumentAModule">
    <property name="classes.dir" value="target/classes"/>
    <cobertura-instrument todir="./${module}/${classes.dir}">
        <fileset dir="./${module}/target/classes">
            <include name="**/*.class"/>
        </fileset>
    </cobertura-instrument>
</target>

Poi, dopo il test è completo, la fase di rendicontazione prima unisce tutti i risultati di tutte le diverse directory vengono fuse in un nuovo file .ser (chiamato sum.ser nel suo esempio)

<target name="report" depends="merge">
    <property name="src.dir" value="src/main/java/"/>
    <cobertura-report datafile="sum.ser"
                      format="html"
                      destdir="./target/report">
        <!-- Add all modules that should be included below -->
        <!-- fileset dir="./MODULE_NAME_TO_REPLACE/${src.dir}"/ -->
        <fileset dir="./product/${src.dir}"/>
    </cobertura-report>
</target>

<target name="merge">
    <cobertura-merge datafile="sum.ser">
        <fileset dir=".">
            <include name="**/cobertura.ser"/>
        </fileset>
    </cobertura-merge>
</target>

Può essere possibile integrare i componenti della formica in Maven utilizzando il plug-in antrun, ma io non sono abbastanza familiarità con le fasi / cicli di vita di sapere dove mettere le diverse chiamate.

Questo è molto utile per me, mentre scrivo classi di test astratte nei miei moduli API e quindi fornire loro un'implementazione nei miei moduli lib. Finora sia cobertura ed Emma sono stati in grado di gestire questo progetto così la mia copertura di codice è in genere 0 o nelle singole cifre.

Answer 2

Non ha mai fatto, ma questo può essere un modo per realizzarlo:

• In ogni modulo, poco prima del install di fase, diamo strumento cobertura i file JAR e installare i file jar di strumentazione (!) Nel Maven repository
locale
• Nel test di modulo, Maven utilizzerà le dipendenze artefatto dal repository Maven locale per eseguire i test. Queste classi di strumentazione dovrebbero apparire nel file di dati, ad esempio cobertura.ser
• Esegui la generazione cobertura-report come di consueto all'interno del test di modulo del progetto, ad esempio mvn site

cobertura documentazione su come manualmente invocare cobertura al file JAR esterni strumenti sul posto:

... Puoi anche passare in file jar per essere dotati di strumenti usando i set di file di formiche standard. Cobertura estrarrà ogni classe dal vaso e lo strumento di esso. Se 'adir' non è stato specificato, allora il vaso originale verrà sovrascritto con una versione strumentato ...

plugin di compilazione del pom.xml può assomigliare a questo - si consiglia di aggiungere un profilo o utilizzare classificatori di distinguere tra il file jar finale e il file jar strumentato se non si desidera sovrascrivere nel vostro repo locale. Poi, nel modulo dei test, è sufficiente definire le dipendenze per gli altri moduli usando i classificatori.

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <executions>
                <execution>
                    <id>cobertura-inplace-instrumentation</id>
                    <phase>package</phase>
                    <configuration>
                        <tasks>
                            <taskdef classpathref="maven.plugin.classpath" resource="tasks.properties" />
                            <cobertura-instrument
                                datafile="${project.build.directory}/cobertura-nop.ser">
                                <fileset dir="${project.build.directory}">
                                    <include name="${project.build.finalName}.${project.packaging}" />
                                </fileset>
                            </cobertura-instrument>
                        </tasks>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
            <dependencies>
                <dependency>
                    <groupId>net.sourceforge.cobertura</groupId>
                    <artifactId>cobertura</artifactId>
                    <version>1.9.4.1</version>
                </dependency>
            </dependencies>
        </plugin>

Answer 3

In generale, i rapporti riguardano il loro modulo specifico, ma possono essere aggregati,
due approcci sono:

• Maven-cruscotto-plugin
• sonar

I vi consiglio di provare a utilizzare il sonar per fare l'aggregazione rapporto per voi.

Vedere il loro esempio pubblico " nemo ", per vedere le capacità impressionanti che vengono offerti.

Answer 4

Non credo che sarebbe possibile in quanto le informazioni di copertura si ottiene cobertura / Emma di strumentazione le classi compilate. Anche se questo potrebbe funzionare per le classi del progetto specificato, non è certo se questi strumenti strumento librerie dipendenti.

Uno sguardo alla Maven cobertura plugin di utilizzo fa , inoltre, non sembra per indicare tale possibilità.

Answer 5

Ho trovato questo abbastanza semplice (anche se ho fatto qualche tempo fa, e può essere arrugginito con i dettagli ...

Il mio progetto principale contiene tutti i moduli. Io uso Cobertura per misurare la mia copertura di test. Sto usando Hudson come un motore di Continuous Integration, e hai il plugin Cobertura per Hudson.

E 'stato un piacere lavorare per un po' di tempo.

Buona fortuna!