Selenium
Selenium vs HP UFT (QTP): What's the Difference?
In this tutorial, we are going to compare to very popular automation tools -Selenium and QTP....
TestNG is an automation testing framework in which NG stands for "Next Generation". TestNG is inspired from JUnit which uses the annotations (@). TestNG overcomes the disadvantages of JUnit and is designed to make end-to-end testing easy.
Using TestNG, you can generate a proper report, and you can easily come to know how many test cases are passed, failed, and skipped. You can execute the failed test cases separately.
For example:
Beside above concept, you will learn more on TestNG, like what are the Advantages of TestNG, how to create test methods using @test annotations, how to convert these classes into testing suite file and execute through the eclipse as well as from the command line.
In this TestNG tutorial, you will learn
Default Selenium tests do not generate a proper format for the test results. Using TestNG in Selenium, we can generate test results.
Most Selenium users use this more than Junit because of its advantages. There are so many features of TestNG, but we will only focus on the most important ones that we can use in Selenium. Following are the key features of Selenium TestNG:
There are three major advantages of TestNG over JUnit:
Annotations in TestNG are lines of code that can control how the method below them will be executed. They are always preceded by the @ symbol. A very early and quick TestNG Example is the one shown below.
Annotations will be discussed later in the section named "Annotations used in TestNG,"so it is perfectly ok if you do not understand the above TestNG Example just yet. It is just important to note for now that annotations in TestNG are easier to code and understand than in JUnit.
The ability to run tests in parallel is available in TestNG but not in JUnit, so the TestNG framework is more preferred of testers using Selenium Grid.
Now, we will learn how to create our first test case using TestNG Annotations in Selenium:
Before we create a test case, we should first setup a new TestNG Project in Eclipse and name it as "FirstTestNGProject".
Step 1: Click File > New > Java Project
Step 2: Type "FirstTestNGProject" as the Project Name then click Next.
Step 3: We will now start to import the TestNG Libraries onto our project. Click on the "Libraries" tab, and then "Add Library…"
Step 4: On the Add Library dialog, choose "TestNG" and click Next.
Step 5: Click Finish.
You should notice that TestNG is included on the Libraries list.
Step 6: We will now add the JAR files that contain the Selenium API. These files are found in the Java client driver that we downloaded from http://docs.seleniumhq.org/download/ when we were installing Selenium and Eclipse in the previous chapters.
Then, navigate to where you have placed the Selenium JAR files.
After adding the external JARs, your screen should look like this.
Step 7: Click Finish and verify that our FirstTestNGProject is visible on Eclipse's Package Explorer window.
Now that we are done setting up our project in this TestNG tutorial, let us create a new TestNG file.
Step 1: Right-click on the "src" package folder then choose New > Other…
Step 2: Click on the TestNG folder and select the "TestNG class" option. Click Next.
Step 3: Type the values indicated below on the appropriate input boxes and click Finish. Notice that we have named our Java file as "FirstTestNGFile".
Eclipse should automatically create the template for our TestNG file shown below.
Let us now create our first Test Case that will check if Mercury Tours' homepage is correct. Type your code as shown in the below TestNG Example:
package firsttestngpackage; import org.openqa.selenium.*; import org.openqa.selenium.firefox.FirefoxDriver; import org.testng.Assert; import org.testng.annotations.*; public class firsttestngfile { public String baseUrl = "http://demo.guru99.com/test/newtours/"; String driverPath = "C:\\geckodriver.exe"; public WebDriver driver ; @Test public void verifyHomepageTitle() { System.out.println("launching firefox browser"); System.setProperty("webdriver.gecko.driver", driverPath); driver = new FirefoxDriver(); driver.get(baseUrl); String expectedTitle = "Welcome: Mercury Tours"; String actualTitle = driver.getTitle(); Assert.assertEquals(actualTitle, expectedTitle); driver.close(); } }
Notice the following.
You may have multiple test cases (therefore, multiple @Test annotations) in a single TestNG file. This will be tackled in more detail later in the section "Annotations used in TestNG."
To run the test, simply run the file in Eclipse as you normally do. Eclipse will provide two outputs – one in the Console window and the other on the TestNG Results window.
The Console window in Eclipse gives a text-based report of our test case results while the TestNG Results window gives us a graphical one.
TestNG has the ability to generate reports in HTML format.
Step 1: After running our FirstTestNGFile that we created in the previous section, right-click the project name (FirstTestNGProject) in the Project Explorer window then click on the "Refresh" option.
Step 2: Notice that a "test-output" folder was created. Expand it and look for an index.html file. This HTML file is a report of the results of the most recent test run.
Step 3: Double-click on that index.html file to open it within Eclipse's built-in web browser. You can refresh this page any time after you rerun your test by simply pressing F5 just like in ordinary web browsers.
In the previous section, you have been introduced to the @Test annotation. Now, we shall be studying more advanced annotations and their usages.
We can use multiple @Test annotations in a single TestNG file. By default, methods annotated by @Test are executed alphabetically. See the code below. Though the methods c_test, a_test, and b_test are not arranged alphabetically in the code, they will be executed as such.
Run this code and on the generated index.html page, click "Chronological view."
If you want the methods to be executed in a different order, use the parameter "priority". Parameters are keywords that modify the annotation's function.
TestNG will execute the @Test annotation with the lowest priority value up to the largest. There is no need for your priority values to be consecutive.
The TestNG HTML report will confirm that the methods were executed based on the ascending value of priority.
Aside from "priority," @Test has another parameter called "alwaysRun" which can only be set to either "true" or "false." To use two or more parameters in a single annotation, separate them with a comma such as the one shown below.
@Test(priority = 0, alwaysRun = true)
@BeforeTest and @AfterTest
@BeforeTest | methods under this annotation will be executed prior to the first test case in the TestNG file. |
@AfterTest | methods under this annotation will be executed after all test cases in the TestNG file are executed. |
Consider the code below.
package firsttestngpackage; import org.openqa.selenium.*; import org.openqa.selenium.firefox.FirefoxDriver; import org.testng.Assert; import org.testng.annotations.*; public class firsttestngfile { public String baseUrl = "http://demo.guru99.com/test/newtours/"; String driverPath = "C:\\geckodriver.exe"; public WebDriver driver ; @BeforeTest public void launchBrowser() { System.out.println("launching firefox browser"); System.setProperty("webdriver.gecko.driver", driverPath); driver = new FirefoxDriver(); driver.get(baseUrl); } @Test public void verifyHomepageTitle() { String expectedTitle = "Welcome: Mercury Tours"; String actualTitle = driver.getTitle(); Assert.assertEquals(actualTitle, expectedTitle); } @AfterTest public void terminateBrowser(){ driver.close(); } }
Applying the logic presented by the table and the code above, we can predict that the sequence by which methods will be executed is:
The placement of the annotation blocks can be interchanged without affecting the chronological order by which they will be executed. Let's understand with a TestNG Example and try to rearrange the annotation blocks such that your code would look similar to the one below.
package firsttestngpackage; import org.openqa.selenium.*; import org.openqa.selenium.firefox.FirefoxDriver; import org.testng.Assert; import org.testng.annotations.*; public class firsttestngfile { public String baseUrl = "http://demo.guru99.com/test/newtours/"; String driverPath = "C:\\geckodriver.exe"; public WebDriver driver ; @AfterTest //Jumbled public void terminateBrowser(){ driver.close(); } @BeforeTest //Jumbled public void launchBrowser() { System.out.println("launching firefox browser"); System.setProperty("webdriver.gecko.driver", driverPath); driver = new FirefoxDriver(); driver.get(baseUrl); } @Test //Jumbled public void verifyHomepageTitle() { String expectedTitle = "Welcome: Mercury Tours"; String actualTitle = driver.getTitle(); Assert.assertEquals(actualTitle, expectedTitle); } }
Run the code above and notice that
@BeforeMethod and @AfterMethod
@BeforeMethod | methods under this annotation will be executed prior to each method in each test case. |
@AfterMethod | methods under this annotation will be executed after each method in each test case. |
In Mercury Tours, suppose we like to verify the titles of the target pages of the two links below.
The flow of our test would be:
The code below illustrates how @BeforeMethod and @AfterMethod are used to efficiently execute the scenario mentioned above.
package firsttestngpackage; import org.openqa.selenium.*; import org.openqa.selenium.firefox.FirefoxDriver; import org.testng.Assert; import org.testng.annotations.*; @Test public class firsttestngfile { public String baseUrl = "http://demo.guru99.com/test/newtours/"; String driverPath = "C:\\geckodriver.exe"; public WebDriver driver; public String expected = null; public String actual = null; @BeforeTest public void launchBrowser() { System.out.println("launching firefox browser"); System.setProperty("webdriver.gecko.driver", driverPath); driver= new FirefoxDriver(); driver.get(baseUrl); } @BeforeMethod public void verifyHomepageTitle() { String expectedTitle = "Welcome: Mercury Tours"; String actualTitle = driver.getTitle(); Assert.assertEquals(actualTitle, expectedTitle); } @Test(priority = 0) public void register(){ driver.findElement(By.linkText("REGISTER")).click() ; expected = "Register: Mercury Tours"; actual = driver.getTitle(); Assert.assertEquals(actual, expected); } @Test(priority = 1) public void support() { driver.findElement(By.linkText("SUPPORT")).click() ; expected = "Under Construction: Mercury Tours"; actual = driver.getTitle(); Assert.assertEquals(actual, expected); } @AfterMethod public void goBackToHomepage ( ) { driver.findElement(By.linkText("Home")).click() ; } @AfterTest public void terminateBrowser(){ driver.close(); } }
After executing this test, your TestNG should report the following sequence.
Simply put, @BeforeMethod should contain methods that you need to run before each test case while @AfterMethod should contain methods that you need to run after each test case.
@BeforeSuite: The annotated method will be run before all tests in this suite have run.
@AfterSuite: The annotated method will be run after all tests in this suite have run.
@BeforeTest: The annotated method will be run before any test method belonging to the classes inside the tag is run.
@AfterTest: The annotated method will be run after all the test methods belonging to the classes inside the tag have run.
@BeforeGroups: The list of groups that this configuration method will run before. This method is guaranteed to run shortly before the first test method that belongs to any of these groups is invoked.
@AfterGroups: The list of groups that this configuration method will run after. This method is guaranteed to run shortly after the last test method that belongs to any of these groups is invoked.
@BeforeClass: The annotated method will be run before the first test method in the current class is invoked.
@AfterClass: The annotated method will be run after all the test methods in the current class have been run.
@BeforeMethod: The annotated method will be run before each test method.
@AfterMethod: The annotated method will be run after each test method.
@Test: The annotated method is a part of a test case
In this tutorial, we are going to compare to very popular automation tools -Selenium and QTP....
Project Summary This project will put you in an online Corporate Test Environment. You will be...
In this tutorial, you will learn- Create a Selenium Project Convert and Execute Selenium Project to...
If a simple XPath is not able to find a complicated web element for our test script, we need to...
Project Summary This project will put you in an Online Corporate Test Environment. You will be...
What is a Scrollbar? A Scrollbar is a lets you move around screen in horizontal or vertical...