Posso specificare una classe di gruppo a livello di un test TestNG caso?

Question

Ho una classe base che rappresenta un database di test in TestNG, e voglio specificare che tutte le classi si estende da questa classe sono un gruppo di "db-test", tuttavia ho notato che non sembra possibile.Ho provato l' @Test annotazione:

@Test(groups = { "db-test" })
public class DBTestBase {
}

Tuttavia, questo non funziona perché il @Test annotazione cercherà di fare un sacco di metodi, in test, e gli avvisi o errori di pop-up in eclipse, quando i test vengono eseguiti.

Così ho provato a disabilitare il test, così almeno i gruppi sono assegnati:

@Test(enabled = false, groups = { "db-test" })
public class DBTestBase {
}

ma quindi @e BeforeTest (e di altri simili annotazioni) ANCHE ottenere disabili...che, ovviamente, non è quello che voglio.

Vorrei qualche modo di annotare una classe di un particolare tipo di gruppo, ma non sembra possibile, in TestNG.Qualcuno ha altre idee?

Answer 1

La risposta è semplice: attraverso una custom org.testng.IMethodSelector:

La sua includeMethod() possibile escludere qualsiasi metodo che si desidera, come un pubblico di non-metodo annotato.

Tuttavia, per registrare un servizio personalizzato Java MethodSelector, è necessario aggiungere alla XMLTest istanza gestiti da qualsiasi TestRunner, il che significa che avete bisogno del vostro proprio personalizzato TestRunner.

Ma, per costruire un costume TestRunner, è necessario registrare un TestRunnerFactory, attraverso il -testrunfactory l'opzione.

MA che -testrunfactory è MAI prese in considerazione da TestNG classe...quindi è necessario, inoltre, a definire un custom TestNG classe :

• per sovrascrivere la configurazione(Mappa) metodo
• così si può effettivamente impostare il TestRunnerFactory
• TestRunnerFactory che costruire una consuetudine TestRunner,
• TestRunner che verrà impostato per l'XMLTest istanza personalizzata XMLMethodSelector
• XMLMethodSelector che costruire un custom IMethodSelector
• IMethodSelector che escludono qualsiasi TestNG metodi di vostra scelta!

Ok...è un incubo.Ma è anche un codice di sfida, quindi deve essere un po ' impegnativo ;)

Tutto il codice è disponibile a DZone frammenti.

Come al solito per un codice di sfida:

• una classe java (e un bel paio di classi interne)
• copia-incolla di una classe in un 'origine/test directory (dal momento che il pacchetto è 'test')
• eseguire (senza argomenti necessari)

---

Aggiornamento da Mike Stone:

Ho intenzione di accettare questo, perché sembra piuttosto simile a quello che ho fatto io, ma ho pensato che mi piacerebbe aggiungere quello che ho fatto così.

Fondamentalmente, ho creato dei Gruppi di annotazione che si comporta come i gruppi di proprietà di Prova (e di altri) annotazioni.

Allora, ho creato un GroupsAnnotationTransformer, che utilizza IAnnotationTransformer a guardare tutti i test e test di classi in fase di definizione, quindi modifica il test per aggiungere i gruppi, che funziona perfettamente con il gruppo di esclusione e di inclusione.

Modificare il build per utilizzare la nuova annotazione trasformatore, e funziona tutto perfettamente!

Bene...l'unico svantaggio è che non aggiungere i gruppi non-metodi di prova...perché al momento ho fatto questo, c'era un'altra annotazione trasformatore che permette di trasformare QUALSIASI cosa, ma per qualche motivo non è stato inserito nella TestNG stavo usando per qualche motivo...quindi è una buona idea per rendere la vostra prima/dopo con annotazioni metodi per alwaysRun=true...che è sufficiente per me.

Il risultato finale è che posso fare:

@Groups({ "myGroup1", "myGroup2"})
public class MyTestCase {
    @Test
    @Groups("aMethodLevelGroup")
    public void myTest() {
    }
}

E ho fatto il trasformatore di lavoro con la creazione di sottoclassi e tutto il resto.

Answer 2

TestNG verrà eseguito tutti i metodi di una classe con un @Test di annotazione.Forse si potrebbe cambiare i metodi non vuoi TestNG a correre per non pubblica

Answer 3

Sembra a me come il seguente codice sfida (comunità wiki post):

Come essere in grado di eseguire tutti i test metodi di classe Estesa dal gruppo 'aGlobalGroup' senza:

• specificando il 'aGlobalGroup' gruppo classe Estesa stesso ?
• test non annotati metodi pubblici della classe Estesa ?

La prima risposta è facile:
aggiungere una classe TestNG(gruppi = { "aGlobalGroup" }) sulla Base del livello di classe

Che gruppo si applica a tutti i metodi pubblici di entrambi classe di Base e di classe Estesa.

MA:anche i non-testng metodi pubblici (senza TestNG annotazione) saranno incluse nel gruppo.

SFIDA:evitare compresi quelli non TestNG metodi.

@Test(groups = { "aGlobalGroup" })
public class Base {

    /**
     * 
     */
    @BeforeClass
     public final void setUp() {
           System.out.println("Base class: @BeforeClass");
     }


    /**
     * Test not part a 'aGlobalGroup', but still included in that group due to the class annotation. <br />
     * Will be executed even if the TestNG class tested is a sub-class.
     */
    @Test(groups = { "aLocalGroup" })
     public final void aFastTest() {
       System.out.println("Base class: Fast test");
     }

    /**
     * Test not part a 'aGlobalGroup', but still included in that group due to the class annotation. <br />
     * Will be executed even if the TestNG class tested is a sub-class.
     */
    @Test(groups = { "aLocalGroup" })
     public final void aSlowTest() {
        System.out.println("Base class: Slow test");
        //throw new IllegalArgumentException("oups");
     }

     /**
      * Should not be executed. <br />
      * Yet the global annotation Test on the class would include it in the TestNG methods...
     */
    public final void notATest() {
       System.out.println("Base class: NOT a test");
     }

    /**
     * SubClass of a TestNG class. Some of its methods are TestNG methods, other are not. <br />
     * The goal is to check if a group specify in the super-class will include methods of this class. <br />
     * And to avoid including too much methods, such as public methods not intended to be TestNG methods.
     * @author <a href="http://stackoverflow.com/users/6309/vonc">VonC</a>
     */
    public static class Extended extends Base
    {
        /**
         * Test not part a 'aGlobalGroup', but still included in that group due to the super-class annotation. <br />
         * Will be executed even if the TestNG class tested is a sub-class.
         */
        @Test
        public final void anExtendedTest() {
           System.out.println("Extended class: An Extended test");
        }

        /**
         * Should not be executed. <br />
         * Yet the global annotation Test on the class would include it in the TestNG methods...
         */ 
        public final void notAnExtendedTest() {
            System.out.println("Extended class: NOT an Extended test");
        }
    }

Answer 4

Non sono sicuro di come l'annotazione eredità opere per TestNG, ma questo articolo può essere di qualche utilità.

In realtà, questo può aiutare meglio, guardare inheritGroups.

Answer 5

È possibile specificare l' @Test annotazione a livello di metodo che consente la massima flessibilità.

public class DBTestBase {

    @BeforeTest(groups = "db-test")
    public void beforeTest() {
        System.out.println("Running before test");
    }

    public void method1() {
        Assert.fail(); // this does not run. It does not belong to 'db-test' group.
    }

    @Test(groups = "db-test")
    public void testMethod1() {
        Assert.assertTrue(true);
    }
}

Questo non funziona per voi o mi manca qualcosa dalla tua domanda.