Test Automation Framework using Robot Framework

This project is implemented to provide a robust framework for implementing automated test suites.

Goal is to write to automated test suites without having to write any code and any non-technical user should be able write tests in plain english.

This library is to implement Robot Framework libraries in java to be able to use in robot framework test suites.

Robot Framework

Robot Framework is a generic test automation framework for acceptance testing and acceptance test-driven development (ATDD). It has easy-to-use tabular test data syntax and it utilizes the keyword-driven testing approach.

Its testing capabilities can be extended by test libraries implemented either with Python or Java, and users can create new higher-level keywords from existing ones using the same syntax that is used for creating test cases. Robot Framework is operating system and application independent. The core framework is implemented using Python and runs also on Jython (JVM) and IronPython (.NET)

Database Library

Documentation

• Core Keywords Documentation
• BDD Style Keywords Documentation
• JavaDoc

Introduction

Robot Framework DatabaseLibrary is Java implementation library for writing tests against database.

Provides ready-to-use keywords for database testing and uses jdbc under the cover for implementation.

Library is fully-documented and can be extended with custom composite keywords.

For more information on Robot Framework visit //TODO and Selenium visit

Tested With:

   Robot Framework: 3.0.2

Usage

• Add this library as a dependency to the project hosting the test suites.

  Maven:

   <dependency>
       <groupId>com.rise.autotest</groupId>
       <artifactId>robot-db-library</artifactId>
       <version>1.0</version>
   </dependency>
  

• Import the library into your test suites file and start using the keywords.

  For full list of keywords refer to Keyword Documentation section.

  dbtests_suite.robot

   *** Settings ***
   Documentation       Database Tests
   Library             DatabaseLibrary
   Suite Setup         Log    Suite setup
   Test Setup          Log    Test setup
   Test Teardown       Log    Test Teardown
   Suite Teardown      Close All Connections
        
   *** Test Cases ***
   [TC-001]-Test Setup
       [Documentation]    Sample robot database test file
       [Tags]    Acceptance
       Open Connection     db.properties   true
       Execute Query    create table if not exists users(user_id varchar(50), user_name varchar(50), email varchar(250))
       Execute Query    insert into users(user_id,user_name,email) values('jamesbond007','jamesbond','james.bond@007.com')
       I Open Connection With Properties     db.conf
       I close the connection
       [Teardown]    Close All Connections  
  

Keyword Extensions

One of the best feature of Robot Framework is its ability to extend and compose keywords. Robot Framework supports writing custom keywords into its own Keyword Resource files, which can be later imported into Test suites.

The keywords in this library can be extended are composed in to a more generic keywords to be used in test suites. It Library show-cases a sample of extending the core keywords to behavior-driven style keywords and also showcases how to generate documentation for these extended keywords.

Below is a sample resource file with extended keywords.

DatabaseLibrary_BDD_Keywords.robot

    *** Settings ***
    Documentation       Behavior-driven keywords, extended from core keywords
    Library             DatabaseLibrary
    
    *** Keywords ***
    I open connection with properties
        [Documentation]    Opens a new connection. Refer to `Open Connection` core keyword.
        [Arguments]    ${configFile}
        Open Connection    ${configFile}
    
    I close the connection
        [Documentation] close the connection
        Close Connection

Selenium Library

Keyword Documentation

• Core Keywords Documentation
• BDD Style Keywords Documentation
• JavaDoc

Introduction

Robot Framework SeleniumLibrary is Java implementation library for web testing that leverages Selenium 3 libraries.

Provides read to use keywords for web testing using selenium and also provides extension keywords for behavior-driven style of writing tests.

Library is fully-documented and can be extended with custom composite keywords.

For more information on Robot Framework visit //TODO and Selenium visit

Tested With:

Selenium: 3.7.1
Robot Framework: 3.0.2

Usage

• Add this library as a dependency to the project hosting the test suites.

Maven:

    <dependency>
        <groupId>com.rise.autotest</groupId>
        <artifactId>robot-selenium-library</artifactId>
        <version>1.0</version>
    </dependency>

• Import the library into your test suites file and start using the keywords.

  For full list of keywords refer to Keyword Documentation section.

  Google_TestSuite.robot

    *** Settings ***
    Documentation       Google.com Automation Test Suite
    Library             SeleniumLibrary
    Suite Setup         Log    Starting execution
    Suite Teardown      Close All Browsers
       
    *** Variables ***
    ${Google URL}      http://www.google.com
    ${Browser}      chrome
       
    *** Test Cases ***
    [TC-001]-Open Google.com
        [Documentation]    Test to verify site opens
        [Tags]    Regression    Acceptance
        [Setup]  Log    Test-specific setup
        Launch Google.com
        Location Should Be    https://www.google.com/
        Title Should Contain    Google
        [Teardown]    Close Browser
           
    *** Keywords ***
    Launch Google.com
        Open Browser    ${Google URL}     ${Browser}   goog1
  

Keyword Extensions

One of the best feature of Robot Framework is its ability to extend and compose keywords. Robot Framework supports writing custom keywords into its own Keyword Resource files, which can be later imported into Test suites.

The keywords in this library can be extended are composed in to a more generic keywords to be used in test suites. This Library show-cases a sample of extending the core keywords to behavior-driven style keywords and also showcases how to generate documentation for these extended keywords.

Below is a sample resource file with extended keywords.

SeleniumLibrary_BDD_Keywords.robot

    *** Settings ***
    Documentation       Behavior-driven keywords, extended from core keywords
    Library             SeleniumLibrary
    
    *** Keywords ***
    I open chrome browser and navigate to
        [Documentation]    Opens chrome browser session and navigate to the given URL
        [Arguments]    ${url}
        Open Browser    ${url}    CHROME
    
    I open Firefox browser and navigate to
        [Documentation]    Opens firefox browser session and navigate to the given URL
        [Arguments]    ${url}
        Open Browser    ${url}    FIREFOX

About Web Driver

WebDriver is a remote control interface that enables introspection and control of user agents. It provides a platform- and language-neutral wire protocol as a way for out-of-process programs to remotely instruct the behavior of web browsers.

W3C Web Driver Candidate Spec: https://w3c.github.io/webdriver/webdriver-spec.html

WebDriver Capabilities

Introduction

WebDriver capabilities are used to communicate the features supported by a given implementation. The local end may use capabilities to define which features it requires the remote end to satisfy when creating a new session. Likewise, the remote end uses capabilities to describe the full feature set for a session.

Below is a list of standard capabilities, that each implementation MUST support. WebDriver Spec#capabilities: https://w3c.github.io/webdriver/webdriver-spec.html#capabilities

Standard WebDriver Capabilities

“timeouts” Object

“proxy” Object

additional capabilities

Firefox(geckodriver) Capabilities

geckodriver also supports capabilities with the moz: prefix, which can be used to define Firefox-specific capabilities.

moz:firefoxOptions

moz:webdriverClick

A boolean value to indicate which kind of interactability checks to run when performing a click on elements.

“log” Object

“prefs” Object

The following example selects a specific Firefox binary to run with a prepared profile from the filesystem in headless mode (available on certain systems and recent Firefoxen)

{
"capabilities": {
    "moz:firefoxOptions": {
        "binary": "/usr/local/firefox/bin/firefox",
        "args": ["-headless", "-profile", "/path/to/my/profile"],
        "prefs": {
            "dom.ipc.processCount": 8
        },
        "log": {
            "level": "trace"
        }
    }  
  }
}

System.setProperty(“webdriver.gecko.driver”, “/Users/bachola/_tools/geckodriver”);

Chrome(chromeDriver) Capabilities

chrome driver also supports capabilities with goog: prefix, which can be used to define Chrome-specific capabilities.

goog:chromeOptions

perfLoggingPrefs Object

loggingPrefs Object

{
"capabilities": {
    "goog:chromeOptions": {
        "args": ["--headless"]
    },
    "loggingPrefs": {
        "driver": "INFO", 
        "browser": "INFO"
    }
}
}

System.setProperty(“webdriver.chrome.driver”, “/Users/bachola/_tools/chromedriver”);

Internet Explorer

Safari

safari.options

Opera

operaOptions

Edge

edgeOptions

Handling Capabilities in Selenium Library

This Selenium Library takes the capabilities json as one of the parameter to Open Browser keyword along with the browser name.

The capabilities string is optional to open browser session. if no capabilities, default capabilities (browserName, platformName) will be applied based on the browserName provided.

Selenium handles the standard web driver capabilities and as well browser specific capabilities (options). Browser specific capabilities will need to be under specific key in the capabilities json. Below are the details:

Firefox: "moz:firefoxOptions"
Google Chrome: "goog:chromeOptions"
Opera: "operaOptions"
Internet Explorer: "se:ieOptions"
Safari: "safari.options"
Edge: "edgeOptions"

This Selenium Library handles multiple browser options in single capabilities json, only the options relevant to the parameter browserName will be picked and applied.

For example the following capabilities json is having both firefox and chrome options along with standard capabilities But only relevant options will be applied based on the browserName argument to the Openn Browser keyword.

{
"capabilities": {
	"platformName": "MAC",
	"moz:firefoxOptions": {
		"prefs": {
			"dom.ipc.processCount": 8
		},
		"log": {
			"level": "trace"
		}
	},
	"goog:chromeOptions": {
		"args": ["--headless"]
	},
	"loggingPrefs": {
		"driver": "INFO", 
		"browser": "DEBUG"
	},
	"timeouts": {
		"script": 10000,
		"pageLoad": 11000,
		"implicit": 12000
	},
	"version": "56"
  }
}

Locating UI Elements

Locating elements in Selenium can be done by using certain type of locators. The keywords in this Selenium Library takes ‘locator’ string as argument. The locator string will be in format locatorType=locatorText (for xpath it can be of format //locatorText). locatorType is case-insensitive.

Following types of locator strings are supported in this library.

Id Locator

This is the most efficient and preferred way to locate an element.

Example:

<div id="coolestWidgetEvah">...</div>

Locator String:

id=coolestWidgetEvah

Class Name Locator

“Class” in this case refers to the attribute on the DOM element. Often in practical use there are many DOM elements with the same class name, thus finding multiple elements becomes the more practical option over finding the first element.

Example:

<div class="cheese"><span>Cheddar</span></div><div class="cheese"><span>Gouda</span></div>

Locator String:

classname=cheese

TagName Locator

The DOM Tag Name of the element.

Example:

<iframe src="..."></iframe>

Locator String:

tag=iframe

Name Locator

Find the element with matching name attribute.

Example:

<input name="cheese" type="text"/>

Locator String:

name=cheese

LinkText Locator

Find the link element with matching visible text.

Example:

<a href="http://www.google.com/search?q=cheese">cheese</a>>

Locator String:

linktext=cheese

linktext=http://www.google.com/search?q=cheese

CSS Locator

Like the name implies it is a locator strategy by css. Native browser support is used by default, so please refer to w3c css selectors for a list of generally available css selectors. If a browser does not have native support for css queries, then Sizzle is used.

Beware that not all browsers were created equal, some css that might work in one version may not work in another.

Example:

<div id="food"><span class="dairy">milk</span><span class="dairy aged">cheese</span></div>

Locator String:

css=#food span.dairy.aged

XPath Locator

At a high level, WebDriver uses a browser’s native XPath capabilities wherever possible. On those browsers that don’t have native XPath support, Selenium provided our own implementation.

This can lead to some unexpected behaviour unless you are aware of the differences in the various XPath engines.

Example:

<input type="text" name="example" />
<INPUT type="text" name="other" />

Locator String:

xpath=//input

//input - if a locator starts with '//' XPATH type is assumed.

IdOrName Locator

Find the element with matching name or id attribute.

Example:

<input type="text" name="example" />

Locator String:

IdOrName=example

Sizzle Locator

Refer to CSS Locator.