Robot Framework Tutorial: Guía Completa de Keyword-Driven Testing

Q: ¿Robot Framework es gratis?

Sí. Robot Framework es completamente gratis y open-source bajo licencia Apache 2.0. Todas las bibliotecas y herramientas están disponibles sin costo.

Q: ¿Robot Framework vs Selenium — cuál es la diferencia?

Robot Framework es un framework de testing con sintaxis keyword-driven. Selenium es una biblioteca de automatización de navegador. Robot Framework usa SeleniumLibrary para automatización web.

Q: ¿Puede Robot Framework testear APIs?

Sí. RequestsLibrary habilita testing de REST API. Robot Framework puede testear apps web, APIs, apps móviles y desktop con las bibliotecas apropiadas.

Domina Robot Framework para automatización de tests. Keyword-driven testing, SeleniumLibrary, keywords personalizados, data-driven tests y CI/CD.

TL;DR
Robot Framework usa enfoque keyword-driven — tests legibles sin programar
Tests escritos en formato tabular (plain text, archivos .robot)
SeleniumLibrary para web testing, RequestsLibrary para APIs
Crea keywords personalizados para encapsular lógica compleja
Reportes integrados e integración CI/CD
Ideal para: Equipos con habilidades técnicas mixtas, acceptance testing, RPA Omite si: Necesitas máxima flexibilidad (usa Python/pytest directamente) Tiempo de lectura: 15 minutos

Tu equipo incluye testers manuales que no programan. La gerencia quiere reportes de tests legibles. Los tests necesitan ser mantenibles por no-desarrolladores.

Robot Framework resuelve esto. Los tests se escriben con keywords en inglés simple. Cualquiera puede leerlos. Los desarrolladores pueden extenderlos. Los reportes se generan automáticamente.

Este tutorial cubre Robot Framework desde setup hasta integración CI/CD — todo para automatización keyword-driven.

¿Qué es Robot Framework?

Robot Framework es un framework de automatización open-source genérico para acceptance testing, acceptance test-driven development (ATDD) y robotic process automation (RPA). Usa un enfoque keyword-driven donde los tests se escriben en formato tabular legible por humanos.

Por qué Robot Framework:

Sintaxis legible — tests parecen lenguaje natural
Fácil de aprender — no-programadores pueden escribir tests
Extensible — bibliotecas Python/Java extienden funcionalidad
Reportes integrados — reportes HTML generados automáticamente
Gran ecosistema — bibliotecas para web, API, móvil, desktop

Instalación

Setup

# Instalar Robot Framework
pip install robotframework

# Instalar SeleniumLibrary para web testing
pip install robotframework-seleniumlibrary

# Instalar RequestsLibrary para API testing
pip install robotframework-requests

# Instalar Browser Library (alternativa basada en Playwright)
pip install robotframework-browser
rfbrowser init

# Verificar instalación
robot --version

Estructura del Proyecto

project/
├── tests/
│   ├── login_tests.robot
│   ├── api_tests.robot
│   └── __init__.robot
├── resources/
│   ├── keywords.robot
│   ├── variables.robot
│   └── pages/
│       └── login_page.robot
├── results/
└── requirements.txt

Sintaxis Básica

Primer Test

*** Settings ***
Library    SeleniumLibrary

*** Variables ***
${BROWSER}    chrome
${URL}        https://example.com

*** Test Cases ***
User Can Open Homepage
    Open Browser    ${URL}    ${BROWSER}
    Title Should Be    Example Domain
    Close Browser

User Can Search For Products
    Open Browser    ${URL}    ${BROWSER}
    Input Text    id=search    robot framework
    Click Button    id=search-btn
    Page Should Contain    Results
    Close Browser

Secciones Explicadas

Sección	Propósito
`* Settings *`	Bibliotecas, recursos, setup/teardown
`* Variables *`	Datos de test y configuración
`* Test Cases *`	Escenarios de test reales
`* Keywords *`	Keywords personalizados reutilizables

SeleniumLibrary para Web Testing

Keywords Comunes

*** Settings ***
Library    SeleniumLibrary

*** Test Cases ***
Web Interaction Examples
    # Navegación
    Open Browser    https://example.com    chrome
    Go To    https://example.com/login

    # Input
    Input Text    id=username    testuser
    Input Password    id=password    secret123

    # Clicks
    Click Button    id=submit
    Click Element    xpath=//a[@class='link']
    Click Link    Home

    # Verificación
    Page Should Contain    Welcome
    Page Should Contain Element    id=dashboard
    Element Should Be Visible    class=success-message
    Element Text Should Be    id=greeting    Hello User

    # Esperas
    Wait Until Element Is Visible    id=loading    timeout=10s
    Wait Until Page Contains    Dashboard

    # Obtener valores
    ${text}=    Get Text    id=message
    ${value}=    Get Value    id=input-field
    ${attr}=    Get Element Attribute    id=link    href

    Close Browser

Setup y Teardown

*** Settings ***
Library    SeleniumLibrary
Suite Setup    Open Browser    ${URL}    ${BROWSER}
Suite Teardown    Close All Browsers
Test Setup    Go To    ${URL}
Test Teardown    Capture Page Screenshot

*** Variables ***
${URL}       https://example.com
${BROWSER}    chrome

*** Test Cases ***
Test One
    # Navegador ya abierto desde Suite Setup
    Page Should Contain    Welcome

Test Two
    # Carga fresca de página desde Test Setup
    Click Link    About
    Page Should Contain    About Us

Keywords Personalizados

Creando Keywords

*** Settings ***
Library    SeleniumLibrary

*** Keywords ***
Login With Credentials
    [Arguments]    ${username}    ${password}
    Input Text    id=username    ${username}
    Input Password    id=password    ${password}
    Click Button    id=login-btn
    Wait Until Page Contains Element    id=dashboard

Logout
    Click Element    id=user-menu
    Click Link    Logout
    Wait Until Page Contains    Login

Verify Dashboard Loaded
    Page Should Contain Element    id=dashboard
    Element Should Be Visible    id=welcome-message
    Page Should Not Contain    Error

*** Test Cases ***
Successful Login
    Open Browser    https://example.com/login    chrome
    Login With Credentials    user@example.com    password123
    Verify Dashboard Loaded
    Logout
    Close Browser

Keywords con Valores de Retorno

*** Keywords ***
Get User Name From Dashboard
    ${name}=    Get Text    id=user-name
    [Return]    ${name}

Create User And Get ID
    [Arguments]    ${name}    ${email}
    Input Text    id=name    ${name}
    Input Text    id=email    ${email}
    Click Button    id=create
    Wait Until Page Contains Element    id=user-id
    ${id}=    Get Text    id=user-id
    [Return]    ${id}

*** Test Cases ***
Verify User Creation
    Open Browser    ${URL}    chrome
    ${user_id}=    Create User And Get ID    John Doe    john@example.com
    Should Not Be Empty    ${user_id}
    Log    Created user with ID: ${user_id}
    Close Browser

Patrón Page Object

Archivo Page Resource

# resources/pages/login_page.robot
*** Settings ***
Library    SeleniumLibrary

*** Variables ***
${LOGIN_URL}           https://example.com/login
${USERNAME_FIELD}      id=username
${PASSWORD_FIELD}      id=password
${LOGIN_BUTTON}        id=login-btn
${ERROR_MESSAGE}       class=error-msg
${DASHBOARD}           id=dashboard

*** Keywords ***
Navigate To Login Page
    Go To    ${LOGIN_URL}

Enter Username
    [Arguments]    ${username}
    Input Text    ${USERNAME_FIELD}    ${username}

Enter Password
    [Arguments]    ${password}
    Input Password    ${PASSWORD_FIELD}    ${password}

Click Login Button
    Click Button    ${LOGIN_BUTTON}

Login Should Succeed
    Wait Until Page Contains Element    ${DASHBOARD}    timeout=10s

Login Should Fail With Message
    [Arguments]    ${expected_message}
    Element Should Be Visible    ${ERROR_MESSAGE}
    Element Text Should Be    ${ERROR_MESSAGE}    ${expected_message}

Login As User
    [Arguments]    ${username}    ${password}
    Navigate To Login Page
    Enter Username    ${username}
    Enter Password    ${password}
    Click Login Button

Usando Page Objects

*** Settings ***
Library    SeleniumLibrary
Resource    resources/pages/login_page.robot
Suite Setup    Open Browser    ${URL}    ${BROWSER}
Suite Teardown    Close All Browsers

*** Variables ***
${URL}        https://example.com
${BROWSER}    chrome

*** Test Cases ***
Valid Login
    Login As User    user@example.com    password123
    Login Should Succeed

Invalid Password
    Login As User    user@example.com    wrongpassword
    Login Should Fail With Message    Invalid credentials

Data-Driven Testing

Test Templates

*** Settings ***
Library    SeleniumLibrary
Test Template    Login Should Fail For Invalid Credentials

*** Test Cases ***        USERNAME              PASSWORD        ERROR
Empty Username            ${EMPTY}              password123     Username required
Empty Password            user@example.com      ${EMPTY}        Password required
Invalid Email Format      invalid-email         password123     Invalid email format
Wrong Password            user@example.com      wrongpass       Invalid credentials

*** Keywords ***
Login Should Fail For Invalid Credentials
    [Arguments]    ${username}    ${password}    ${expected_error}
    Open Browser    https://example.com/login    chrome
    Input Text    id=username    ${username}
    Input Password    id=password    ${password}
    Click Button    id=login
    Element Text Should Be    class=error    ${expected_error}
    Close Browser

API Testing

*** Settings ***
Library    RequestsLibrary
Library    Collections

*** Variables ***
${BASE_URL}    https://jsonplaceholder.typicode.com

*** Test Cases ***
Get All Users
    Create Session    api    ${BASE_URL}
    ${response}=    GET On Session    api    /users
    Status Should Be    200    ${response}
    ${users}=    Set Variable    ${response.json()}
    Length Should Be    ${users}    10

Create New Post
    Create Session    api    ${BASE_URL}
    ${body}=    Create Dictionary    title=Test Post    body=Content    userId=1
    ${response}=    POST On Session    api    /posts    json=${body}
    Status Should Be    201    ${response}
    ${post}=    Set Variable    ${response.json()}
    Should Be Equal    ${post['title']}    Test Post

Delete Post
    Create Session    api    ${BASE_URL}
    ${response}=    DELETE On Session    api    /posts/1
    Status Should Be    200    ${response}

Integración CI/CD

GitHub Actions

name: Robot Framework Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install robotframework robotframework-seleniumlibrary

      - name: Run tests
        run: |
          robot --outputdir results tests/

      - name: Upload results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: robot-results
          path: results/

Ejecutando Tests

# Ejecutar todos los tests
robot tests/

# Ejecutar archivo específico
robot tests/login_tests.robot

# Ejecutar con tags
robot --include smoke tests/
robot --exclude slow tests/

# Ejecutar con variables
robot --variable BROWSER:firefox --variable URL:https://staging.example.com tests/

# Output a directorio específico
robot --outputdir results tests/

Robot Framework con Asistencia de IA

Las herramientas de IA pueden ayudar a escribir y mantener tests de Robot Framework.

Lo que la IA hace bien:

Generar keywords desde user stories
Crear variaciones de datos de test
Convertir casos de test manuales a sintaxis Robot
Sugerir library keywords

Lo que aún necesita humanos:

Entender requisitos de negocio
Diseñar arquitectura de tests
Depurar fallas complejas
Mantener page objects

FAQ

¿Qué es Robot Framework?

Robot Framework es un framework de automatización open-source basado en Python que usa un enfoque keyword-driven. Los tests se escriben en formato tabular legible que parece lenguaje natural, haciéndolos accesibles para no-programadores. Soporta testing web, API, móvil y desktop a través de varias bibliotecas.

¿Robot Framework es gratis?

Sí, Robot Framework es completamente gratis y open-source bajo licencia Apache 2.0. Todas las bibliotecas estándar (SeleniumLibrary, RequestsLibrary, etc.) también son gratis. No hay versiones pagas ni funciones enterprise — todo está disponible sin costo.

¿Robot Framework vs Selenium — cuál es la diferencia?

Robot Framework es un framework de automatización de tests que provee la estructura y sintaxis para escribir tests. Selenium es una biblioteca de automatización de navegador. Robot Framework usa SeleniumLibrary (un wrapper alrededor de Selenium) para realizar automatización de navegador web. Piensa en Robot Framework como el framework de test y Selenium como el driver de navegador.

¿Puede Robot Framework testear APIs?

Sí, Robot Framework puede testear REST APIs usando RequestsLibrary. Puedes hacer requests HTTP (GET, POST, PUT, DELETE), verificar códigos de estado de respuesta, parsear respuestas JSON y validar datos.

Recursos Oficiales

Ver También

Selenium Tutorial - Fundamentos de automatización de navegador
API Testing Guide - Testing de REST API
Cucumber BDD Tutorial - Behavior-driven development
Python Testing Guide - Automatización de testing Python