Tag: Gradle

Selenium UI test is the most used high level test these days for web applications. Regardless of which language you use, the framework is pretty much the same. I would like to share with everybody the Selenium web driver testing framework I worked on recently using Selenium in Java on a Groovy Gradle framework.

I will provide the step-by-step guideline on how to create a skeleton framework from scratch:

1. Import libraries you need

dependencies {

    compile 'org.codehaus.groovy:groovy-all:2.4.3'
    testCompile 'junit:junit:4.12'
    testCompile 'org.seleniumhq.selenium:selenium-java:2.46.0'
    testCompile 'info.cukes:cucumber-groovy:1.2.3'
}

You will need the Selenium Java from Maven repository, Cucumber in Groovy as a BDD layer (although this is not necessary), JUnit to assert test values.

2. Create a webdriver class

import org.openqa.selenium.WebDriver
import org.openqa.selenium.WebElement
import org.openqa.selenium.chrome.ChromeDriver

public class CsWebDriver {

 private static WebDriver _driver

 public static WebDriver get(String browserType)
 {
 if (browserType.equals("chrome"))
 {
 System.setProperty("webdriver.chrome.driver","srcmainresourceschromedriver.exe")
 ChromeOptions options = new ChromeOptions();
 options.setBinary("c:Chrome.V41GoogleChromePortable.exe");

 _driver=new ChromeDriver(options)

 }

 return _driver

 }

This is where we declare a new web driver object from the library and initialize it with a copy of driver downloaded from  ChromeDriver. You could create or extend all browser related functionalities in this class, such as Open a URL, Quit, Wait, Move To Click, etc.

For example: Move to an element to click using Action class

public static WebElement WaitTillElementExist(WebElement ele, int seconds)
{

   WebDriverWait wait = new WebDriverWait(_driver,seconds)
   return wait.until(ExpectedConditions.elementToBeClickable(ele))
}

3. Create Page Factory to host Page Objects

public class PageFactory {

    private static WebDriver _driver

    public static LoginPage LoginPage

   public static void InitialisePages(WebDriver driver)
   {
     _driver=driver
     LoginPage= new LoginPage(driver)
   }

   public static void ResetPages()
   {
     LoginPage=null
   }

 public static GetDriver() 
 { return _driver 
 }

Page Factory above is where we declare, initialize, and reset our Page Objects. An instance of web driver will be passed into each Page Object.

import org.openqa.selenium.support.FindBy 
import org.openqa.selenium.support.How

@InheritConstructors
class LoginPage extends BasePage {

    @FindBy(how=How.ID, using="Username")
    private WebElement userName

    @FindBy(how=How.ID, using="Password")
    private WebElement password

    @FindBy(how=How.CSS, using="button[class='btn']")
    private WebElement loginBtn

    public void Login(String username, String pwd)
    {
      userName.sendKeys(username)
      password.sendKeys(pwd)
      loginBtn.click()
    }
}

Every webpage that we are testing is treated as an object. By importing the Selenium library FindBy and How we can select the element that we want using ID, CSS, XPATH, etc. The page object will also contain functions specific to the page, for eg. Login function. As we can see, the page object is extended from the BasePage. A BasePage looks like this:

import org.openqa.selenium.support.PageFactory

public class BasePage {

    public WebDriver driver

    public BasePage(WebDriver webdriver)
    {
        this.driver=webdriver
        PageFactory.initElements(webdriver,this)

    }
}

We use the Selenium PageFactory library to easily implement this.

    4. Binding everything together

So we now have the web driver class, page factory, and page objects, how do we glue this all together into an executable test? To make test easier to understand and read, we usually like to use a BDD tool to describe a test Scenario. I will not go into depth on the BDD tool in this post, but I would like to touch base on the Before Scenario Hook of a BDD tool that is used to glue all pieces together.

this.metaClass.mixin(cucumber.api.groovy.Hooks) this.metaClass.mixin(cucumber.api.groovy.EN) Before("@web") 
{ 
  scenario -> PageFactory.InitialisePages(WebDriver.get("chrome")) 
  WebDriver.Open(oagUrl) 
}

Before every scenario, we initialize all Page Objects with a Chrome driver and then  open the URL.

After("@web") { scenario ->

    if (scenario.isFailed()) {
        String fileName=scenario.getName()
        WebDriver.PrintPageSource()
        WebDriver.TakeScreenShot(fileName, scenario)
    }

    WebDriver.Quit()
    PageFactory.ResetPages()
}

After every scenario, we check if the scenario is failed, if so, we print out the scenario name and take a screen shot. We then quit the driver and reset all Page Objects to null.

  5. Run the test via command line

To enable the test to be run on a CI box, we have to make the test run via command line. The example below is using Gradle to run the Cucumber Groovy test:

configurations {
    cucumberRuntime {
        extendsFrom testRuntime
    }
}

sourceSets{
    test{
        groovy{
            srcDirs 'src/test'
        }
    }
}

task cucumber() {
    dependsOn assemble, compileTestJava
    doLast {
        javaexec {
            main = "cucumber.api.cli.Main"
            classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output
            args = ['-f', 'json:target/cucumber-report.json','--plugin','pretty', '--glue', 'src/test/groovy/au/com/test/story/steps', 'src/test/groovy/au/com/test/story/features']
        }
    }
}

We created a Gradle task called “cucumber” and execute the test using “javaexec”.  We need to define in the Source Sets the directory of the test. In “args –glue”, we define where the Feature  files and Steps Definitions are.

  6. Finally, run your test!