Skip to content

Latest commit

 

History

History
228 lines (188 loc) · 9.65 KB

File metadata and controls

228 lines (188 loc) · 9.65 KB

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:

  1. Fork the repository.
  2. 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
  1. Import the project in IntelliJ IDEA.
  2. Make your desired changes.
  3. 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.
  4. 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:

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.