Ok, eu sei que você provavelmente deseja uma propriedade fácil que possa ser especificada na sua @BeforeClass ou algo parecido, mas talvez seja necessário aguardar a implementação. Pelo menos eu também não consegui encontrar.
A seguir, é feio como o inferno, mas acho que faz o trabalho, pelo menos em pequena escala, resta ver como ele se comporta em cenários mais complexos. Talvez com mais tempo, isso possa ser aprimorado para algo melhor.
Ok, então eu criei uma classe de teste semelhante à sua:
public class RetryTest extends TestConfig {
public class RetryTest extends TestConfig {
Assertion assertion = new Assertion();
@Test( enabled = true,
groups = { "retryTest" },
retryAnalyzer = TestRetry.class,
ignoreMissingDependencies = false)
public void testStep_1() {
}
@Test( enabled = true,
groups = { "retryTest" },
retryAnalyzer = TestRetry.class,
dependsOnMethods = "testStep_1",
ignoreMissingDependencies = false)
public void testStep_2() {
if (fail) assertion.fail("This will fail the first time and not the second.");
}
@Test( enabled = true,
groups = { "retryTest" },
retryAnalyzer = TestRetry.class,
dependsOnMethods = "testStep_2",
ignoreMissingDependencies = false)
public void testStep_3() {
}
@Test( enabled = true)
public void testStep_4() {
assertion.fail("This should leave a failure in the end.");
}
}
Eu tenho a Listenerclasse super apenas no caso em que gostaria de estender isso para outras classes, mas você também pode definir o ouvinte em sua classe de teste.
@Listeners(TestListener.class)
public class TestConfig {
protected static boolean retrySuccessful = false;
protected static boolean fail = true;
}
Três dos 4 métodos acima têm a RetryAnalyzer. Deixei o testStep_4sem para ter certeza de que o que estou fazendo a seguir não mexa com o resto da execução. Dito RetryAnalyzer, na verdade, não tentará novamente (observe que o método retornará false), mas fará o seguinte:
public class TestRetry implements IRetryAnalyzer {
public static TestNG retryTestNG = null;
@Override
public boolean retry(ITestResult result) {
Class[] classes = {CreateBookingTest.class};
TestNG retryTestNG = new TestNG();
retryTestNG.setDefaultTestName("RETRY TEST");
retryTestNG.setTestClasses(classes);
retryTestNG.setGroups("retryTest");
retryTestNG.addListener(new RetryAnnotationTransformer());
retryTestNG.addListener(new TestListenerRetry());
retryTestNG.run();
return false;
}
}
Isso criará uma execução dentro da sua execução. Não mexerá no relatório e, assim que terminar, continuará com sua execução principal. Mas ele "tentará" novamente os métodos dentro desse grupo.
Sim, eu sei, eu sei. Isso significa que você executará seu conjunto de testes para sempre em um loop eterno. É por isso que o RetryAnnotationTransformer. Nele, removeremos o RetryAnalyzer da segunda execução desses testes:
public class RetryAnnotationTransformer extends TestConfig implements IAnnotationTransformer {
@SuppressWarnings("rawtypes")
@Override
public void transform(ITestAnnotation annotation, Class testClass, Constructor testConstructor, Method testMethod) {
fail = false; // This is just for debugging. Will make testStep_2 pass in the second run.
annotation.setRetryAnalyzer(null);
}
}
Agora temos o último dos nossos problemas. Nosso conjunto de testes original não sabe nada sobre a "repetição" de execução lá. É aqui que fica realmente feio. Precisamos contar ao nosso repórter o que aconteceu. E esta é a parte que eu encorajo você a melhorar. Falta-me tempo para fazer algo melhor, mas, se puder, vou editá-lo em algum momento.
Primeiro, precisamos saber se a execução retryTestNG foi bem-sucedida. Provavelmente existem milhões de maneiras de fazer isso melhor, mas por enquanto isso funciona. Eu configurei um ouvinte apenas para a nova tentativa de execução. Você pode vê-lo TestRetryacima e consiste no seguinte:
public class TestListenerRetry extends TestConfig implements ITestListener {
(...)
@Override
public void onFinish(ITestContext context) {
if (context.getFailedTests().size()==0 && context.getSkippedTests().size()==0) {
successful = true;
}
}
}
Agora, o Ouvinte da suíte principal, o que você viu acima na superclasse TestConfigverá se a execução aconteceu e se correu bem e atualizará o relatório:
public class TestListener extends TestConfig implements ITestListener , ISuiteListener {
(...)
@Override
public void onFinish(ISuite suite) {
if (TestRetry.retryTestNG != null) {
for (ITestNGMethod iTestNGMethod : suite.getMethodsByGroups().get("retryTest")) {
Collection<ISuiteResult> iSuiteResultList = suite.getResults().values();
for (ISuiteResult iSuiteResult : iSuiteResultList) {
ITestContext iTestContext = iSuiteResult.getTestContext();
List<ITestResult> unsuccessfulMethods = new ArrayList<ITestResult>();
for (ITestResult iTestResult : iTestContext.getFailedTests().getAllResults()) {
if (iTestResult.getMethod().equals(iTestNGMethod)) {
iTestContext.getFailedTests().removeResult(iTestResult);
unsuccessfulMethods.add(iTestResult);
}
}
for (ITestResult iTestResult : iTestContext.getSkippedTests().getAllResults()) {
if (iTestResult.getMethod().equals(iTestNGMethod)) {
iTestContext.getSkippedTests().removeResult(iTestResult);
unsuccessfulMethods.add(iTestResult);
}
}
for (ITestResult iTestResult : unsuccessfulMethods) {
iTestResult.setStatus(1);
iTestContext.getPassedTests().addResult(iTestResult, iTestResult.getMethod());
}
}
}
}
}
}
O relatório deve mostrar agora três testes aprovados (à medida que foram repetidos) e um que falhou porque não fazia parte dos outros três testes:
Sei que não é o que você está procurando, mas ajudo a atendê-lo até que eles adicionem a funcionalidade ao TestNG.