Introduction to TestNG
TestNG Is Open Source
(Freeware) testing framework which Is inspired by JUnit and NUnit with
Introducing a few new features and functionality compared to NUnit and JUnit to
make It easy to use and more powerful.
We can use TestNg with
selenium web-driver to configure and run our automation test cases very easily,
easy to understand, and to generate different test reports like HTML or XSLT.
Some Major Features of TestNG
รผ Support of @DataProvider
annotation to perform data-driven testing,
รผ To set test case
execution dependency.
รผ Separates compile-time
test code from run-time configuration/data info.
รผ Flexible runtime
configuration
รผ Test case grouping
รผ To generate HTML and
XSLT test execution report.
Difference between TestNG and Junit
Few of the major difference
between Junit and TestNG are:
JUnit
|
TestNG
|
Parameter
configuration is very tuff
|
Parameter
configuration is very easy.
|
JUnit
does not support group test.
|
TestNG
support group test
@Test(group
={sanity})
|
These
are not supportable.
|
TestNG
support
@BeforeTest,
@AfterTest,
@BeforeSuite,
@AfterSuite,
@BeforeGroups,
@AfterGroups
which
are not supported in JUnit.
|
Test
prioritizing and parallel testing is not possible
|
In
testNG test priority is possible using @Test(priority = 1)
Parallel
test case is also possible by calling the multiple test in a <suite>
<test>
…..
<\test>
|
Different
annotations supported by TestNG
TestNG supports many
different annotations to configure the Selenium WebDriver test.
@Test
@Test annotation
describes the method as a test method or part of your test.
@Test (Priority = 1)
@ to the priority of the
function
@Test(group = {“smoke”})
@ set the method name
with a group, when testNG will run “smoke” group only those methods will run
which are only belongs to the “smoke” group.
@Parameters
When you want to pass
parameters in your test methods, you need to use @Parameters annotation.
In the .xml file
(<parameter name="browser" value="FFX" />
In the class, use just above the methods @Test @Parameters
({"browser"})
@BeforeMethod
Any method which is
marked with @BeforeMethod annotation will be executed before each and every
@test annotated method.
@AfterMethod
Same as @BeforeMethod,
If any method is annotated with @AfterMethod annotation then it will be
executed after execution of each and every @test annotated method.
@BeforeClass
A method annotated using
@BeforeClass will be executed before the first @Test method execution.
@BeforeClass annotated method will be executed once only per class so don't be
confused.
@AfterClass
Same as @BeforeClass, A method annotated with @AfterClass annotation will be executed once only per
class after the execution of all @Test annotated methods of that class.
@BeforeTest
@BeforeTest annotated
method will be executed before any @Test annotated method of those classes
which are inside <test> tag in the testng.xml file.
@AfterTest
@AfterTest annotated
method will be executed when all @Test annotated methods complete its execution
of those classes which are inside <test> tag in the testng.xml file.
@BeforeSuite
A method marked with
@BeforeSuite annotation will run before all suites from the test.
@AfterSuite
@AfterSuite annotated
method will start running when the execution of all tests executed from the
current test suite.
@DataProvider
When you use
@DataProvider annotation for any method that means you are using that method as
a data supplier. Configuration of @DataProvider annotated method must be as it
always returns Object[][] which we can use in @Test annotated method.
@BeforeGroups
@BeforeGroups annotated
method will run before the first test run of that specific group.
@AfterGroups
@AfterGroups annotated
method will run after all test methods of that group completes its execution.
@Factory
When you want to execute
a specific group of test cases with different values, you need to use @Factory
annotation. An array of class objects is returned by @Factory annotated method
and those TestNG will those objects as test classes.
@Listeners
@Listeners are used to
with test class. It is helpful for logging purposes.
Usage
of TestNG.xml file
In selenium WebDriver,
we are using a testng.xml file to configure the whole test suite in a single
file.
A few of the tasks which
we can specify in the testng.xml file are as below.
รผ To define a test suite
using a set of test cases to run them from a single place.
รผ To Include or exclude
test methods from test execution.
รผ To specify a group to
include or exclude.
รผ To pass a parameter to
use in the test case.
รผ To specify grouping
dependencies.
รผ To configure and execute
parallel test execution.
รผ To define listeners.
TestNG Assertions
Soft Assert: Soft Assert collects errors during @Test Soft Assert does not
throw an exception when an assert fails and would continue with the next step
after the assert statement
Hard
Assert: Hard Assert throws an AssertException immediately when an
assert statement fails and the test suite continues with next @Test.
Let's look into both of these assertions into more detail.
Hard Assertions
in TestNG
There are many different
assertions available. But in this article, I am going to discuss only the major
once.
assertEquals:
This assertion is useful to compare expected and actual values
in selenium webdriver. If both values match then it's fine and will continue
execution. But if fails then immediately it will mark that specific test method
as fail and exit from that test method.
Assert.assertEquals(actual,
expected);
Assert.assertEquals(Actualtext,
"Tuesday, 28 January 2014");
assertNotEquals :
Its function is opposite to assertEquals assertion. Means if
both sides values will not match then this assertion will pass else it will
fail
Assert.assertNotEquals(actual,
expected, message)
Assert.assertNotEquals(Actualtext,
"Tuesday, 28 January 2014", "Expected and actual match in
assertion_method_1");
assertTrue:
assertTrue assertion is generally used for Boolean
condition true. It will pass if the condition returns "true". If it
will return false then it will fail and skip test execution from that specific
method.
assertTrue(condition)
Assert.assertTrue(driver.findelement(By.id(“
”)).isSelected());
assertFalse:
It will check the boolean value returned by condition and will pass
if the returned value is "False". If the returned value is pass then this assertion
will fail and skip execution from the current test method.
Assert.assertFalse(condition)
Assert.assertFalse(driver.findelement(By.id(“
”)).isSelected());
assertNull
assertNull(object)
assertion will check and verify that the object is null. It will pass if the
object found null. If the object found not null then it will return an error
message like "java.lang.AssertionError: expected [null] but found
[true]". Whenever your assertion fails, it will mark that specific test
method as fail in TestNG result.
assertNull(object)
txt1 =
driver.findElement(By.xpath("//input[@id='text1']"));
Assert.assertNull(txt1.getAttribute("disabled"));
assertNotNull:
assertNotNull assertion is designed to check and verify that
values returned by the object are not null. Means it will be pass if the
returned value is not null.
assertNotNull(object)
txt1 =
driver.findElement(By.xpath("//input[@id='text1']"));
Assert.assertNotNull(txt1.getAttribute("disabled"));
TestNG
Soft Assertions
Using TestNG soft
assertion, we can continue our test execution even if the assertion fails that
means on the failure of soft assertion, the remaining part of the @Test method
will be executed, and an assertion failure will be reported at the end of @Test
method.
To use TestNG soft
assertion, you have to use the TestNG SoftAssert class. This class will help to
not throw an exception on assertion failure and recording failure.
If we will use soft
assertion then our test execution will remain to continue even If any assertion
fails. Another important thing Is our assertion failure will be reported in the
report so that we can view It at the end of the test.
We can use soft assertion
when we are using multiple assertions In the same test method and you want to
execute all of them even If anyone In between fails.
//Created object of TestNG SoftAssert class to use Its Properties.
SoftAssert s_assert =
new SoftAssert();
//Text on the expected side
Is written Incorrect intentionally to get fail this assertion.
Assert.assertEquals(Actualtext,
"Tuesday, 01 January 2014", "1st assert failed.");
System.out.println("Hard
Assertion -> 1st pagetext assertion executed."
//Text on the expected side
Is written Incorrect intentionally to get fail this assertion.
s_assert.assertEquals(Actualtext,
"Tuesday, 01 January 2014", "1st assert failed.");
System.out.println("Soft
Assertion -> 1st pagetext assertion executed.");
