Selenium Java Test Automation Architecture

Ready-to-use UI Test Automation Architecture using Java and Selenium WebDriver.

Installation Steps

In order to use the framework:

Fork the repository.
Clone, i.e, download your copy of the repository to your local machine using

git clone https://github.com/[your_username]/selenium-java-test-automation-architecture.git

Import the project in IntelliJ IDEA.
Make your desired changes.
Use IntelliJ IDEA to run your desired tests. Alternatively, you can use the terminal to run the tests, for example ./gradlew test -Dbrowser=firefox -Dheadless=false to run all the tests using the firefox browser in headful mode.
To see the report, go to the testoutput folder in the project root and then go to the report folder.

Languages and Frameworks

The project uses the following:

Java 11 as the programming language.
Selenium WebDriver as the web browser automation framework using the Java binding.
Univocity Parsers to parse and handle CSV files.
TestNG as the testing framework.
AssertJ as the assertion library.
Lombok to generate getters.
Owner to minimize the code to handle properties file.
Extent Reports as the test reporting strategy.
Selenium Shutterbug for capturing screenshots.
Gradle as the Java build tool.
IntelliJ IDEA as the IDE.

Project Structure

The project is structured as follows:

📦 selenium-java-test-automation-architecture
├─ .github
│  ├─ FUNDING.yml
│  ├─ dependabot.yml
│  └─ workflows
│     └─ test-execution.yml
├─ .gitignore
├─ LICENSE
├─ README.md
├─ build.gradle
├─ gradle
│  └─ wrapper
│     ├─ gradle-wrapper.jar
│     └─ gradle-wrapper.properties
├─ gradlew
├─ gradlew.bat
├─ script
│  └─ install_chrome.sh
├─ settings.gradle
└─ src
   ├─ main
   │  └─ java
   │     └─ io
   │        └─ github
   │           └─ tahanima
   │              ├─ config
   │              │  ├─ Configuration.java
   │              │  └─ ConfigurationManager.java
   │              ├─ dto
   │              │  ├─ BaseDto.java
   │              │  ├─ LoginDto.java
   │              │  └─ ProductsDto.java
   │              ├─ factory
   │              │  ├─ BasePageFactory.java
   │              │  └─ BrowserFactory.java
   │              ├─ report
   │              │  └─ ExtentReportManager.java
   │              └─ ui
   │                 ├─ component
   │                 │  ├─ BaseComponent.java
   │                 │  ├─ Header.java
   │                 │  └─ SideNavMenu.java
   │                 └─ page
   │                    ├─ BasePage.java
   │                    ├─ LoginPage.java
   │                    └─ ProductsPage.java
   └─ test
      ├─ java
      │  └─ io
      │     └─ github
      │        └─ tahanima
      │           ├─ e2e
      │           │  ├─ BaseTest.java
      │           │  ├─ LoginTest.java
      │           │  └─ ProductsTest.java
      │           └─ util
      │              ├─ DataProviderUtil.java
      │              ├─ TestListener.java
      │              └─ TestRetry.java
      └─ resources
         ├─ config.properties
         └─ testdata
            ├─ login.csv
            ├─ login.json
            ├─ products.csv
            └─ products.json

Basic Usage

Configuration

The project uses a config.properties file to manage global configurations such as browser type and base url.
1. To add a new property, register a new entry in this file.
```
key=value
```
  Then, add a method in the Configuration interface in the below format.
```
@Key("key")
dataType key();
```
  For example, let's say I want to add a new property named context with the value dev. In the config.properties file, I'll add:
```
context=dev
```
  In the Configuration interface, I'll add:
```
@Key("context")
String context();
```
  To use your newly created property, you need to use the below import statement.
```
import static io.github.tahanima.config.ConfigurationManager.config;
```
  Then, you can call config().key() to retrieve the value of your newly created property. For the example I've provided, I need to call config().context().
2. You can supply the properties present in the config.properties file as system properties in your test via gradle.
```
./gradlew test -Dkey1=value1 -Dkey2=value2
```

Test Data

The project uses csv or json file to store test data and univocity-parsers to retrieve the data and map it to a Java bean.

To add configurations for new test data, add a new Java bean in the dto package. For example, let's say I want to add test data for a User with the attributes First Name and Last Name. The code for this is as follows:

package io.github.tahanima.dto;

import com.univocity.parsers.annotations.Parsed;

import lombok.Getter;
import lombok.ToString;

@Getter
@ToString(callSuper = true)
public class UserDto extends BaseDto {

    @Parsed(field = "First Name", defaultNullRead = "")
    private String firstName;

    @Parsed(field = "Last Name", defaultNullRead = "")
    private String lastName;
}

Note that the class extends from BaseDto and thus, inherits the attributes Test Case ID and Test Case Description.

Now, in the testdata folder you can add a csv file user.csv for User with the below contents and use it in your tests.

Test Case ID,Test Case Description,First Name,Last Name
TC-1,Successful user creation,Tahanima,Chowdhury

Alternately, you can use a json file user.json with the below contents and use it in your tests.

[
  {
    "testCaseId": "TC-1",
    "testCaseDescription": "Successful user creation",
    "firstName": "Tahanima",
    "lastName": "Chowdhury"
  }
]

For reference, check this, this and this.

Browser

The project contains the implementation of the Chrome and Firefox browsers. If you want to include an implementation of a new browser type, add the relevant codes in the BrowserFactory enum.

For example, let's say I want to add the Edge browser to the BrowserFactory enum. The code for this is:

EDGE {
    @Override
    public WebDriver getDriver() {
        WebDriver driver = new EdgeDriver(getOptions());

        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(config().timeout()));
        driver.manage().window().maximize();

        return driver;
    }

    private EdgeOptions getOptions() {
        EdgeOptions options = new EdgeOptions();

        options.setAcceptInsecureCerts(true);

        if (Boolean.TRUE.equals(config().headless())) {
            options.addArguments("--headless=new");
        }

        return options;
    }
}

Now, you can launch all your tests in the Edge browser by either setting the property browser to edge in the config.properties file or as a system property via gradle.

Page Objects and Page Component Objects

The project uses Page Objects and Page Component Objects to capture the relevant behaviors of a web page. Check the ui package for reference.
Tests

The project uses TestNG as the test runner. Check this implementation for reference.

Tahanima/selenium-java-test-automation-architecture