如果测试失败，则重试TestNG代码中的特定代码段，而不是整个测试

Question

如果TestNG测试失败，我想重试一些特定于方法的代码，而不是重试整个测试。

我已经从这里的https://github.com/haojiwu/testng-retry-example查看了自定义测试侦听器和重试分析器。这将重新运行整个测试，如果它失败了，我想要一些方法特定的代码。

@Test()
public void testStuff() {
    String var1;
    String var2;

    /* Code specific to this test and should only be ran once. */
    doSomething(param1)

    /* Contains code looking for files that may or not be ready by the time the code is ran. */
    /* I want to try this code then wait and retry up to a max of 3 retries. */
    assertStuff(var1, var2);
}

我想在doSomething(param1)中做代码，如果assertStuff(var1，var2)中的断言失败，我想等待5秒，然后重试assertStuff(var1，var2)代码，如果断言通过，那么测试通过，否则重试2次。

Answer 1

您可能想要使用TestNG retryAnalyzer特性，但仅限于assertStuff(var1, var2)部件。

因此，您应该将doSomething(param1)移到一个单独的方法中，并使用@BeforeClass (或@BeforeMethod)进行注释：

...
@BeforeClass
public void initSomething() {
    doSomething(param1);
}

@Test(retryAnalyzer = ThreeRetries.class)
public void testStuff() {
    String var1;
    String var2;

    assertStuff(var1, var2);
}

或者，您可以对强制部分使用@Test注释，并声明测试之间的依赖关系，例如：

...
@Test
public void initSomething() {
    doSomething(param1);
}

@Test(retryAnalyzer = ThreeRetries.class, dependsOnMethods = "initSomething")
public void testStuff() {
    String var1;
    String var2;

    assertStuff(var1, var2);
}

Answer 2

不依赖于RetryAnalyzer的一种更简单的方法(如果你不使用最新的测试版，即7.0.0-beta5或更高版本，RetryAnalyzer的一个问题是，你需要负责修剪重试产生的重复测试结果)。

相反，您可以围绕assertStuff()方法构建一个简单的轮询机制，并让它返回您可以断言的true或false。

下面是一个例子。为了方便起见，我使用了org.openqa.selenium.support.ui.FluentWait，因为它的API非常简洁

import java.time.Duration;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.function.Supplier;
import org.openqa.selenium.TimeoutException;
import org.openqa.selenium.support.ui.FluentWait;
import org.testng.Assert;
import org.testng.annotations.Test;

public class TestClass {
  private static final int max = 5;

  @Test
  public void testStuff() {
    doSomething();
    boolean wasAsserted = assertStuff(2);
    Assert.assertTrue(wasAsserted);
  }

  @Test
  public void testStuffThatFails() {
    doSomething();
    boolean wasAsserted = assertStuff(10);
    Assert.assertTrue(wasAsserted);
  }

  private boolean assertStuff(int retries) {
    final AtomicInteger integer = new AtomicInteger(0);
    Supplier<Integer> input = integer::getAndIncrement;
    FluentWait<Supplier<Integer>> checker =
        new FluentWait<>(input)
            .pollingEvery(Duration.ofSeconds(2))
            .withTimeout(Duration.ofSeconds(10));
    try {
      return checker.until(getCondition(retries));
    } catch (TimeoutException e) {
      return false;
    }
  }

  private Function<Supplier<Integer>, Boolean> getCondition(int retries) {
    return integerSupplier -> {
      int current = integerSupplier.get();
      return current == retries || current > max;
    };
  }

  private void doSomething() {
    System.err.println("I did something");
  }
}

Answer 3

简单地说，我们也尝试这样做

    int iterate=5;
    boolean status=false;

    while(iterate >=1 && status ==false) {

        try {
            assertEquals("false", "true");
            status=true;
        }catch (AssertionError e) {
            iterate--;
            Thread.sleep(500);
        }
    }