Test ignorando in modo condizionale in JUnit 4

Question

OK, quindi l'annotazione @Ignore è utile per contrassegnare che un test case 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 un computer uniprocessore, non penso che sarebbe corretto passare semplicemente il test (poiché 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 corretto (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 darà questa flessibilità e sospetto che avrò bisogno di creare manualmente la suite di test per la classe in questione. Tuttavia, la documentazione non menziona nulla a riguardo e guardando attraverso lo API non è nemmeno chiaro come ciò sarebbe fatto a livello di programmazione (cioè come faccio a creare in modo programmatico un'istanza di Test o simile che è equivalente a quella creata dall'annotazione @Ignore?).

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

Answer 1

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

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

Lo si può fare in un metodo @Before o nella prova di sé, ma non in un metodo @After. Se lo fai nel test stesso, il tuo metodo @Before verrà eseguito. Puoi anche farlo entro @BeforeClass per impedire l'inizializzazione della classe.

Un errore di presupposto fa ignorare il test.

Edit: da confrontare con il @RunIf annotazione dal JUnit-ext, il loro codice di esempio sarebbe simile a questa:

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

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

Answer 2

Si consiglia di verificare il progetto Junit-ext. Hanno RunIf annotazione 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; 
    } 
} 

[Esempio di codice tratto dal loro esercitazione] modo

Answer 3

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 come Assume.assumeTrue() ma fallisce il test.

Answer 4

In JUnit 4, un'altra opzione potrebbe essere quella di creare un'annotazione per indicare che il test deve soddisfare i criteri personalizzati, quindi estendere il runner predefinito con il proprio e utilizzando la riflessione, basare la propria 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 */ 
    } 
}