Começando a automatizar sem programar usando Robot Framework

Hoje talvez possamos dizer que existem dois tipos diferentes de QAs: você pode ser um QA igual o Matheus Matos , um dos autores desse artigo, que curte automação e programar; ou você pode ser igual o outro autor desse artigo, o Gabriel Jundurian, que sabe que automação é uma parte importante da vida de tester hoje mas…programação não é com ele, nunca foi.

Primeiramente, se você é igual ao Gabriel, parabéns, você não está sozinho(a) no mundo 👊

Segundo, esse artigo pode te ajudar a começar nessa empreitada de automação sem precisar ser um expert em Python, Java, JavaScript, Ruby e…sei lá, C#. Digo isso porque o objetivo desse artigo é fazer uma introdução a um framework de teste chamado Robot Framework.

“Ah, mas como que você vai me apresentar um framework de teste sendo que dos dois autores desse artigo, um curte e outro não curte programar? Qual a lógica? Para automatizar usando um framework de teste não precisa saber programar?”

Pois bem, essa ferramenta pode agradar gregos e troianos. Pode auxiliar quem não gosta, ou tem dificuldade, de programar, e pode ajudar quem já tem uma certa experiência, visto a sua facilidade e leque de opções.

Bora lá?

O que é Robot Framework?

Palavras do próprio site do Robot Framework: é um framework de automação open source e genérico.

Mas o que isso quer dizer? Que ele não é focado em um tipo apenas de automação, ele consegue automatizar testes Web, de API, banco de dados, mobile, utilizar RPA e muitos outros, inclusive conseguindo navegar entre eles no mesmo script.

Além disso, como já comentamos, ele auxilia quem não gosta de programar por causa de sua abordagem “keyword driven”, ou seja, o usuário usa palavras-chave para escrever o código (vai ficar mais claro quando chegarmos nos exemplos), não sendo necessário utilizar uma linguagem de programação. O Robot foi desenvolvido em Python, mas você não precisa saber Python para automatizar usando Robot.

Para facilitar, cada biblioteca do Robot (que é o que você instala para poder automatizar web, mobile…) já tem suas keywords pré-definidas. Então é tudo questão de instalar o Robot, adicionar a(s) biblioteca(s) desejada(s) e usar as palavras-chave que já vem com elas. É possível inclusive criar novas baseadas nas já existentes de acordo com a necessidade de cada um.

Curtiu? Então partiu instalar tudo.

Instalação Python + Pip + Robot Framework

Primeiro, como o Robot é feito em Python, precisamos instalar o Python (que coisa, não?). Para isso basta ir no site (https://www.python.org/downloads/) e baixar a última versão disponível (no momento temos a 3.11.4).

Processo de instalação dele é bem direto e reto, apenas marquem a opção “Add Python to PATH”, e segue o jogo:

Feito isso, para garantir que o Python foi instalado, abra um terminal, ou CMD, no seu computador (se já tinha um aberto, recomendamos fechar e abrir um novo) e digite:

python -V

Se tudo foi feito corretamente, o resultado será a versão instalada do Python:

Agora, você pode até aproveitar esse terminal já aberto e instalar o Pip que é um sistema de gerenciamento de pacotes padrão para gerenciar pacotes de software escritos em Python.

Basta você digitar os seguintes comandos no terminal e aguardar, se você for usuário do sistema operacional Windows:

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py

Se você for usuário do sistema operacional Linux ou Unix, basta digitar o seguinte comando:

wget https://bootstrap.pypa.io/get-pip.py

Depois para ambos sistemas operacionais, basta executar e aguardar a finalização da instalação:

python get-pip.py

Para instalar o Robot, digite o seguinte comando:

pip install robotframework

E, mais uma vez, para garantir a versão, digite

robot --version

Instalação Visual Studio Code + Extensão do Robot

Você também vai precisar de um Ambiente de Desenvolvimento Integrado (IDE) que vai facilitar a sua vida no momento em que for escrever os casos de teste automatizado, existem inúmeros IDEs open source, mas nós recomendamos fortemente que use o Visual Studio Code! Para baixar e instalar basta seguir os seguintes passos:

1. Acesse o site (https://code.visualstudio.com/download) e escolha seu ambiente (Linux, MacOS ou Windows). Realize o download do arquivo e clique nele para instalar. O processo de instalação é bem simples (apenas garanta que na foto abaixo, as mesmas opções estão marcadas):

2. Abra o Visual Studio Code e clique em “Extensões” ou pressione Ctrl + Shift + x e busque por Python, depois clique em Install.

Repita o mesmo para a extensão “Robot Code”:

E para a extensão “Material Icon Theme” (essa é meramente perfumaria, mas pedimos para instalar apenas para facilitar o reconhecimento o arquivo do Robot):

3. Antes de sair automatizando tudo, é necessário realizar algumas configurações para que lá na frente você não se frustre com possíveis erros. Para evitar isso, bora configurar corretamente a sua IDE!

Primeiro você precisa acessar a paleta de comandos, isso pode ser feito de duas formas, clicando na engrenagem no canto inferior esquerdo, ou pressionando Ctrl + Shift + P.

Depois digite Python e clique em Python: Select Interpreter, e selecione Python 3.X (A versão pode variar dependendo do ambiente e de qual versão você baixou).

Agora com o ambiente configurado, você está pronto para iniciar a escrita dos seus testes automatizados!

Criando a pasta do projeto e o arquivo de automação do Robot

Para poder organizar o projeto, sugerimos que crie uma pasta onde os arquivos serão salvos.

Primeiro, crie uma pasta dentro do seu computador, pode ser uma qualquer, qualquer nome, its up to you!

Após isso, com o VS Code aberto, clique em “Open Folder” e selecione a pasta criada:

Você também pode acessar a mesma opção “Open Folder” através do menu “File”.

Com ele aberto, você irá ver um lado esquerdo… vazio. Assim, chegou a hora de criarmos o arquivo .robot onde colocaremos nossos códigos.

Para isso, clique com o botão direito e selecione “New File”:

Após isso, crie o arquivo com nome que desejar, porém sua extensão precisa ser “.robot”.

Feito isso, você vera que o ícone do arquivo (graças a última extensão que instalamos) virará uma pequena carinha de robô.

E pronto, temos o arquivo que o Robot Framework aceita, no padrão correto, pronto para nosso código.

Instalando as bibliotecas

Agora é necessário instalar as bibliotecas que incorporam a automação e os comandos de Mobile, Web e Desktop no Robot.

Para Web, o Robot possui bibliotecas tanto do Selenium quanto do Playwright. Nesse artigo, nós vamos usar a Playwright.

O seu github, junto a sua documentação, é esse:

GitHub - MarketSquare/robotframework-browser: Robot Framework Browser library powered by…

Para instalar, temos que:

• Instalar o node.js (https://nodejs.org/en/download/) — recomendamos a versão LTS
• Rodar o seguinte comando no VS Code usando seu terminal (no menu superior clique em Terminal > New Terminal):

pip install robotframework-browser

• Instalar dependências do node.js usando o seguinte comando no Power Shell:

rfbrowser init

Para Mobile, temos a biblioteca do Appium, famoso framework de automação mobile.

O github dessa biblioteca, junto com toda sua documentação, é esse:

GitHub - serhatbolsu/robotframework-appiumlibrary: AppiumLibrary is an appium testing library for…

Para instalar, temos que dar o seguinte comando no terminal:

pip install --upgrade robotframework-appiumlibrary

Para desktop, vamos usar também o Appium.

Com tudo instalado, vamos para a parte principal, um exemplo da automação de cada um deles para vocês verem a diferença com relação a outros frameworks.

Nesse texto nós vamos mostrar exemplos de 3 automações diferentes usando Robot: Mobile, Desktop e Web.

Mobile

O cenário que vamos mostrar aqui é o seguinte:

1. Abrir o menu de aplicativos
2. Pesquisar por Gacebook na barra de pesquisas (sim, Gacebook)
3. Conferir se Facebook é exibido como resultado

Esse é o código que temos desse cenário usando Appium + Java (tiramos de propósito algumas partes do código para ele ficar “menor”):

DesiredCapabilities desiredCapabilities = new DesiredCapabilities();

        desiredCapabilities.setCapability("platformName", "Android");
        desiredCapabilities.setCapability("platformVersion", "12");
        desiredCapabilities.setCapability("skipDeviceInitialization", true);
        desiredCapabilities.setCapability("skipServerInstallation", true);

    try {
            driver = new AndroidDriver<MobileElement>(new URL("http://localhost:4723/wd/hub"),desiredCapabilities);
        } catch (MalformedURLException e) {
            e.printStackTrace();

    
    // Faz swype para abrir o menu de aplicativos
    Dimension size = driver.manage().window().getSize();
        int x = size.width/2;
        int y_init = (int) (size.height*0.9);
        int y_end = (int) (size.height*0.1);

        new TouchAction(driver)
                .press(PointOption.point(x, y_init))
                .waitAction(WaitOptions.waitOptions(Duration.ofMillis(500)))
                .moveTo(PointOption.point(x, y_end))
                .release()
                .perform();

        // Clica no menu de busca
        driver.findElementById("com.sec.android.app.launcher:id/app_search_edit_text").click();

        // Digita 'Gacebook'
        driver.findElementById("com.samsung.android.app.galaxyfinder:id/edit_search").clear();
        driver.findElementById("com.samsung.android.app.galaxyfinder:id/edit_search").click();
        driver.findElementById("com.samsung.android.app.galaxyfinder:id/edit_search").sendKeys("Gacebook");

        driver.hideKeyboard();

        // Pega o resultado e faz a validação
        String text = driver.findElementById("com.samsung.android.app.galaxyfinder:id/app_label").getText();
        assertEquals("Facebook", text);

Vejam a quantidade enorme de linhas e termos que, se o usuário não entender de programação e da linguagem em si, pode não ser de fácil compreensão.

E aqui temos o código usando Robot, utilizando AppiumLibrary:

*** Settings ***
Library    AppiumLibrary


*** Test Cases ***
Should Search Facebook in Menu Apps
    Open Application    http://127.0.0.1:4723  platformName=Android  platformVersion=12    automationName=UiAutomator2
    Set Appium Timeout    20
    Swipe By Percent    50  90  50  10    duration=500
    Click Element    com.sec.android.app.launcher:id/app_search_edit_text
    Wait Until Page Contains Element    com.samsung.android.app.galaxyfinder:id/edit_search
    Input Text    com.samsung.android.app.galaxyfinder:id/edit_search   Gacebook
    Hide Keyboard
    Element Should Contain Text    com.samsung.android.app.galaxyfinder:id/app_label    Facebook
    Close Application

Desktop

O cenário para esse teste é bem simples e consiste em:

1. Abrir a Calculadora do Windows
2. Clicar nos números 1 e 0 para formar o numero 10.
3. Clicar no sinal “+” para adicionar a função de soma.
4. Clicar nos números 1 e 0 para formar o numero 10.
5. E clicar no “=” para mostrar o resultado da soma.
6. Conferir se o resultado é 20.

Em C#, o código utilizando Appium.WebDriver:

using System;
using OpenQA.Selenium;
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Enums;
using OpenQA.Selenium.Appium.Windows;

class Program
{
    static void Main(string[] args)
    {
        // Configuração do driver do Appium
        AppiumOptions options = new AppiumOptions();
        options.AddAdditionalCapability(MobileCapabilityType.PlatformName, "Windows");
        options.AddAdditionalCapability("app", "Microsoft.WindowsCalculator_8wekyb3d8bbwe!App");

        WindowsDriver<WindowsElement> driver = new WindowsDriver<WindowsElement>(new Uri("http://127.0.0.1:4723"), options);

        // Esperar a calculadora abrir
        WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
        wait.Until(ExpectedConditions.ElementExists(By.Id("num1Button")));

        // Clicar nos botões
        driver.FindElementById("num1Button").Click();
        driver.FindElementById("num0Button").Click();
        driver.FindElementById("plusButton").Click();
        driver.FindElementById("num1Button").Click();
        driver.FindElementById("num0Button").Click();
        driver.FindElementById("equalButton").Click();

        // Obter o resultado
        string result = driver.FindElementById("CalculatorResults").Text;

        // Verificar se o resultado é igual a 20
        if (result == "20")
        {
            Console.WriteLine("O resultado está correto: 20");
        }
        else
        {
            Console.WriteLine("O resultado está incorreto: " + result);
        }

        // Fechar a calculadora
        driver.Quit();
    }
}

E aqui temos o código usando Robot, também utilizando AppiumLibrary:

*** Settings ***
Library    AppiumLibrary

*** Variables ***
${appium_server}    http://localhost:4723/wd/hub
${desired_capabilities}    platformName=Windows
${app_path}    Microsoft.WindowsCalculator_8wekyb3d8bbwe!App

*** Test Cases ***
Abrir Calculadora e Realizar Soma
    Open Application    ${appium_server}    ${desired_capabilities}    app=${app_path}
    Wait Until Page Contains Element    name=Calculator
    Click Element    accessibility_id=num1Button
  Click Element    accessibility_id=num0Button
    Click Element    accessibility_id=plusButton
    Click Element    accessibility_id=num1Button
    Click Element    accessibility_id=num0Button
    Click Element    accessibility_id=equalButton
    ${result}    Get Text    accessibility_id=CalculatorResults
    Should Be Equal As Strings    ${result}    Display is 20
    Close Application

Para executar o seu código automatizado usando Robot em aplicações desktop é necessário instalar um driver chamado WinAppDriver que pode ser considerado como uma API do WebDriver. Ele é uma estrutura que consiste em bibliotecas que podem ser integradas a um executor de testes que suporta o Appium.

Para realizar o download, clique neste link direto: (https://github.com/microsoft/WinAppDriver/releases/download/v1.2.1/WindowsApplicationDriver_1.2.1.msi), após baixar, realize a instalação!

Uma vez instalado, você deve navegar até o seguinte diretório:

C:\Program Files (x86)\Windows Application Driver,

E executar a aplicação WinAppDriver como administrador. (Recomendamos que você crie um atalho da aplicação na sua área de trabalho ou taskbar, para não ter que repetir esse processo toda vez 🙂).

Web

Aqui vamos com um cenário mais simples, fazer login:

1. Entrar no site https://saucedemo.com
2. Entrar com usuário e senha
3. Verificar se o login foi feito

Esse é o código em Python usando Playwright

from playwright.sync_api import Page

def test_order_by(page: Page) -> None:
    page.goto('https://www.saucedemo.com/')
    page.get_by_placeholder("Username").fill("standard_user")
    page.locator('[name="password"]').fill("secret_sauce")
    page.locator('[id="login-button"]').click()
    assert page.locator('[class="title"]').inner_text() == "Products"

E aqui temos o mesmo código usando Robot com Playwright:

*** Settings ***
Library    Browser

*** Test Cases ***
Should Login to SauceDemo webSite
    New Browser     chromium    headless=false
    New Page    https://www.saucedemo.com/
    Type Text    id=user-name    standard_user
    Type Text    id=password    secret_sauce
    Click    id=login-button 
    Get Text    span.title    equal    Products

Vejam, nos 3 exemplos, a diferença tanto em quantidade de linhas, quanto em legibilidade. Tirando os locators (com.sec, com.samsung….), o usuário tem uma boa noção do que está se passando.

Reparem que dentro dos testes nós temos ‘Open Application’, ‘Input Text’, ‘Click’…isso são as keywords que comentamos que já vieram criadas e prontas para serem usadas direto das bibliotecas do Appium e Playwright que instalamos anteriormente. Nada disso fomos nós que criamos.

Execução

Para rodar cada um deles (recomendamos que tenham arquivos diferentes para cada um dos códigos), usa-se o seguinte comando no terminal:

robot + caminho ou nome do arquivo
ex: robot .\web_artigo.robot

Como para rodar o código de Mobile envolve mais do que apenas o que colocamos nesse artigo (são necessários ainda outros programas rodando junto, e mais configurações do que mostramos), recomendamos rodar apenas o código web e desktop. Estes sim, apenas com o que colocamos aqui, é possível de ser rodado. Mas, mesmo assim, mostraremos a execução da automação de todas:

• No nosso caso de Mobile, ficaria algo assim:

• Com desktop, ficaria assim:

• E Web

Vejam que, no próprio terminal, o Robot já nos fala qual status de cada teste, e, o mais legal, ele automaticamente gera um report, que são essas 3 últimas linhas da imagem acima. Ao abrir o arquivo ‘report.html’, nós temos um relatório completo com status de todos os testes, quantos passaram, quantos falharam.

E é um report navegável. Ao clicar, por exemplo, no final desse print, no ‘Should Login…’, nós somos levados a uma outra página onde temos detalhes daquele testes em específico.

Conclusão

O Robot é uma ferramenta bastante completa e versátil. Como viram, ela pode facilitar bastante na hora de automatizar por conta das suas keywords. Com elas, quem não gosta de programar pode começar rapidamente a criar cenários de teste básicos (deixando claro que ter alguma compreensão de programação pode ser benéfico, especialmente quando se trata de casos de teste mais complexos ou de criar palavras-chave personalizadas).

Porém Robot não é limitado às keywords que já estão nas bibliotecas. Podemos usar operadores lógicos, laços de repetição e etc, assim como em linguagens de programação, ou até rodar scripts externos escritos em Python tudo dentro do Robot. Conseguimos estruturar o seu código em Page Object, possui report próprio…Enfim, isso é o Robot.

Esperamos que esse artigo tenha despertado em você uma nova visão sobre automação, a de que ela pode não ser tão complicada e que o Robot pode ser uma barreira de entrada consideravelmente mais baixa em comparação com outras ferramentas de automação.

Caso tenham interesse, esse é o site oficial: https://robotframework.org/

Esperamos que tenha gostado, e nos vemos numa próxima!

Muito obrigado!