Skip to main content

Robot Framework


cd ~/MyProject
pyenv global 3.10.6 # use specific python version
pyenv local 3.10.6
# Create Environment
python -m venv .venv
# Activate Environment
source .venv/bin/activate
# deactivate Environment
source .venv/bin/deactivate

Poetry Maven for Python

Poetry is a tool for dependency management and packaging in Python. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you. Poetry offers a lockfile to ensure repeatable installs, and can build your project for distribution.

pipx install poetry # Install Poetry
poetry new poetry-demo # Create Poetry Project
poetry run # runnning files ising poetry
poetry init # Make a folder poetry project
poetry shell # installs dependencies and activates environment
deactivate # when run in poetry shell deactivates the evironment
exit # Removes the poetry shell
poetry build

UI Libraries

In Robot Framework, which is a keyword-driven test automation framework, you can use SeleniumLibrary to interact with web browsers, and when dealing with web elements, locators play a crucial role. Chaining locators in Robot Framework with SeleniumLibrary allows you to create more specific and flexible locators by combining multiple locator strategies.

Here's an example to illustrate chaining locators in Robot Framework using SeleniumLibrary:

*** Settings ***
Library SeleniumLibrary

*** Test Cases ***
Chaining Locators Example
Open Browser chrome
${element}= Chain Locators css:div#container xpath://a[@id='link']
Click Element ${element}
Capture Page Screenshot
Close Browser

In this example:

  1. Open Browser opens the Chrome browser and navigates to the specified URL.
  2. Chain Locators is used to create a more specific locator by chaining two locators together. The first part of the chain is a CSS locator (css:div#container), and the second part is an XPath locator (xpath://a[@id='link']). The resulting ${element} will be a combination of these locators.
  3. Click Element uses the ${element} locator to click on the specific element on the web page.
  4. Capture Page Screenshot takes a screenshot for verification purposes.
  5. Close Browser closes the browser.

This is just a basic example, and you can chain different types of locators based on your needs. Keep in mind that while chaining locators can be powerful, it's essential to ensure that the combined locators uniquely identify the desired element on the web page. Additionally, consider the maintainability of your tests, as overly complex locators can make your test scripts harder to understand and maintain.

Rest Libraries

Desktop Libraries

Mobile Libraries

Database Library

Standard Library

Project Structure

  • pyproject.toml - Python dependencies
  • - Project description
  • .gitignore - Lists files and folders to be ignored by git
  • tests/ - Test Suites folder search.robot - Test Suite for Search functionality login.robot - Test Suite for Log In functionality checkout/ - Folder containing Test Suites for Checkout checkout_basic.robot - Test Suites for standard Checkout checkout_premium.robot - Test Suites for premium Checkout
  • resources/ - Reusable keywords common.robot - General Keywords (e.g. Login/Logout, Navigation, ...) are stored here search.robot - Keywords for searching are stored here - Python helper keywords are stored here

my_project Structure

├── tests
│ ├── suiteA.robot
│ ├── suiteB.robot
│ ├── ...

├── resources
│ ├── common.resource
│ ├── some_other.resource
│ ├──
│ ├──
│ ├── ...

├── .gitlab-ci.yml
├── .gitignore
├── requirements.txt

Import custom keywords

Settings Resource resources/common.resource Resource resources/some_other.resource Library resources/ Variables resources/ ...

Running Python Tests

robot --pythonpath . tests/suiteA.robot

Using PYTHONPATH environment variable

$ robot tests/suiteA.robot

File and Folders

Robot Documentation using RestructuredText

  • .robot, rst extension can be used to create restructured text
reStructuredText example

This text is outside code blocks and thus ignored.

.. code:: robotframework

*** Settings ***
Documentation Example using the reStructuredText format.
Library OperatingSystem

*** Variables ***
${MESSAGE} Hello, world!

*** Test Cases ***
My Test
[Documentation] Example test.
My Keyword ${CURDIR}

Another Test
Should Be Equal ${MESSAGE} Hello, world!

Also this text is outside code blocks and ignored. Code blocks not
containing Robot Framework data are ignored as well.

.. code:: robotframework

# Both space and pipe separated formats are supported.

| *** Keywords *** | | |
| My Keyword | [Arguments] | ${path} |
| | Directory Should Exist | ${path} |

.. code:: python

# This code block is ignored.
def example():
print('Hello, world!')


1. Scalar (Identifier: $) – The most common way to use variables in Robot Framework test data is using the scalar variable syntax like ${var}. When this syntax is used, the variable name is replaced with its value as-is.

2. List (Identifier: @) – If a variable value is a list or list-like, a list variable like @{EXAMPLE} is used. In this case, the list is expanded, and individual items are passed in as separate arguments.

3. Dictionary (Identifier: &) – A variable containing a Python dictionary or a dictionary-like object can be used as a dictionary variable like &{EXAMPLE}. In practice, this means that the dictionary is expanded and individual items are passed as named arguments to the keyword.

4. Environment (Identifier: %) – Robot Framework allows using environment variables in the test data using the syntax %{ENV_VAR_NAME}. They are limited to string values.

`*** Variables ***`

`${STRING}           cute name                #Scalar`

`${INT_AS_STRING}`    `1`                     `#Scalar`

`${INT_AS_INT}       ${``1``}                    #Scalar`

`${FLOAT}            ${``3.14``}                   #Scalar`

`@{LIST}             one    two    three`

`&{DICTIONARY}       string=name`    `int``=${``1``}    list=@{LIST}`