Delve into designing a test automation framework using Java and Selenium. Learn about Selenium basics, TestNG, build management, logging, and reporting to automate web applications effectively.

ui-test.tar.gz

Java

TestNG

Bash

ui-test

ui-test-1

ui-test-frmk

ui-frmk

Testing the user interface for any application is generally time-consuming when done for each new release. UI test automation is the most common and effective way to simulate the actual user journey and business use-cases for any application.
In this course, you will learn how to design a test automation framework from scratch for automating any web-based application using Java, Selenium, and TestNG. You’ll start by learning the basics of Selenium and TestNG and then move on to learn about build management, logging, and reporting, which are key learnings for any QA engineer or developer. By the end of this course, you will have successfully created a UI test automation framework.

Design a Test Automation Framework with Selenium and Java


# `@Parameters`

Tests can be parameterized using `@Parameter`. They can be passed from ***testng.xml***. Parameters can be set at `suite` level or `test` level.

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="Sample Test Suite">
    <parameter name="browser" value="chrome" />
    <test name="Sample Test">
        <parameter name="browser" value="chrome" />
    </test>
</suite>
```

Here in the above ***testng.xml***, we set the parameter **browser** to **chrome** at the test suite level. The same parameter can be overridden at the test level as well, as shown.

To use parameter in the test method, follow the following approach.

```java
@Parameters("browser")
@Test
public void testMethod(String browser) {

}
```

For configuration methods like `@BeforeXXX` and `@AfterXXX`, follow the following approach.

```java
@Parameters("browser")
@BeforeMethod
public void initMethod(String browser) {

}
```
---------------------------

# `@DataProvider`

`@DataProvider` is for running a test case multiple times by passing different sets of parameters.

## Creating `@DataProvider` method

`@DataProvider` can be created like either of two ways given below:

```java
@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;
}
```

```java
@DataProvider( name = "createData" )
public Iterator<Object[]> createTestData() {

    List<Object[]> data = new ArrayList<Object[]>();
    data.add(new Object[] { "Sam", 21 });
    data.add(new Object[] { "Smith", 22 });

    return data.iterator();
}
```

In the above code snippet, we are creating 
a data set for 2 test runs. In the first run, the test method with 2 parameters - `String` and `int`, will be injected with *"Sam"* and *21* respectively. Likewise, during the second run, values *"Smith"* and *22* will be passed. 

When a `name` attribute is not provided for a `@DataProvider` annotated method, by default, the name of the method is taken.

In addition, the return type of a `@DataProvider` can be custom data types also like `CustomClass[]` or `Iterator<CustomClass>`

By default, the `@DataProvider` will be looked upon in the same class as the test method. If the `@DataProvider` is present elsewhere, the method needs to be declared `public static`. The following code snippet explains this.

```java
public class DataProviderFactory {

	@DataProvider( name = "createData" )
	public static Iterator<Object[]> createTestData() {

		List<Object[]> list = new ArrayList<Object[]>();
		list.add(new Object[] { "Sam", 21 });
		list.add(new Object[] { "Smith", 22 });

		return list.iterator();
	}

}
```

```java
public class TestClass {

	@Test(dataProvider = "createData", dataProviderClass = DataProviderFactory.class)
	public void testMethod(String name, int age) {
		
	}
}

```


## Using `@DataProvider` in test method

When using `@DataProvider`, we should ensure the order and type of the parameters list that is given as an argument to the test method.


If the test method and data provider are in the same class.

```java
@Test(dataProvider = "createData") 
public void testMethod(String name, int age) {
}
```

If the test method and data provider are in different classes, use:

```java
@Test(dataProvider = "createData", dataProviderClass = MyDataProviderClass.class) 
public void testMethod(String name, int age) {
}
```

`@DataProvider` tests can be made to run in parallel by setting `@DataProvider(parallel = true)` and thread count can be controlled from ***testng.xml*** using property `data-provider-thread-count="10"`.

```
<suite name="Sample Test Suite" parallel="tests" thread-count="5" data-provider-thread-count="10">

```

------------------------

# `@Factory`

`@Factory` is for creating test classes at runtime. 

```java
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;
	}

}
```

In the above code snippet, we are creating a `@Factory` method that creates two instances of the test class with parameters - for the first run with *"chrome"* and for the second run with *"firefox"*

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

```java
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<Object[]> data() {

		List<Object[]> arr = new ArrayList<>();
		arr.add(new Object[] { "firefox" });
		arr.add(new Object[] { "chrome" });
		return arr.iterator();
	}

}
```

As we know already, if the `@DataProvider` annotated method is not present in the same class, we need to provide `@Factory(dataProviderClass = DataProviderFactory.class, dataProvider = "createData")`, and the `@DataProvider` annotated method needs to be `public static`.

---

Now that you are familiar with the details related to the major annotations, in the next lesson, you will learn about the use of different listeners.


This lesson explains in detail how to parameterize a test and use @Parameter, @DataProvider and @Factory annotations effectively for testing purposes.

Introduction to UI Test Automation

Selenium WebDriver Basics

TestNG Framework

Build Management

Configuration Management

Logging

Reporting

Designing the UI Test Automation Framework

Sample UI Test Framework

Parameterisation, DataProvider and Factory

`@Parameters` #

Parameterisation, DataProvider and Factory

@Parameters #

`@Parameters` #