How do I get the name of the test method that was run in a testng tear down method?
Declare a parameter of type ITestResult in your @AfterMethod and TestNG will inject it:
@AfterMethod
public void afterMethod(ITestResult result) {
System.out.println("method name:" + result.getMethod().getMethodName());
}
If you want to get the method name before the test is executed you can use the following:
import java.lang.reflect.Method;
@BeforeMethod
public void nameBefore(Method method)
{
System.out.println("Test name: " + method.getName());
}
Just declare a java.lang.reflect.Method
parameter.
@BeforeMethod
public void beforeTestMethod(Method testMethod){
System.out.println("Before Testmethod: " + testMethod.getName());
}
But TestNG allows you to inject a lot more ;)
- Any @Before method or @Test method can declare a parameter of type
ITestContext
.- Any @AfterMethod method can declare a parameter of type
ITestResult
, which will reflect the result of the test method that was just run.- Any @Before and @After methods can declare a parameter of type
XmlTest
, which contain the current tag.- Any @BeforeMethod (and @AfterMethod) can declare a parameter of type
java.lang.reflect.Method
. This parameter will receive the test method that will be called once this @BeforeMethod finishes (or after the method as run for @AfterMethod).- Any @BeforeMethod can declare a parameter of type
Object[]
. This parameter will receive the list of parameters that are about to be fed to the upcoming test method, which could be either injected by TestNG, such asjava.lang.reflect.Method
or come from a@DataProvider
.- Any @DataProvider can declare a parameter of type
ITestContext
orjava.lang.reflect.Method
. The latter parameter will receive the test method that is about to be invoked.
Another (although not as simple as Cedric's answer) way that TestNG supports this is to register a listener:
@Listeners({MethodListener.class})
public class ListenerTest {
@Test
public void someTest() {
}
}
Where the listener could look like this:
public class MethodListener implements IInvokedMethodListener {
@Override
public void beforeInvocation(IInvokedMethod method, ITestResult testResult) {
}
@Override
public void afterInvocation(IInvokedMethod method, ITestResult testResult) {
System.out.println(method.getTestMethod().getMethodName());
}
}
This particular listener would print the method name (i.e. someTest
) to the console. It would be executed after every executed test.
If you are generating the testSuite programmatically then you can add the listener as follows instead of adding @Listeners({MethodListener.class})
over each test class
List<String> listeners = new ArrayList<String>();
listeners.add(MethodListener.class.getName());
testSuite.setListeners(listeners);
In my own project I access this data thanks to a JUnit @Rule
.
String testName;
String className;
@Rule
public TestWatcher watcher = new TestWatcher() {
public void starting(Description description) {
testName = description.getMethodName();
className = description.getClassName();
logger.info("Starting test " + testName + " in class " + className);
}
};