testng

Question 1

TestNG

Answer 1

an easy-to-use testing framework written in Java, designed for unit, functional, and end-to-end integration tests providing many functionalities. Many plugins are integrated with TestNG.

Question 2

Writing tests with TestNG is very simple

Answer 2

Write the business logic inside a method. Then annotate the method with @Test.

Question 3

testng.xml

Answer 3

a file that contains the test configuration, and it allows us to organize test classes and define test suites and tests.

Question 4

testng essential dependencies

Answer 4

import org.testng.Assert;

import org.testng.annotations.Test;

Question 5

Java - XML Connection in TESTNG

Answer 5

package com.example.tests;
import org.testng.Assert;
import org.testng.annotations.Test;
public class TestClass {
    @Test // is an annotation to indicate this is a test method
    public void testA() {
        Assert.assertTrue(true); 
    }
}

Question 6

Testng documentation:

Answer 6

https://testng.org/doc/documentation-main.html

Question 7

TestNG supports annotations:

Answer 7

@Test annotated method is considered as a test method …at class level as well. When given at test method level, the one at method level will take precedence. A test method can be disabled by setting @Test(enabled = false).
@BeforeSuite annotated method will run once per test suite before all the tests.
@AfterSuite annotated method will run once per test suite after all the tests.
@BeforeTest annotated method will run once per test before all the test methods.
@AfterTest annotated method will run once per test after all the test methods.
@BeforeClass annotated method will run once per every test class instance before all the test methods.
@AfterClass annotated method will run once per every test class instance after all the test methods.
@BeforeMethod annotated method will run once per every test method instance before all the test methods.
@AfterMethod annotated method will run once per every test method instance after all the test methods.
@BeforeGroup will run once per every test method instance before all the test methods that belong to the given group.
@AfterGroup will run once per every test method instance after all the test methods that belong to the given group.
@Parameter annotation on test method is to pass parameters to test methods.
@DataProvider to create test methods or test classes at runtime with different parameters. TestNG will create multiple test methods at runtime. It can also be added to the test class constructor in conjunction with @Factory to pass parameters to create test class instances at runtime.
@Factory used on a method that returns instances of test classes or on a test class constructor with @DataProvider.
@Listeners is used at test class level to takes the array of classes that implements a plethora of implementations of ITestNGListener like IAlterSuiteListener, IAnnotationTransformer, IMethodInterceptor, IReporter, etc. for different purposes.

Question 8

order for the execution of annotated methods:

Answer 8

@BeforeSuite
    @BeforeTest
    @BeforeClass
    @BeforeMethod
    @Test
    @AfterMethod
    @AfterClass
    @AfterTest
    @AfterSuite

Question 9

How to control parallelism?

Answer 9

Parallelism and thread count can be set at suite level or test level like below.

Question 10

Types of parallelism

Answer 10

methods: run test methods in parallel in different threads. All dependent methods will be run in different threads, respecting the priority of tests.
tests: run tags in parallel in separate threads.
classes: run test classes in parallel in separate threads, but test methods in those test classes will run in the same thread.
instances: run instances of test methods/classes in parallel in different threads.

Question 11

What is the grouping of tests?

Answer 11

TestNG allows to group related tests using tags. TestNG allows having configuration methods that can run before starting or ending of tests belonging to a group.

Question 12

How to group tests?

Answer 12

Each test can belong to one or more groups. This grouping can be done to test methods or test classes. When giving at both places, the one given at the test method takes precedence. This becomes Partial test grouping, as all the test methods in the class belong to a group, and this method belongs to another.

Question 13

Parameterisation

Answer 13

Tests can be parameterized using @Parameter. They can be passed from testng.xml. Parameters can be set at suite level or test level. The same parameter can be overridden at the test level as well.

Question 14

To use parameter in the test method

Question 15

To use parameter in the test method

Answer 15

@Parameters(“browser”)
@Test
public void testMethod(String browser) {}

@Parameters(“browser”)
@BeforeMethod
public void initMethod(String browser) {}

Question 16

@DataProvider

Answer 16

for running a test case multiple times by passing different sets of parameters.

Question 17

Creating @DataProvider method

Answer 17

@DataProvider( name = “createData” )
public Object[][] createTestData() {

Object[][] data = new Object[2][2];
data[0] = new Object[] { "Sam", 21 };
data[1] = new Object[] { "Smith", 22 };

return data; }

Question 18

If the @DataProvider is not present in the same class than the test method:

Answer 18

public class DataProviderFactory {
    @DataProvider( name = "createData" )
    public static Iterator createTestData() {
        return list.iterator();
    }
}
public class TestClass {
    @Test(dataProvider = "createData", dataProviderClass = DataProviderFactory.class)
    public void testMethod(String name, int age) {        
    }
}

Question 19

to ensure the order and type of the parameters list that is given as an argument to the test method.

Answer 19

//If the test method and data provider are in the same class.
@Test(dataProvider = "createData") 
public void testMethod(String name, int age) {}

//If the test method and data provider are in different classes
@Test(dataProvider = "createData", dataProviderClass = MyDataProviderClass.class) 
public void testMethod(String name, int age) {}

Question 20

@Factory

Answer 20

creating test classes at runtime.

Question 21

a @Factory method that creates two instances of the test class

Answer 21

public class TestClass {
    private String browser;
    public TestClass(String browser) {
        this.browser = browser;
    }
    @Test
    public void testMethod() {
    }
    @Factory
    public Object[] createTestClasses() {
        Object[] data = new Object[2];
        data[0] = new TestClass("chrome");
        data[1] = new TestClass("firefox");
        return data;
    }
}

Question 22

The default constructor is required when the data provider method is not static.

Answer 22

public class TestClass {
    private String browser;
    public TestClass() {
    }
    @Factory(dataProvider = "data")
    public TestClass(String browser) {
        this.browser = browser;
    }
    @Test
    public void testMethod() {
    }
    @DataProvider
    public Iterator data() {
        List arr = new ArrayList<>();
        arr.add(new Object[] { "firefox" });
        arr.add(new Object[] { "chrome" });
        return arr.iterator();
    }
}

Question 23

if the @DataProvider annotated method is not present in the same class

Answer 23

we need to provide @Factory(dataProviderClass = DataProviderFactory.class, dataProvider = “createData”), and the @DataProvider annotated method needs to be public static.

Question 24

TestNG listeners

Answer 24

several interfaces that allow us to change the behavior of TestNG at runtime

Question 25

Programmatically re-running failed tests

Answer 25

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;
public class SampleRetryAnalyzer implements IRetryAnalyzer {
  private int retryCount = 0;
  private static final int maxRetryCount = 2;
  @Override
  public boolean retry(ITestResult result) {
    if (retryCount < maxRetryCount) {
      retryCount++;
      return true;
    }
    return false;
  }
}

Question 26

To avoid adding @Test(retryAnalyzer = SampleRetryAnalyzer.class) to every test method.

Answer 26

public class RetryListener implements IAnnotationTransformer {
    public void transform( ITestAnnotation annotation, Class testClass, Constructor testConstructor, Method testMethod ) {
        annotation.setRetryAnalyzer(SampleRetryAnalyzer.class);
    }
}
//testng.xml

Question 27

Writing Custom Annotations

Answer 27

create custom annotations and use them using TestNG configurations methods to make annotations more customizable per your needs.

Question 28

Example of custom annotation

Answer 28

create a single @DataProvider method that reads from different files with a file to read given in a test method.