Condizionatamente ignorando prove in JUnit 4

Question

OK, quindi l'annotazione @Ignore è buono per la marcatura che un banco di prova non dovrebbe essere eseguito.

Tuttavia, a volte voglio ignorare un test basato su informazioni di runtime. Un esempio potrebbe essere se ho un test concorrenza che deve essere eseguito su una macchina con un certo numero di nuclei. Se questo test sono stati eseguiti su una macchina monoprocessore, non credo che sarebbe corretto solo superare il test (in quanto non è stato eseguito), e certamente non sarebbe giusto a fallire il test e rompere la build .

Quindi, voglio essere in grado di ignorare le prove in fase di esecuzione, come questo mi sembra il risultato giusto (dal momento che il quadro di prova consentirà la costruzione di passare, ma registrare che i test non sono stati eseguiti). Sono abbastanza sicuro che l'annotazione non mi dà questa flessibilità, e il sospetto che avrò bisogno di creare manualmente la suite di test per la classe in questione. Tuttavia, la documentazione non menziona nulla di questo e guardando attraverso il API è inoltre non è chiaro come questo possa essere fatto a livello di codice (vale a dire come faccio a programatically creare un'istanza di Test o simile che è equivalente a quello creato da l'annotazione @Ignore?).

Se qualcuno ha fatto qualcosa di simile in passato, o ha una brillante idea di come altro potrei andare su questo, sarei felice di sentire su di esso.

Answer 1

Il modo JUnit è quello di fare questo in fase di esecuzione è org.junit.Assume.

 @Before
 public void beforeMethod() {
     org.junit.Assume.assumeTrue(someCondition());
     // rest of setup.
 }

Si può fare in un metodo @Before o nella prova di sé, ma non in un metodo @After. Se lo si fa nella prova stessa, il metodo di @Before otterrà eseguito. È anche possibile farlo entro @BeforeClass per evitare l'inizializzazione di classe.

Una mancata assunzione fa sì che il test per essere ignorato.

Modifica Per confrontare con l'annotazione @RunIf da JUnit-ext , il loro codice di esempio sarebbe simile a questa:

@Test
public void calculateTotalSalary() {
    assumeThat(Database.connect(), is(notNull()));
    //test code below.
}

Per non parlare che è molto più facile da catturare e utilizzare la connessione dal metodo Database.connect() in questo modo.

Answer 2

Si dovrebbe checkout Junit-ext progetto. Hanno annotazione RunIf che esegue i test condizionali, come:

@Test
@RunIf(DatabaseIsConnected.class)
public void calculateTotalSalary() {
    //your code there
}

class DatabaseIsConnected implements Checker {
   public boolean satisify() {
        return Database.connect() != null;
   }
}

[Codice campione prelevato dal loro esercitazione]

Answer 3

In JUnit 4, un'altra opzione per voi potrebbe essere quella di creare un'annotazione per indicare che il test deve soddisfare i criteri personalizzati, quindi estendere il corridore default con il proprio e con la riflessione, basare la decisione sui criteri personalizzati. Può sembrare qualcosa di simile:

public class CustomRunner extends BlockJUnit4ClassRunner {
    public CTRunner(Class<?> klass) throws initializationError {
        super(klass);
    }

    @Override
    protected boolean isIgnored(FrameworkMethod child) {
        if(shouldIgnore()) {
            return true;
        }
        return super.isIgnored(child);
    }

    private boolean shouldIgnore(class) {
        /* some custom criteria */
    }
}

Answer 4

Una breve nota: Assume.assumeTrue(condition) ignora resto dei passi, ma supera la prova. A fallire il test, utilizzare org.junit.Assert.fail() all'interno l'istruzione condizionale. Funziona lo stesso come Assume.assumeTrue() ma fallisce il test.