JUnit 4.9.x及更高版本

Question

在JUnit 3中，我可以得到当前正在运行的测试的名称：

public class MyTest extends TestCase
{
    public void testSomething()
    {
        System.out.println("Current test is " + getName());
        ...
    }
}

将打印“当前测试是testSomething”。

在JUnit 4中是否有任何开箱即用或简单的方法？

背景：显然，我不想只打印测试的名称。我想加载存储在与测试同名的资源中的特定于测试的数据。你知道，convention over configuration以及所有这些。

Answer 1

JUnit 4.7使用TestName-Rule添加了此功能。看起来这样可以获得方法名称：

import org.junit.Rule;

public class NameRuleTest {
    @Rule public TestName name = new TestName();

    @Test public void testA() {
        assertEquals("testA", name.getMethodName());
    }

    @Test public void testB() {
        assertEquals("testB", name.getMethodName());
    }
}

Answer 2

JUnit 4.9.x及更高版本

自JUnit 4.9以来，{@ 3}}类已被弃用，而不是TestWatchman类，它有调用：

@Rule
public TestRule watcher = new TestWatcher() {
   protected void starting(Description description) {
      System.out.println("Starting test: " + description.getMethodName());
   }
};

JUnit 4.7.x - 4.8.x

以下方法将打印类中所有测试的方法名称：

@Rule
public MethodRule watchman = new TestWatchman() {
   public void starting(FrameworkMethod method) {
      System.out.println("Starting test: " + method.getName());
   }
};

Answer 3

JUnit 5及更高版本

在 JUnit 5 中有TestInfo注入，这简化了提供给测试方法的测试元数据。例如：

@Test
@DisplayName("This is my test")
@Tag("It is my tag")
void test1(TestInfo testInfo) {
    assertEquals("This is my test", testInfo.getDisplayName());
    assertTrue(testInfo.getTags().contains("It is my tag"));
}

查看更多：JUnit 5 User guide，TestInfo javadoc。

Answer 4

考虑使用SLF4J（Simple Logging Facade for Java）使用参数化消息提供了一些巧妙的改进。将SLF4J与JUnit 4规则实现相结合可以提供更有效的测试类日志记录技术。

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
import org.junit.rules.TestWatchman;
import org.junit.runners.model.FrameworkMethod;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingTest {

  @Rule public MethodRule watchman = new TestWatchman() {
    public void starting(FrameworkMethod method) {
      logger.info("{} being run...", method.getName());
    }
  };

  final Logger logger =
    LoggerFactory.getLogger(LoggingTest.class);

  @Test
  public void testA() {

  }

  @Test
  public void testB() {

  }
}

Answer 5

一种令人费解的方式是通过继承org.junit.runners.BlockJUnit4ClassRunner来创建自己的Runner。

然后你可以这样做：

public class NameAwareRunner extends BlockJUnit4ClassRunner {

    public NameAwareRunner(Class<?> aClass) throws InitializationError {
        super(aClass);
    }

    @Override
    protected Statement methodBlock(FrameworkMethod frameworkMethod) {
        System.err.println(frameworkMethod.getName());
        return super.methodBlock(frameworkMethod);
    }
}

然后，对于每个测试类，您需要添加@RunWith（NameAwareRunner.class）注释。或者，如果您不想每次都记住它，可以将该注释放在Test超类上。当然，这限制了您对跑步者的选择，但这可能是可以接受的。

此外，可能需要一些功夫才能将当前的测试名称从Runner和您的框架中获取，但这至少会让您获得名称。

Answer 6

请改为尝试：

public class MyTest {
        @Rule
        public TestName testName = new TestName();

        @Rule
        public TestWatcher testWatcher = new TestWatcher() {
            @Override
            protected void starting(final Description description) {
                String methodName = description.getMethodName();
                String className = description.getClassName();
                className = className.substring(className.lastIndexOf('.') + 1);
                System.err.println("Starting JUnit-test: " + className + " " + methodName);
            }
        };

        @Test
        public void testA() {
                assertEquals("testA", testName.getMethodName());
        }

        @Test
        public void testB() {
                assertEquals("testB", testName.getMethodName());
        }
}

输出如下：

Starting JUnit-test: MyTest testA
Starting JUnit-test: MyTest testB

注意：如果您的测试是 TestCase 的子类，则不会有效！测试运行但 @Rule 代码永远不会运行。

Answer 7

JUnit 4没有任何开箱即用的机制，可以让测试用例获得自己的名字（包括在安装和拆卸过程中）。

Answer 8

String testName = null;
StackTraceElement[] trace = Thread.currentThread().getStackTrace();
for (int i = trace.length - 1; i > 0; --i) {
    StackTraceElement ste = trace[i];
    try {
        Class<?> cls = Class.forName(ste.getClassName());
        Method method = cls.getDeclaredMethod(ste.getMethodName());
        Test annotation = method.getAnnotation(Test.class);
        if (annotation != null) {
            testName = ste.getClassName() + "." + ste.getMethodName();
            break;
        }
    } catch (ClassNotFoundException e) {
    } catch (NoSuchMethodException e) {
    } catch (SecurityException e) {
    }
}

Answer 9

基于之前的评论并进一步考虑我创建了TestWather的扩展，您可以在JUnit测试方法中使用它：

public class ImportUtilsTest {
    private static final Logger LOGGER = Logger.getLogger(ImportUtilsTest.class);

    @Rule
    public TestWatcher testWatcher = new JUnitHelper(LOGGER);

    @Test
    public test1(){
    ...
    }
}

测试助手类是下一个：

public class JUnitHelper extends TestWatcher {
private Logger LOGGER;

public JUnitHelper(Logger LOGGER) {
    this.LOGGER = LOGGER;
}

@Override
protected void starting(final Description description) {
    LOGGER.info("STARTED " + description.getMethodName());
}

@Override
protected void succeeded(Description description) {
    LOGGER.info("SUCCESSFUL " + description.getMethodName());
}

@Override
protected void failed(Throwable e, Description description) {
    LOGGER.error("FAILURE " + description.getMethodName());
}
}

享受！

Answer 10

@ClassRule
public static TestRule watchman = new TestWatcher() {
    @Override
    protected void starting( final Description description ) {
        String mN = description.getMethodName();
        if ( mN == null ) {
            mN = "setUpBeforeClass..";
        }

        final String s = StringTools.toString( "starting..JUnit-Test: %s.%s", description.getClassName(), mN );
        System.err.println( s );
    }
};

Answer 11

我建议您将测试方法名称与测试数据集分离。我将建模一个DataLoaderFactory类，它从您的资源加载/缓存测试数据集，然后在您的测试用例中调用一些接口方法，该方法返回测试用例的一组测试数据。将测试数据与测试方法名称相关联假设测试数据只能使用一次，在大多数情况下，我建议在多个测试中使用相同的测试数据来验证业务逻辑的各个方面。

Answer 12

您可以使用Slf4j和TestWatcher

来实现这一目标

private static Logger _log = LoggerFactory.getLogger(SampleTest.class.getName());

@Rule
public TestWatcher watchman = new TestWatcher() {
    @Override
    public void starting(final Description method) {
        _log.info("being run..." + method.getMethodName());
    }
};

Answer 13

在JUnit 5中，TestInfo替代了JUnit 4中的TestName规则。

从文档中：

TestInfo用于注入有关当前测试或容器放入@ Test，@ RepeatedTest，@ ParameterizedTest， @ TestFactory，@ BeforeEach，@ AfterEach，@ BeforeAll和@AfterAll 方法。

要检索当前已执行测试的方法名称，您有两个选项：String TestInfo.getDisplayName()和 Method TestInfo.getTestMethod()。

仅检索当前测试方法的名称TestInfo.getDisplayName()可能不够，因为测试方法的默认显示名称为methodName(TypeArg1, TypeArg2, ... TypeArg3)。
在@DisplayName("..")中复制方法名称不是一个好主意。

您也可以使用 TestInfo.getTestMethod()返回一个Optional<Method>对象。
如果在测试方法中使用了检索方法，则您甚至不需要测试Optional包装的值。

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.TestInfo;
import org.junit.jupiter.api.Test;

@Test
void doThat(TestInfo testInfo) throws Exception {
    Assertions.assertEquals("doThat(TestInfo)",testInfo.getDisplayName());
    Assertions.assertEquals("doThat",testInfo.getTestMethod().get().getName());
}

Answer 14

通过ExtensionContext的JUnit 5

优势：

通过覆盖ExtensionContext，您将获得afterEach(ExtensionContext context)的附加功能。

public abstract class BaseTest {

    protected WebDriver driver;

    @RegisterExtension
    AfterEachExtension afterEachExtension = new AfterEachExtension();

    @BeforeEach
    public void beforeEach() {
        // Initialise driver
    }

    @AfterEach
    public void afterEach() {
        afterEachExtension.setDriver(driver);
    }

}

public class AfterEachExtension implements AfterEachCallback {

    private WebDriver driver;

    public void setDriver(WebDriver driver) {
        this.driver = driver;
    }

    @Override
    public void afterEach(ExtensionContext context) {
        String testMethodName = context.getTestMethod().orElseThrow().getName();
        // Attach test steps, attach scsreenshots on failure only, etc.
        driver.quit();
    }

}

Answer 15

我有一个扩展 TestCase 的 Junit4 测试类，因此 @Rule 的示例不起作用（如其他答案中所述）。

但是，如果您的类扩展了 TestCase，您可以使用 getName() 来获取当前的测试名称，这样就可以了：

@Before
public void setUp() {
  System.out.println("Start test: " + getName());
}

@After
public void tearDown() {
  System.out.println("Finish test: " + getName());
}

获取JUnit 4中当前正在执行的测试的名称

15 个答案:

JUnit 4.9.x及更高版本

JUnit 4.7.x - 4.8.x

JUnit 5及更高版本

通过ExtensionContext的JUnit 5