Ignorare condizionalmente i test in JUnit 4

OK, quindi l' @Ignoreannotazione è utile per contrassegnare che un caso di test non deve essere eseguito.

Tuttavia, a volte voglio ignorare un test basato sulle informazioni di runtime. Un esempio potrebbe essere se ho un test di concorrenza che deve essere eseguito su una macchina con un certo numero di core. Se questo test fosse eseguito su una macchina uniprocessore, non penso che sarebbe corretto semplicemente superare il test (dal momento che non è stato eseguito), e certamente non sarebbe giusto fallire il test e rompere la build .

Quindi voglio essere in grado di ignorare i test in fase di esecuzione, poiché questo sembra il risultato giusto (poiché il framework di test consentirà il passaggio della build ma registrerà che i test non sono stati eseguiti). Sono abbastanza sicuro che l'annotazione non mi dia questa flessibilità e sospetto che dovrò creare manualmente la suite di test per la classe in questione. Tuttavia, la documentazione non menziona nulla al riguardo e guardando attraverso l' API non è anche chiaro come questo sarebbe fatto a livello di codice (cioè come posso creare a livello di programmazione un'istanza Testo simile equivalente a quella creata @Ignoredall'annotazione?).

Se qualcuno ha fatto qualcosa di simile in passato, o ha una brillante idea di come altrimenti potrei fare questo, sarei felice di sentirlo.

Il modo JUnit è farlo in fase di esecuzione org.junit.Assume.

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

Puoi farlo in un @Beforemetodo o nel test stesso, ma non in un @Aftermetodo. Se lo fai nel test stesso, il tuo @Beforemetodo verrà eseguito. Puoi anche farlo all'interno @BeforeClassper impedire l'inizializzazione della classe.

Un errore presupposto causa l'ignoramento del test.

Modifica: per confrontare con l' @RunIfannotazione di junit-ext , il loro codice di esempio sarebbe simile al seguente:

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

Per non parlare del fatto che è molto più semplice acquisire e utilizzare la connessione dal Database.connect()metodo in questo modo.

Dovresti controllare il Junit-extprogetto. Hanno RunIfannotazioni che eseguono test condizionali, come:

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

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

[Esempio di codice tratto dal loro tutorial]

In JUnit 4, un'altra opzione potrebbe essere quella di creare un'annotazione per indicare che il test deve soddisfare i tuoi criteri personalizzati, quindi estendere il runner predefinito con il tuo e usando la riflessione, basare la tua decisione sui criteri personalizzati. Potrebbe assomigliare a questo:

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 */
    }
}

Una breve nota: Assume.assumeTrue(condition)ignora il resto dei passaggi ma supera il test. Per fallire il test, utilizzare org.junit.Assert.fail()all'interno dell'istruzione condizionale. Funziona allo stesso modo Assume.assumeTrue()ma non supera il test.