Robot Framework Test Automation: Step-by-Step Guide

Updated 14 November 2026 · Standard formula, shown below

This guide walks you through using Robot Framework for test automation, from installation to writing and running your first test suites. You’ll learn how to structure test cases, use keywords, and integrate with Selenium for web testing, giving you a solid foundation for automating repetitive checks and improving software quality.

What You’ll Need

Python 3.6 or later installed on your system (check with python --version).
Pip (Python’s package installer) – usually included with Python.
Basic familiarity with the command line or terminal.
For web testing: a browser (Chrome, Firefox, etc.) and the corresponding WebDriver (e.g., ChromeDriver for Chrome).

Step-by-Step

Install Robot Framework and SeleniumLibrary
Open your terminal and run:
pip install robotframework
Then install the Selenium library for web automation:
pip install robotframework-seleniumlibrary
Verify Installation
Run robot --version to confirm Robot Framework is installed. It should print the version number. Also run python -c "import SeleniumLibrary" to ensure the library imports without errors.
Set Up WebDriver (for web tests)
Download the WebDriver for your browser (e.g., ChromeDriver for Chrome) and place it in a directory that’s in your system’s PATH, or specify its location in the test settings. For Firefox, use geckodriver.
Create a Test Suite File
Robot Framework test files use the .robot extension. Create a new file, e.g., mytest.robot, and open it in a text editor.

Write the Basic Structure
Start with the Settings section to import libraries and define metadata. Then add a Test Cases section with your test cases. Example:

*** Settings ***
Library    SeleniumLibrary

*** Test Cases ***
Open Google
    Open Browser    https://www.google.com    chrome
    Title Should Be    Google
    Close Browser

Run the Test
In the terminal, navigate to the directory containing your .robot file and run:
robot mytest.robot
Robot Framework will execute the test and generate an HTML report and log.
View Results
After execution, you’ll see files like report.html, log.html, and output.xml. Open report.html in a browser to see a summary of pass/fail statuses and details.
Use Keywords for Reusability
Define your own keywords in the *** Keywords *** section. This helps avoid repetition. Example:
```
*** Keywords ***
Open Google Homepage
    Open Browser    https://www.google.com    chrome
    Title Should Be    Google
```
Add Variables
Use the *** Variables *** section to define values like URLs or login credentials. Reference them with ${VARIABLE_NAME}. For example:
```
*** Variables ***
${URL}    https://www.google.com
```
Create Test Suites and Organize
You can group test cases into multiple files and directories. Use __init__.robot files to set up suite-level setup/teardown. Run all tests in a directory with robot path/to/directory.
Use Tags for Selective Execution
Add tags to test cases like [Tags] smoke. Then run only those tests with robot --include smoke mytest.robot.
Leverage Built-in Libraries
Robot Framework includes built-in libraries like BuiltIn, Collections, and String. Import them in Settings to use their keywords for assertions, list operations, and string manipulation.
Integrate with CI/CD
You can run Robot Framework tests in CI pipelines (e.g., Jenkins, GitLab CI) by invoking the same robot command and publishing the generated HTML reports as artifacts.

Common Mistakes

Forgetting to install the SeleniumLibrary or not importing it in the Settings section.
WebDriver not in PATH – leads to “WebDriverException: Message: ‘chromedriver’ executable needs to be in PATH”.
Using single backslashes in file paths – use forward slashes or double backslashes.
Not closing browsers in teardown, causing resource leaks.
Using spaces inconsistently in test case names or keywords – Robot Framework is space-sensitive; use at least two spaces between elements.
Assuming test cases run in order – they don’t by default; use [Documentation] and setup/teardown to manage dependencies.

Tips

Start with a simple test and gradually add complexity.
Use meaningful test case names and documentation tags for readability.
Leverage the Run Keyword If and Run Keyword And Expect Error for conditional logic and error handling.
Use the --outputdir option to keep test artifacts organized.
Take advantage of the --dryrun option to check syntax without executing.
Read the generated log.html to debug failures – it shows each keyword’s execution time and outcome.

Troubleshooting

“command not found: robot” – Ensure Python’s Scripts directory is in your PATH, or reinstall with pip install robotframework using the correct Python environment.
Tests fail with “No keyword with name ‘Open Browser’ found” – Check that SeleniumLibrary is imported correctly in the Settings section.
Browser opens but immediately closes – This often happens when the WebDriver version doesn’t match the browser version. Update both to the latest stable versions.
“Element not found” errors – Use explicit waits like Wait Until Element Is Visible instead of relying on implicit sleeps.
Tests pass locally but fail in CI – Ensure the CI environment has the necessary browsers and WebDrivers installed, and that paths are set correctly.
Slow test execution – Use Set Selenium Speed to add delays only when needed, and consider running tests in parallel with pabot (a parallel runner).

Frequently Asked Questions

Q: Can Robot Framework test APIs?
A: Yes, use the RequestsLibrary to send HTTP requests and validate responses.

Q: How do I handle pop-ups or alerts?
A: Use the Handle Alert keyword from SeleniumLibrary to accept, dismiss, or get text from alerts.

Q: Is Robot Framework only for web testing?
A: No, it supports many interfaces via libraries, including REST APIs, databases, SSH, and desktop applications.

Q: How can I run only a specific test case?
A: Use the --test option with the test name, e.g., robot --test "Open Google" mytest.robot.

Q: Can I use Robot Framework with Python code?
A: Yes, you can write custom Python libraries and import them as Robot Framework libraries.

Q: How do I generate a test report in JUnit format?
A: Use the --xunit option to output JUnit-style XML, which is useful for CI integration.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.