Framework Setup

Creating the Gradle Project

Launch IntelliJ and select ‘Create New Project’
Select ‘Gradle’ in the left pane
- Select the appropriate Java JDK in the ‘Project SDK’ dropdown at the top (should be the one installed previously. For purposes of this guide and for simplicity reasons, we are using Java 8 JDK)
  - Make sure ‘Java’ is check in the right pane
- Click ‘Next’
In the ‘GroupId’ field, enter an appropriate name (e.g. “com.producttestframework”)
In the ‘ArtifactId’ field, input an appropriate name (e.g. “AutomationFramework”)
Click ‘Next’
Check the ‘Use auto-import’ checkbox
Ensure the ‘Use default gradle wrapper (recommended)’ radio button is selected
Ensure ‘Use Project JDK’ is selected for the Gradle JVM
Click ‘Next’
Give an appropriate Project Name (e.g. “ProductAutomation”) and an appropriate project location on your local machine (e.g. ~/Users/username/DevProjects/ProductAutomation)
Click ‘Finish’
Advance to IntelliJ IDEA –> Preferences/Settings –> Build, Execution, Deployment –> Build Tools –> Gradle
- Check the ‘Create directories for empty content roots automatically’ checkbox
  - This will create your src/main and src/test sub-directories and resources for you
Click ‘Apply’
Click ‘OK’

Gradle Dependencies

You can manage all your projects dependencies, plugins and packages by simply adding them accordingly into your Gradle project’s build.gradle file 🙂

Open up the build.gradle file and add the following dependencies within the dependencies braces.
- Remove the ‘junit’ dependency that was added by default

Please note that the latest versions may change since the date I wrote this guide. I recommend searching for each dependency below on https://mvnrepository.com and simply copying the dependencies from there for Gradle and then pasting them into your project’s build.gradle file.

Do make sure however, that you include certain information like ‘exclusions’ for JUnit in the TestNG dependency as shown in my examples below.

Cucumber Dependencies

Cucumber-Java

testCompile group: 'io.cucumber', name: 'cucumber-java', version: '4.8.0'

Cucumber-JVM-Deps

testCompile group: 'io.cucumber', name: 'cucumber-jvm-deps', version:'1.0.6'

Cucumber-TestNG

compile(group: 'io.cucumber', name: 'cucumber-testng', version:'4.8.0') {
    exclude(module: 'junit')
}

TestNG Dependencies

TestNG

testCompile group: 'org.testng', name: 'testng', version:'6.14.3'

Selenium WebDriver Dependencies

Selenium Java

compile group: 'org.seleniumhq.selenium', name: 'selenium-java', version:'3.13.0'

WebDriver Manager (used to automatically grab the necessary Selenium Drivers when creating an instance, rather than manually setting a path to them)

compile group: 'io.github.bonigarcia', name: 'webdrivermanager', version:'2.2.4'

Extra Needed Dependencies for Drivers

Google Core Libraries for Java

compile group: 'com.google.guava', name: 'guava', version:'25.1-jre'

Gson

compile group: 'com.google.code.gson', name: 'gson', version:'2.8.5'

Logging

Log4J-Core

compile group: 'org.apache.logging.log4j', name: 'log4j-core', version:'2.11.1'

Log4J-API

compile group: 'org.apache.logging.log4j', name: 'log4j-api', version:'2.11.1'

Tell Gradle to use TestNG.xml File

Later in this blog series, we will create a testng.xml file which we use to run our different test suites, defined for example in our TestRunner class that we will also make. We need to specifically tell Gradle to use our testng.xml file for test classes and ordering, so lets configure a test suite (xml) to be executed in a Gradle task 🙂

Add the following TestNG task below the dependencies section in your build.gradle file…
```
test {
    useTestNG() {
        suites 'testng.xml'
    }
}
```

When complete, the whole build.gradle file should look similar to below…

group 'com.testifyqagradleframework'
version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8 //this is your Java JDK version

repositories {
    mavenCentral()
}

dependencies {
    compile(group: 'info.cukes', name: 'cucumber-testng', version:'1.2.5') {
        exclude(module: 'junit')
    }
    compile group: 'net.masterthought', name: 'cucumber-reporting', version:'3.19.0'
    compile group: 'org.seleniumhq.selenium', name: 'selenium-java', version:'3.13.0'
    compile group: 'org.apache.logging.log4j', name: 'log4j-core', version:'2.11.1'
    compile group: 'org.apache.logging.log4j', name: 'log4j-api', version:'2.11.1'
    compile group: 'com.google.guava', name: 'guava', version:'25.1-jre'
    compile group: 'com.google.code.gson', name: 'gson', version:'2.8.5'
    compile group: 'io.github.bonigarcia', name: 'webdrivermanager', version:'2.2.4'
    compile group: 'org.json', name: 'json', version:'20180130'
    testCompile group: 'org.testng', name: 'testng', version:'6.14.3'
    testCompile group: 'info.cukes', name: 'cucumber-java', version:'1.2.5'
    testCompile group: 'info.cukes', name: 'cucumber-jvm-deps', version:'1.0.5'
}

test {
    useTestNG() {
        suites 'testng.xml'
    }
}

IntelliJ Plugins

Cucumber for Java Plugin

Ensure ‘Cucumber for Java’ plugin is installed and enabled in IntelliJ by going to Settings –> Plugins and ensuring ‘Cucumber for Java’ is checked
1. MacOS: IntelliJ IDEA –> Preferences –> Plugins
2. Windows: File –> Settings –> Plugins

Log4J Plugin

Go into Settings –> Plugins again as done in the above section
Search for ‘Log4J’
Install / enable (if necessary)

Create a .gitignore File

In IntelliJ, right-click on your project root and select New –> File
1. Name the file .gitignore and click OK

Paste the following into your .gitignore file (this is a default template used for Gradle projects)

log/
target/*
.idea/
.DS_Store
release.properties
buildNumber.properties
.gradle/
build/

# Ignore Gradle GUI config
gradle-app.setting

# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
!gradle-wrapper.jar

# Cache of project
.gradletasknamecache

# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
# gradle/wrapper/gradle-wrapper.properties

Now would be a good time to save the Gradle project if you haven’t yet done so! 🙂

Packages & Directory Structure

Right-click on the {project-root}/src/test/java directory, select New –> Package, and add the following packages (as well as sub packages within other packages. You may need to put a temporary dummy file in ‘utils’ package first before adding the sub-packages)
- pages
- steps
- utils
  - drivers
  - helpers
  - hooks
  - selenium
Right-click the /src/test/resources directory and select New –> Directory
1. Name the directory ‘features’ and click OK

Initial Files in each Package / Directory

Features folder

Right-click the ‘features’ directory, select ‘New’ –> ‘File’ and add the following feature files (Feature files is what Cucumber uses to write BDD scenarios using Gherkin language. Please see https://cucumber.io/ for more information)
- BaseScenarios.feature

Pages package

Right-click the ‘pages’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘pages’ package will contain all our class files for our web pages / page objects, following Page Object Model (POM) principles. Please see https://goo.gl/4iq2Et for more information)
- Page
- BasePage

Steps package

The steps package will contain all our step definition classes, which will contain our step definitions / glue which links our steps in our test scenarios to the java methods which perform different actions.

When it comes to grouping our step definitions, it is good practice to have a Step Definition class file for each major domain object we are trying to test.

For example, in this blog series, we will mainly be testing that a user can search for “Reddit” on DuckDuckGo and then navigate to Reddit by selecting the appropriate search result.

So in this case, we could have the following Step Definition files…

Right-click the ‘steps’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘steps’ package will contain all our step definitions, which acts as the glue that connects our BDD/Gherkin language scenarios in our Feature files, to our test methods in our Java classes. Please see https://cucumber.io/docs/gherkin/step-organization/ for more information)
- BaseSteps
  - this class contains all the step definitions for your base scenarios and steps that apply across multiple domain objects
- SearchSteps
  - this class contains all the step definitions for steps that perform actions around searching on DuckDuckGo
- RedditSteps
  - this class contains all the step definitions for steps that involve Reddit

Utils package

Drivers package

Right-click the ‘drivers’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘drivers’ package will contain class files for all the different WebDrivers our test framework will use)
- ChromeWebDriver
- FirefoxWebDriver

Helpers package

Right-click the ‘helpers’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘helpers’ package will contain class files for all our static methods which can act as helpers to our existing functionality)
- WebDriverHelpers
- WebElementHelpers

Hooks package

Right-click the ‘hooks’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘hooks’ package will contain classes for all the different hooks we can run before and/or after test runs/suites/scenarios etc.)
- CucumberHooks
- StepHooks
- TestRunHooks

Selenium package

Right-click the ‘selenium’ package, select ‘New’ –> ‘Java Class’ and add the following classes to the package (the ‘selenium’ package will contain our core WebDriver setup and DriverController instance, as well as a Settings class where we can list public static variables to be used in our project)
- Driver
- DriverController
- Settings

Liked it? Take a second to support Thomas on Patreon!

A blog on QA Automation

Part 2a. Framework Setup (Gradle / Cucumber / Selenium / TestNG)