MaxRokatansky May 7, 2019 at 17:43

TestNG Annotation Guide for Selenium WebDriver

Transfer

Peace, labor, May, Khabrovsk residents! For those who, like us, burst into the inter-holiday workweek, we have prepared a translation that we want to coincide with the start of recruitment for the Java QA Engineer course , which is scheduled for launch on May 28.

TestNG is a test framework created by Cédric Beust that helps us meet many of our testing needs. TestNG is widely used with Selenium. Want to know what NG means? This means “Next Generation” . TestNG is similar to JUnit, but it is more powerful when it comes to controlling the flow of your program. The architecture of the framework helps us make tests more structured and provide better validation points.

Some features of TestNG that deserve attention:

Powerful and varied annotations to support your test cases.
Running tests in parallel, using dependencies between tests.
The flexibility to run your tests on different data sets, through the TestNG.xml file or through the concept of data providers.
Grouping and prioritization of test cases.
Generation of HTML reports, customization using various plugins.
Generation of test execution logs.
Easy integration with Eclipse, Maven, Jenkins, etc.

Typically, the testing process using TestNG includes the following steps:

Before moving on to TestNG annotations for Selenium, we outline the prerequisites for setting up TestNG.

Prerequisites:

Java development kit
Eclipse or any other IDE
Installed TestNG in Eclipse or in your IDE

Note: Java annotations can only be used with Java version 1.5 and higher.

If you are new to TestNG, see the article on how to run the first automation script with TestNG .

So what is an annotation?

An annotation is a label that provides additional information about a class or method ( Translator's note: annotations in java can be applied not only to classes and methods, but also to other elements ). For annotations, the prefix “@” is used. TestNG uses annotations to help create a robust test framework. Let's look at the TestNG annotations used to automate testing with Selenium.

@Test

This is the most important annotation in TestNG, which contains the main logic of the test . All automated functions are in the annotated method @Test. It has various attributes with which the method launch can be configured.

The sample code below checks the url transition:

@Test
public void testCurrentUrl() throws InterruptedException {
   driver.findElement(By.xpath("//*[@id='app']/header/aside/ul/li[4]/a"))
     .click();
   String currentUrl = driver.getCurrentUrl();
   assertEquals(
     currentUrl,
     "https://automation.lambdatest.com/timeline/?viewType=build&page=1", 
     "url did not matched");
}

@BeforeTest

A method with this annotation is started before the first method with the annotation starts @Test. (Translator's note: as part of the test defined in the section testin the xml configuration file) . You can use this annotation in TestNG with Selenium to configure your browser. For example, launch a browser and expand it to full screen, set specific browser settings, etc.

Below is an example for BeforeTest, in which the browser expands to full screen:

@BeforeTest
public void profileSetup() {
   driver.manage().window().maximize();
}

@AfterTest

Methods marked with this annotation start after all the- @Testmethods of your test. ( Translator's note: as part of the test defined in the section testin the xml configuration file, the “current class” is not correctly written in the original ). This is a useful annotation that is useful for providing test results. You can use this annotation to create a report on your tests and email it to interested parties.

Code example:

@AfterTest
public void reportReady() {
   System.out.println("Report is ready to be shared, with screenshots of tests");
}

@BeforeMethod

Methods with this annotation are run before each @Testmethod . You can use it to test the connection to the database before running the test. Or, for example, when testing functionality that depends on the user's login, put the code to enter the system here.
The following is a code snippet demonstrating LambdaTest login:

@BeforeMethod
public void checkLogin() {
   driver.get("https://accounts.lambdatest.com/login");
   driver.findElement(By.xpath("//input[@name='email']")).sendKeys("sadhvisingh24@gmail.com");
   driver.findElement(By.xpath("//input[@name='password']")).sendKeys("activa9049");
   driver.findElement(By.xpath("//*[@id='app']/section/form/div/div/button")).click();
}

@AfterMethod

Methods with this annotation are launched after each @Testmethod . You can use this annotation to take screenshots each time you run the test.
The following is a snippet of code demonstrating how to take a screenshot:

@AfterMethod
public void screenShot() throws IOException {
   TakesScreenshot scr = ((TakesScreenshot) driver);
   File file1 = scr.getScreenshotAs(OutputType.FILE);
   FileUtils.copyFile(file1, new File("С:\\test-output\\test1.PNG"));
}

@BeforeClass

A method with this annotation will execute before the first test method in the current class. You can use this annotation to configure browser properties, initialize the driver, open a browser with the desired URL, etc.

Sample code for BeforeClass:

@BeforeClass
public void appSetup() {
   driver.get(url);
}

@AfterClass

A method with this annotation will execute after the last test method in the current class. This annotation in TestNG can be used to perform actions to clean up resources after the test is completed, such as closing the driver, etc.
The following is an example of a code snippet showing driver closure:

@AfterClass
public void closeUp() {
   driver.close();
}

@BeforeSuite

A test suite (suite) can consist of several classes, this annotation is run before all test methods of all classes. This annotation marks the entry point at startup. @BeforeSuiteTestNG annotation can be used to perform common functions, such as setting up and running Selenium or remote web drivers, etc.
An example annotation @BeforeSuitein TestNG showing driver setup:

@BeforeSuite
public void setUp() {
   System.setProperty(
           "webdriver.chrome.driver",
           "С:\\selenium\\chromedriver.exe");
   driver = new ChromeDriver();
}

@AfterSuite

This annotation in TestNG starts after all test methods in all classes have been run. This annotation can be used to clean before completing tests when you use several classes, for example, closing drivers, etc.
Below is a snippet of code for annotation @AfterSuitein TestNG for Selenium:

@AfterSuite
public void cleanUp() {
   System.out.println("All close up activities completed");
}

@BeforeGroups

TestNG can group tests together using the group attribute in annotations @Test. For example, if you want all the similar functions related to user management to be combined together, you can mark the tests, such as dashboard (user panel), profile (profile), transactions (transactions) and the like, in one group, such as user_management. The annotation @BeforeGroupsin TestNG helps to launch certain actions in front of the specified group of tests. This annotation can be used if the group focuses on one functionality, as indicated in the example above. The summary @BeforeGroupmay contain a login function that is required to run tests in a group, for example, testing a user panel, user profile, etc.

Usage example @BeforeGroups:

@BeforeGroups("urlValidation")
public void setUpSecurity() {
   System.out.println("url validation test starting");
}

@AfterGroups

This annotation is launched after all test methods of the specified group have been executed.

Sample code for annotation @AfterGroupsin TestNG for Selenium:

@AfterGroups("urlValidation")
public void tearDownSecurity() {
   System.out.println("url validation test finished");
}

Example

The code below shows examples of using all the annotations discussed above:

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.*;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import static org.testng.Assert.assertEquals;
public class AnnotationsTestNG {
   private WebDriver driver;
   private String url = "https://www.lambdatest.com/";
   @BeforeSuite
   public void setUp() {
       System.setProperty(
               "webdriver.chrome.driver",
               "С:\\selenium\\chromedriver.exe");
       driver = new ChromeDriver();
       driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
       System.out.println("The setup process is completed");
   }
   @BeforeTest
   public void profileSetup() {
       driver.manage().window().maximize();
       System.out.println("The profile setup process is completed");
   }
   @BeforeClass
   public void appSetup() {
       driver.get(url);
       System.out.println("The app setup process is completed");
   }
   @BeforeMethod
   public void checkLogin() {
       driver.get("https://accounts.lambdatest.com/login");
       driver.findElement(By.xpath("//input[@name='email']")).sendKeys("sadhvisingh24@gmail.com");
       driver.findElement(By.xpath("//input[@name='password']")).sendKeys("activa9049");
       driver.findElement(By.xpath("//*[@id='app']/section/form/div/div/button")).click();
       System.out.println("The login process on lamdatest is completed");
   }
   @Test(groups = "urlValidation")
   public void testCurrentUrl() throws InterruptedException {
       driver.findElement(By.xpath("//*[@id='app']/header/aside/ul/li[4]/a")).click();
       Thread.sleep(6000);
       String currentUrl = driver.getCurrentUrl();
       assertEquals(currentUrl, "https://automation.lambdatest.com/timeline/?viewType=build&page=1", "url did not matched");
       System.out.println("The url validation test is completed");
   }
   @AfterMethod
   public void screenShot() throws IOException {
       TakesScreenshot scr = ((TakesScreenshot) driver);
       File file1 = scr.getScreenshotAs(OutputType.FILE);
       FileUtils.copyFile(file1, new File("С:\\test-output\\test1.PNG"));
       System.out.println("Screenshot of the test is taken");
   }
   @AfterClass
   public void closeUp() {
       driver.close();
       System.out.println("The close_up process is completed");
   }
   @AfterTest
   public void reportReady() {
       System.out.println("Report is ready to be shared, with screenshots of tests");
   }
   @AfterSuite
   public void cleanUp() {
       System.out.println("All close up activities completed");
   }
   @BeforeGroups("urlValidation")
   public void setUpSecurity() {
       System.out.println("url validation test starting");
   }
   @AfterGroups("urlValidation")
   public void tearDownSecurity() {
       System.out.println("url validation test finished");
   }
}

TestNG Report:

Console output:

Translator Note:

to run the test, change the path to chromedriver.exe in the setUp () method, and the path to the screenshot folder in the screenShot () method. Also, for successful test execution, the checkLogin () method must have a valid username and password.
Used maven dependencies:
org.testngtestng6.14.3testorg.seleniumhq.seleniumselenium-chrome-driver3.141.59testcommons-iocommons-io2.6test

TestNG annotation sequence for Selenium The

annotations described above are run in runtime in the following order:

Beforesuite
Beforetest
Beforeclass
BeforeGroups
Beforemethod
Test
Aftermethod
Aftergroups
Afterclass
Aftertest
Aftersuite

Here is the order in which they are executed:

Attributes used with annotations in TestNG

Annotations in TestNG have attributes that you can use to configure them. They help set up the execution order of test methods.

These attributes are:

description : you can specify a description of the test method.
For example, @Test(description = ”this test checks the login”).
alwaysRun : this attribute ensures that the test method will always be executed, even if the tests on which it depends are dropped. When the attribute value is true, this method will always run.
For example, @Test(alwaysRun = true).
dataProvider : sets the name of the data provider for the test method. Suppose that you are going to run your tests in several browsers, then in the test method with the dataProvider attribute, you can add parameters for the browser and its version, which will be passed to the method by the data provider. In this case, the test containing this attribute will use this input to run the tests in multiple browsers.
For example, @Test(dataProvider = ”cross-browser-testing”).
dependsOnMethods : provides information about the order in which tests are run. A test with this attribute will be executed only if the test on which it depends is successful. If the test on which the method depends falls, then the test does not start.
For example, @Test(depenOnmethod = “login”).
groups : helps to group your test methods focused on one functionality into one group.
For example, @Test(groups = ”Payment_Module”).
This attribute also allows you to control which tests to run. When you run tests, you can ignore some groups or, conversely, run only some groups. All you need to do is specify the necessary groups in the TestNG.xml file. In the tag includeindicate the groups that need to be run, and in the tag excludethat should be ignored.
dependsOnGroups : performs the functions of the two above-mentioned attributes, that is, it determines the dependence of the test method on the specified group. This test method will be launched only after the specified group of tests is completed.
For example, @Test(depenOnMethods = "Payment_Module").
priority : helps us prioritize test methods. When TestNG runs the test methods, it can do it in random order. In a scenario where you want your tests to run in the correct order, you can use the priority attribute. The default priority for all test methods is 0. First, tests are run with a lower priority value.
For example, @Test(priority = 1), @Test(priority = 2). In this case, the test with priority equal to one will be executed first, and then the test with priority two.
enabled : this attribute is used when you need to ignore and not run a specific test. All you have to do is set it to false.
For example, @Test(enabled = false).
timeout : defines the time for which the test should be completed. If the test execution exceeds the time specified by the attribute, then the test will fail with an exception throwing org.testng.internal.thread.ThreadTimeoutException
For example, @Test(timeOut = 500). Please note that time is indicated in milliseconds .
invocationCount : works just like a loop. The test will run as many times as specified in invocationCount.
For example, @Test(invocationCount = 5) will be launched 5 times.
invocationTimeOut : used in conjunction with the above invocationCount attribute. The value of this attribute together with invocationCount indicates that the test will be run as many times as specified in invocationCount, and during the time specified in the invocationTimeOut attribute.
For example, @Test(invocationCount = 5, invocationTimeOut = 20).
expectedExceptions : Helps to handle exceptions that are expected to be thrown in the test method. If the exception specified in the attribute is thrown by the test method, then the test was successful. Otherwise, the absence of an exception or the throw of another exception not specified in the attribute will fail the test.
For example, @Test(expectedExceptions = {ArithmeticException.class}).

Above are the attributes used with annotations in TestNG with Selenium. The following is a code snippet demonstrating the use of the above attributes:

import static org.testng.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
public class AnnotationsTest {
   private WebDriver driver;
   private String url = "https://www.lambdatest.com/";
   @BeforeSuite
   public void setUp() {
       System.setProperty(
               "webdriver.chrome.driver",
               "С:\\selenium\\chromedriver.exe");
       driver = new ChromeDriver();
       System.out.println("The setup process is completed");
   }
   @BeforeTest
   public void profileSetup() {
       driver.manage().window().maximize();
       System.out.println("The profile setup process is completed");
   }
   @BeforeClass
   public void appSetup() {
       driver.get(url);
       System.out.println("The app setup process is completed");
   }
   @Test(priority = 2)
   public void checkLogin() {
       driver.get("https://accounts.lambdatest.com/login");
       driver.findElement(By.xpath("//input[@name='email']")).sendKeys("sadhvisingh24@gmail.com");
       driver.findElement(By.xpath("//input[@name='password']")).sendKeys("xxxxx");
       driver.findElement(By.xpath("//*[@id='app']/section/form/div/div/button")).click();
       System.out.println("The login process on lamdatest is completed");
   }
   @Test(priority = 0, description = "this test validates the sign-up test")
   public void signUp() throws InterruptedException {
       WebElement link = driver.findElement(By.xpath("//a[text()='Free Sign Up']"));
       link.click();
       WebElement organization = driver.findElement(By.xpath("//input[@name='organization_name']"));
       organization.sendKeys("LambdaTest");
       WebElement firstName = driver.findElement(By.xpath("//input[@name='name']"));
       firstName.sendKeys("Test");
       WebElement email = driver.findElement(By.xpath("//input[@name='email']"));
       email.sendKeys("User622@gmail.com");
       WebElement password = driver.findElement(By.xpath("//input[@name='password']"));
       password.sendKeys("TestUser123");
       WebElement phoneNumber = driver.findElement(By.xpath("//input[@name='phone']"));
       phoneNumber.sendKeys("9412262090");
       WebElement termsOfService = driver.findElement(By.xpath("//input[@name='terms_of_service']"));
       termsOfService.click();
       WebElement button = driver.findElement(By.xpath("//button[text()='Signup']"));
       button.click();
   }
   @Test(priority = 3,
           alwaysRun = true,
           dependsOnMethods = "check_login",
           description = "this test validates the URL post logging in",
           groups = "url_validation")
   public void testCurrentUrl() throws InterruptedException {
       driver.findElement(By.xpath("//*[@id='app']/header/aside/ul/li[4]/a")).click();
       String currentUrl = driver.getCurrentUrl();
       assertEquals(
               currentUrl,
               "https://automation.lambdatest.com/timeline/?viewType=build&page=1",
               "url did not matched");
       System.out.println("The url validation test is completed");
   }
   @Test(priority = 1,
           description = "this test validates the logout functionality",
           timeOut = 25000)
   public void logout() throws InterruptedException {
       Thread.sleep(6500);
       driver.findElement(By.xpath("//*[@id='userName']")).click();
       driver.findElement(By.xpath("//*[@id='navbarSupportedContent']/ul[2]/li/div/a[5]")).click();
   }
   @Test(enabled = false)
   public void skipMethod() {
       System.out.println("this method will be skipped from the test run using the attribute enabled=false");
   }
   @Test(priority = 6, invocationCount = 5, invocationTimeOut = 20)
   public void invocationcountShowCaseMethod() {
       System.out.println("this method will be executed by 5 times");
   }
   @AfterMethod()
   public void screenshot() throws IOException {
       TakesScreenshot scr = ((TakesScreenshot) driver);
       File file1 = scr.getScreenshotAs(OutputType.FILE);
       FileUtils.copyFile(file1, new File("С:\\test-output\\test1.PNG"));
       System.out.println("Screenshot of the test is taken");
   }
   @AfterClass
   public void closeUp() {
       driver.close();
       System.out.println("The close_up process is completed");
   }
   @AfterTest
   public void reportReady() {
       System.out.println("Report is ready to be shared, with screenshots of tests");
   }
   @AfterSuite
   public void cleanUp() {
       System.out.println("All close up activities completed");
   }
   @BeforeGroups("urlValidation")
   public void setUpSecurity() {
       System.out.println("url validation test starting");
   }
   @AfterGroups("urlValidation")
   public void tearDownSecurity() {
       System.out.println("url validation test finished");
   }
}

Output to the console:

TestNG report:

Additional annotations in TestNG

There are several more useful annotations that will help us achieve our goals.

@DataProvider

A method with this annotation is used to provide data to a test method in which the dataProvider attribute is set. This method helps in creating data-driven tests into which multiple sets of input values can be passed. The method should return a two-dimensional array or object.

An annotation @DataProviderhas two attributes:

name - this attribute is used to indicate the name of the data provider. If not specified, then the default method name is used.
parallel - this attribute allows you to run tests in parallel with different data. Having this attribute is one of TestNG's advantages over Junit. The default is false.

The example below shows the use of annotation @DataProviderwith the given name and parallel attributes.

@DataProvider(name = "SetEnvironment", parallel = true)
public Object[][] getData() {
   Object[][] browserProperty = new Object[][]{
           {Platform.WIN8, "chrome", "70.0"},
           {Platform.WIN8, "chrome", "71.0"}
   };
   return browserProperty;
}

@Factory

This annotation helps to run multiple test classes through one test class. Simply put, it defines and creates tests dynamically.

The code snippet below shows the use of annotation @Factory, which helps to call test class methods.

import org.testng.annotations.Test;
import org.testng.annotations.Factory;
class FactorySimplyTest1 {
   @Test
   public void testMethod1() {
       System.out.println("This is to test for method 1 for Factor Annotation");
   }
}
class FactorySimpleTest2 {
   @Test
   public void testMethod2() {
       System.out.println("This is to test for method 2 for Factor Annotation");
   }
}
public class FactoryAnnotation {
   @Factory()
   @Test
   public Object[] getTestFactoryMethod() {
       Object[] factoryTest = new Object[2];
       factoryTest[0] = new FactorySimplyTest1();
       factoryTest[1] = new FactorySimpleTest2();
       return factoryTest;
   }
}

Console Output:

@Parameters

This annotation allows you to pass parameters to your tests through the TestNG.xml file. This is useful when you need to transfer a limited amount of data to your tests. For complex and large data sets, it is better to use annotation @DataProvideror Excel.

Usage example:

@Parameters({"username", "password"})
@Test()
public void checkLogin(String username, String password) {
   driver.get("https://accounts.lambdatest.com/login");
   driver.findElement(By.xpath("//input[@name='email']")).sendKeys(username);
   driver.findElement(By.xpath("//input[@name='password']")).sendKeys(password);
   driver.findElement(By.xpath("//*[@id='app']/section/form/div/div/button")).click();
   System.out.println("The login process on lamdatest is completed");
}

In the TestNG.xml file, parameters are defined as follows:

@Listener

This annotation helps with logging and reporting. There are several Listener:

IExecutionListener
IAnnotationTransformer
ISuiteListener
ITestListener

But we will leave the description of these listeners and their use for another article.

That's all!

The key point to consider when working with all of these annotations and attributes is that you need to use Java version 1.5 or higher, since annotations are not supported in earlier versions of java.

All of the above annotations and TestNG attributes help improve code structure and readability. This helps to provide detailed reports, which makes status reports easier and more useful. The use of these annotations in TestNG for Selenium is entirely up to your business requirements. Therefore, choosing the right annotations and using them correctly is important. You can try these annotations in TestNG on the LambdaTest Selenium Grid right now!

Those who have read to the end are invited to a free open webinar , which will be held on May 14 by our teacher, Dmitry Eremin . Well, according to the established tradition, we are waiting for your comments, friends.

Tags:

TestNG Annotation Guide for Selenium WebDriver

Also popular now: