Ignorando Condicionalmente Testes no JUnit 4

OK, então a @Ignoreanotação é boa para marcar que um caso de teste não deve ser executado.

No entanto, às vezes eu quero ignorar um teste com base em informações de tempo de execução. Um exemplo pode ser se eu tiver um teste de simultaneidade que precise ser executado em uma máquina com um certo número de núcleos. Se esse teste fosse executado em uma máquina uniprocessadora, não acho que seria correto apenas passar no teste (já que não foi executado) e certamente não seria correto falhar no teste e interromper a compilação .

Então, eu quero poder ignorar testes em tempo de execução, pois esse parece ser o resultado certo (já que a estrutura de teste permitirá que a compilação passe, mas registre que os testes não foram executados). Tenho certeza de que a anotação não me dará essa flexibilidade e suspeito que precisarei criar manualmente o conjunto de testes para a classe em questão. No entanto, a documentação não menciona nada sobre isso e, analisando a API , também não está claro como isso seria feito programaticamente (ou seja, como eu crio programaticamente uma instância Testou similar equivalente à criada pela @Ignoreanotação?).

Se alguém fez algo semelhante no passado, ou tem uma idéia brilhante de como mais eu poderia fazer isso, ficaria feliz em ouvir sobre isso.

A maneira JUnit é fazer isso no tempo de execução org.junit.Assume.

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

Você pode fazer isso em um @Beforemétodo ou no próprio teste, mas não em um @Aftermétodo. Se você fizer isso no teste, seu @Beforemétodo será executado. Você também pode fazer isso dentro @BeforeClasspara impedir a inicialização da classe.

Uma falha de suposição faz com que o teste seja ignorado.

Edit: Para comparar com a @RunIfanotação de junit-ext , o código de exemplo ficaria assim:

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

Sem mencionar que é muito mais fácil capturar e usar a conexão do Database.connect()método dessa maneira.

Você deve fazer o checkout do Junit-extprojeto. Eles possuem RunIfanotações que executam testes condicionais, como:

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

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

[Exemplo de código retirado do tutorial]

Na JUnit 4, outra opção para você pode ser criar uma anotação para indicar que o teste precisa atender aos seus critérios personalizados e, em seguida, estender o corredor padrão por conta própria e, usando a reflexão, baseie sua decisão nos critérios personalizados. Pode ser algo como isto:

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

Uma observação rápida: Assume.assumeTrue(condition)ignora o restante das etapas, mas passa no teste. Para falhar no teste, use org.junit.Assert.fail()dentro da instrução condicional. Funciona da mesma forma, Assume.assumeTrue()mas falha no teste.