Fundamentos de Automação de Testes com Python

01Variáveis, Tipos, Condicionais, Loops e Funções

Variáveis

Uma variável é uma caixa com um nome, onde guardas um valor para usares mais tarde. Em Python, crias uma variável só ao dares-lhe um nome e um valor:

nome = "Ana Ferreira"
idade = 28
aprovado = True
print(nome, idade, aprovado)

• Não precisas de dizer antecipadamente que tipo de valor a variável vai guardar: o Python percebe sozinho.
• Usa nomes que digam o que a variável guarda (nome, não x). Vais ler este código muitas vezes mais do que o escreves.
• O sinal de igual aqui não significa "igual a" como em matemática; significa "guarda isto nesta caixa".

Tipos de dados

Cada valor tem um tipo, e o tipo determina o que podes fazer com ele. Os quatro que vais usar constantemente:

nome = "Ana Ferreira"   # str: texto, sempre entre aspas
idade = 28               # int: número inteiro
altura = 1.68             # float: número com casas decimais
aprovado = True           # bool: só pode ser True ou False
print(nome, idade, altura, aprovado)

Podes sempre confirmar o tipo de uma variável com type():

idade = 28
print(type(idade))   # <class 'int'>

Um erro muito comum de principiante: "28" (com aspas) é texto, não é o número 28. "28" + 1 dá erro: não podes somar texto com número. Se precisares de converter, usa int("28") ou str(28).

Condicionais (if / else)

Um condicional é uma instrução que só corre se uma condição for verdadeira, como "se chover, levo o guarda-chuva". Em Python:

idade = 16

if idade >= 18:
    print("Pode votar")
else:
    print("Ainda não pode votar")

O bloco a seguir ao if só corre se a condição for verdadeira. O bloco a seguir ao else só corre se for falsa. Repara na indentação (os espaços antes de print). Em Python, a indentação não é estética, é o que define o que pertence a cada bloco. Se a indentação estiver errada, o código não funciona como esperas, mesmo sem dar erro.

Para mais do que duas hipóteses, usa elif ("else if"):

nota = 14

if nota >= 18:
    print("Excelente")
elif nota >= 10:
    print("Aprovado")
else:
    print("Reprovado")

Loops

Um loop é uma instrução que repete uma ação várias vezes, sem teres de a escrever repetidamente. Os dois tipos que vais usar:

# for: quando sabes por quantos elementos vais passar
nomes = ["Ana", "Bruno", "Carla"]
for nome in nomes:
    print(nome)

# while: quando repetes até uma condição deixar de ser verdadeira
tentativas = 0
while tentativas < 3:
    print("A tentar...")
    tentativas = tentativas + 1

for é o que vais usar mais: em QA automation, quase sempre estás a percorrer uma lista de coisas para verificar (linhas de um ficheiro, resultados de um teste, registos de uma base de dados).

Funções

Uma função é um bloco de código com nome, que podes reutilizar sempre que precisares, como uma receita. Defines uma função com def:

def saudacao(nome):
    return f"Olá, {nome}!"

mensagem = saudacao("Ana")
print(mensagem)   # Olá, Ana!

nome aqui é um parâmetro: um valor que entra na função de fora. return é o que a função devolve a quem a chamou. Sem return, a função ainda corre, mas não devolve nada útil para usares depois.

Repara em f"Olá, {nome}!", chama-se f-string: o f antes das aspas permite meter variáveis diretamente dentro do texto, entre chavetas. Vais usar isto constantemente para construir mensagens.

Escrever código como funções, em vez de uma sequência solta de instruções, é o que te vai permitir, já no exercício deste módulo, reutilizar a mesma lógica de validação para emails, datas e IDs sem copiar e colar três vezes.

02O Terminal, e os Tipos de Teste

O terminal

O terminal é a janela onde escreves comandos de texto para o computador executar, em vez de clicares com o rato. É estranho nas primeiras vezes e depois torna-se o sítio onde passas mais tempo como QA automation.

cd nome-da-pasta      # entrar numa pasta (cd = "change directory")
cd ..                 # subir uma pasta
dir                   # listar ficheiros da pasta atual (Windows)
ls                    # listar ficheiros da pasta atual (Mac/Linux)
python nome_do_ficheiro.py    # correr um script Python

Para o exercício deste módulo, o fluxo típico é: abrir o terminal, entrar (cd) até à pasta onde guardaste o script e os ficheiros de dados, e depois correr python validador_de_dados.py. Se o terminal disser que não encontra o ficheiro, o problema quase sempre é estares na pasta errada. Confirma com dir/ls o que está mesmo à tua volta antes de assumir que o código tem um erro.

Tipos de teste: funcional, regressão, exploratório

Três formas diferentes de testar, cada uma respondendo a uma pergunta diferente.

• Teste funcional: verificar se uma funcionalidade faz o que devia fazer. Pergunta: "isto faz o que prometeu?" Exemplo: confirmar que um formulário de login realmente deixa entrar com credenciais certas.
• Teste de regressão: verificar se uma alteração nova não estragou algo que já funcionava. Pergunta: "o que já funcionava, continua a funcionar?" Exemplo: depois de corrigires um bug no checkout, confirmas que o login continua a funcionar.
• Teste exploratório: usar a aplicação sem um guião fixo, à procura de problemas inesperados. Pergunta: "o que é que ainda não pensei em testar?" Não segues uma lista: navegas, experimentas casos estranhos (um email sem "@", um campo vazio, colar um texto gigante) só para ver o que acontece.

O validador que vais construir hoje é, no fundo, um teste funcional automatizado: em vez de olhares linha a linha para um ficheiro de dados a confirmar se cada valor tem o formato certo, escreves um script que faz essa verificação por ti, e que podes correr outra vez amanhã, com dados diferentes, sem repetir o trabalho manual.

03Níveis de Teste, e o Ciclo de Vida de um Defeito

Níveis de teste: unitário, integração, sistema, aceitação

Estes quatro níveis diferem na escala do que estás a testar, de uma peça isolada até ao produto inteiro.

• Teste unitário: testar a mais pequena parte possível do código, isolada do resto. Exemplo: testar só a função saudacao() do capítulo anterior, sem depender de mais nada.
• Teste de integração: testar se duas partes do sistema funcionam bem quando ligadas entre si. Exemplo: a função que valida um email funciona bem quando ligada à função que lê o ficheiro CSV?
• Teste de sistema: testar a aplicação completa, do início ao fim. Exemplo: correr o validador_de_dados.py inteiro, do ficheiro de entrada ao resultado final impresso.
• Teste de aceitação: confirmar que o produto cumpre o que o cliente pediu. Exemplo: se o pedido foi "um script que me diga quais das minhas 100 linhas de dados têm erros", o teste de aceitação é mesmo isso: dás-lhe 100 linhas reais e confirmas que o resultado é útil e correto.

Não são níveis que se "escolhem". Um projeto real normalmente tem os quatro, cada um a apanhar problemas que os outros não apanhariam sozinhos.

Ciclo de vida de um defeito

Quando encontras um problema (um "defeito" ou "bug"), ele não desaparece só por o teres reportado; passa por estados até estar mesmo resolvido.

1. Reportado: o problema foi identificado e escrito (o que vais praticar no capítulo 8, com o bug report).
2. Em análise: alguém confirma que é mesmo um problema (e não, por exemplo, um mal-entendido sobre como a funcionalidade deveria funcionar).
3. Corrigido: a alteração no código foi feita.
4. Verificado: confirma-se que a correção realmente resolveu o problema, e que não introduziu um novo.
5. Fechado: o ciclo termina.

Vais viver este ciclo já no exercício deste módulo, em miniatura: quando o teu validador disser que um valor é inválido, isso é "reportado". Confirmares porque é inválido é "em análise". Se fores tu a corrigir o dado de origem, isso é "corrigido", e correr o validador outra vez para confirmar é "verificado".

04Prática: o Teu Primeiro Validador

Antes de começares o Exercício 1, cria um ficheiro chamado dados_teste.csv, na mesma pasta onde vais escrever o script, com este conteúdo (copia exatamente, inclui casos válidos e inválidos de propósito):

tipo,valor
email,ana.ferreira@exemplo.com
email,bruno@@exemplo.com
email,carla.exemplo.com
email,diogo@exemplo
data,2026-09-30
data,30-09-2026
data,2026-9-3
data,2026/09/30
id,QA1234
id,qa_1234
id,QA
id,QA123456789012

import csv


def validar_email(valor):
    if valor.count("@") != 1:
        return False
    if valor.startswith("@") or valor.endswith("@"):
        return False
    posicao_arroba = valor.index("@")
    parte_depois = valor[posicao_arroba + 1:]
    return "." in parte_depois


def validar_data(valor):
    if len(valor) != 10:
        return False
    if valor[4] != "-" or valor[7] != "-":
        return False
    partes = valor.split("-")
    if len(partes) != 3:
        return False
    ano, mes, dia = partes
    return ano.isdigit() and mes.isdigit() and dia.isdigit()


def validar_id(valor):
    if len(valor) < 5 or len(valor) > 12:
        return False
    return valor.isalnum()


def validar(tipo, valor):
    if tipo == "email":
        return validar_email(valor)
    if tipo == "data":
        return validar_data(valor)
    if tipo == "id":
        return validar_id(valor)
    return False


def main():
    validos = 0
    invalidos = 0

    with open("dados_teste.csv", encoding="utf-8") as ficheiro:
        leitor = csv.DictReader(ficheiro)
        for linha in leitor:
            tipo = linha["tipo"]
            valor = linha["valor"]
            resultado = validar(tipo, valor)

            if resultado:
                validos += 1
                print(f"OK    [{tipo}] {valor}")
            else:
                invalidos += 1
                print(f"FALHA [{tipo}] {valor}")

    print(f"\n{validos} válidos, {invalidos} inválidos")


if __name__ == "__main__":
    main()

Antes deste exercício, cria também um ficheiro log.txt na mesma pasta, com este conteúdo:

2026-08-01 09:12:03 INFO  Servidor iniciado
2026-08-01 09:12:05 INFO  Ligação à base de dados estabelecida
2026-08-01 09:14:22 INFO  Pedido recebido: GET /utilizadores
2026-08-01 09:14:22 ERROR Timeout ao ligar à base de dados
2026-08-01 09:15:01 INFO  Pedido recebido: POST /login
2026-08-01 09:15:02 ERROR Credenciais inválidas para o utilizador 'ana'
2026-08-01 09:16:40 INFO  Pedido recebido: GET /produtos
2026-08-01 09:16:41 INFO  Resposta enviada: 200 OK
2026-08-01 09:18:12 ERROR Ficheiro de configuração não encontrado
2026-08-01 09:19:00 INFO  Servidor encerrado

def encontrar_erros(caminho_ficheiro):
    total_linhas = 0
    erros = []

    with open(caminho_ficheiro, encoding="utf-8") as ficheiro:
        for numero, linha in enumerate(ficheiro, start=1):
            total_linhas += 1
            if "ERROR" in linha:
                erros.append((numero, linha.strip()))

    return erros, total_linhas


def main():
    erros, total_linhas = encontrar_erros("log.txt")

    for numero, linha in erros:
        print(f"Linha {numero}: {linha}")

    print(f"\n{len(erros)} erro(s) em {total_linhas} linhas")


if __name__ == "__main__":
    main()

05Listas, Dicionários e Ficheiros CSV

Listas

Uma lista é uma sequência ordenada de valores, como uma lista de compras: os itens têm uma ordem, e podes ter valores repetidos. Em Python, cria-se entre parênteses retos:

produtos = ["teclado", "rato", "monitor"]

print(produtos[0])       # teclado: o primeiro item está na posição 0
print(len(produtos))     # 3: quantos itens a lista tem

produtos.append("webcam")
print(produtos)           # ['teclado', 'rato', 'monitor', 'webcam']

produtos[0] acede ao item na posição 0: a contagem começa em 0, tal como já viste ao indexar caracteres de uma string no capítulo 1. append() acrescenta um item ao fim da lista. E percorrer uma lista item a item é simples:

produtos = ["teclado", "rato", "monitor"]
for produto in produtos:
    print(f"Produto: {produto}")

Dicionários

Um dicionário é uma coleção de pares nome-valor, como uma agenda telefónica: procuras por um nome (a chave) e encontras a informação associada (o valor). Em Python, cria-se entre chavetas, com dois pontos a separar cada chave do seu valor:

produto = {"id": "1", "nome": "Teclado mecânico", "preco": "29.90"}

print(produto["nome"])       # Teclado mecânico
produto["preco"] = "24.90"   # atualizar um valor existente
print(produto)

Ao contrário de uma lista, não acedes a um dicionário por posição; acedes pelo nome da chave. Uma combinação muito comum em QA automation é uma lista de dicionários: vários registos, cada um com os mesmos campos.

produtos = [
    {"id": "1", "nome": "Teclado mecânico", "preco": "29.90"},
    {"id": "2", "nome": "Rato sem fios", "preco": "9.90"},
]

for produto in produtos:
    print(produto["nome"], "->", produto["preco"])

É exatamente esta forma (uma lista, com um dicionário por linha) que vais obter ao ler um ficheiro CSV em Python.

Ler e escrever ficheiros CSV

CSV é a sigla de comma-separated values, valores separados por vírgula. É um ficheiro de texto simples onde cada linha representa um registo, e a primeira linha costuma ser o cabeçalho. Python já vem com um módulo pronto para ler isto, chamado csv; não precisas de instalar nada. A ferramenta mais prática é csv.DictReader, que lê cada linha diretamente como um dicionário, usando o cabeçalho como chaves:

import csv

with open("produtos.csv", encoding="utf-8") as ficheiro:
    leitor = csv.DictReader(ficheiro)
    for linha in leitor:
        print(linha["id"], linha["produto"], linha["preco"])

Repara no encoding="utf-8" ao abrir o ficheiro: garante que acentos, como em "mecânico", são lidos corretamente. Para escrever é parecido, com csv.DictWriter:

import csv

produtos = [
    {"id": "1", "produto": "Teclado mecânico", "preco": "29.90"},
    {"id": "2", "produto": "Rato sem fios", "preco": "9.90"},
]

with open("saida.csv", "w", encoding="utf-8", newline="") as ficheiro:
    colunas = ["id", "produto", "preco"]
    escritor = csv.DictWriter(ficheiro, fieldnames=colunas)
    escritor.writeheader()
    escritor.writerows(produtos)

• "w" (de write, escrever) em vez de nada: sem isto, open() assume que queres ler o ficheiro, e o teu código falha.
• newline="" evita linhas em branco extra entre cada registo no Windows. Basta copiares esta linha sempre que escreveres um CSV.
• escritor.writeheader() escreve a linha de cabeçalho primeiro. Sem isto, o ficheiro não diz o que cada coluna significa.

06Comparar o Esperado com o Obtido

No fundo, isto é o que QA automation faz a maior parte do tempo: comparar o que esperavas obter com o que realmente obtiveste, e assinalar as diferenças. É a mesma lógica de conferires o talão de compras com o que está mesmo dentro do saco: se o talão diz 3 artigos e só encontras 2 no saco, descobriste um problema sem teres de confiar de olhómetro.

Em Python, a comparação mais simples é entre dois valores, com dois sinais de igual:

esperado = 29.90
obtido = 34.90

if esperado == obtido:
    print("OK: valores iguais")
else:
    print(f"DIFERENÇA: esperado {esperado}, obtido {obtido}")

Na prática, raramente comparas só um valor solto; comparas registos inteiros, como uma linha de um CSV. Nesse caso, comparas campo a campo, e juntas os nomes dos campos que forem diferentes:

def comparar_linhas(linha_esperada, linha_obtida):
    diferencas = []
    for campo in linha_esperada:
        if linha_esperada[campo] != linha_obtida[campo]:
            diferencas.append(campo)
    return diferencas


linha_esperada = {"id": "1", "produto": "Teclado mecânico", "preco": "29.90"}
linha_obtida = {"id": "1", "produto": "Teclado mecânico", "preco": "34.90"}

diferencas = comparar_linhas(linha_esperada, linha_obtida)
print(diferencas)   # ['preco']: só o preço é diferente

07Git, Sem Mistério

Até agora, sempre que alteraste um script, a versão anterior desapareceu: escreveste por cima dela. O Git é uma ferramenta que guarda o histórico de alterações do teu código: cada versão fica registada, e podes sempre voltar atrás se algo correr mal, como um botão de "undo" que continua a funcionar mesmo depois de fechares o computador e voltares no dia seguinte.

O ciclo básico tem cinco comandos, escritos no terminal, dentro da pasta do teu projeto:

git init
git add .
git commit -m "Primeira versão do comparador"
git remote add origin https://github.com/o-teu-utilizador/comparador-resultados.git
git push -u origin main

• git init: transforma a pasta atual num repositório Git. Só corres isto uma vez, no início do projeto.
• git add .: prepara ficheiros para serem guardados. O ponto significa "tudo o que está nesta pasta".
• git commit -m "...": guarda mesmo uma fotografia do projeto no histórico, com uma mensagem a explicar o que mudou.
• git remote add origin ...: liga o teu repositório local a um repositório vazio criado antes no GitHub.
• git push -u origin main: envia os commits guardados localmente para o GitHub. O -u só é necessário na primeira vez.

Antes de correres o git remote add, precisas de ter criado esse repositório vazio no site do GitHub, normalmente com o botão verde "New repository".

Um comando extra que vale a pena conheceres já: git status. A qualquer momento, diz-te o que mudou desde o último commit, e o que ainda não foi preparado com git add.

08Como Escrever um Bug Report

Encontraste uma diferença entre o esperado e o obtido. E agora? Se guardares isso só na tua cabeça, essa informação perde-se, e quem tem de corrigir o problema não sabe por onde começar. Um bug report é um documento que descreve um problema de forma clara o suficiente para outra pessoa, ou tu próprio duas semanas depois, perceber exatamente o que aconteceu, sem teres de estar ao lado a explicar.

Um bug report útil tem sempre estes campos:

• Título: um resumo numa linha, específico o suficiente para se distinguir de outros problemas. "O preço está errado" é fraco; "Preço do produto id 1 aparece como 34.90€ em vez de 29.90€" já diz logo do que se trata.
• Passos para reproduzir: a sequência exata de ações para chegar ao problema, numerada.
• Esperado: o que devia ter acontecido.
• Obtido: o que realmente aconteceu.
• Severidade: o quão grave é o problema.

Repara como isto encaixa diretamente no ciclo de vida de um defeito do capítulo 3: escrever o bug report é o passo "reportado". É o ponto de partida de tudo o resto.

09Prática: o Teu Primeiro Comparador

Antes de escreveres o comparador, cria dois ficheiros na mesma pasta: baseline.csv e atual.csv. São deliberadamente parecidos mas não iguais, para teres o que comparar. Conteúdo de baseline.csv:

id,produto,preco
1,Teclado mecânico,29.90
2,Rato sem fios,9.90
3,Monitor 24 polegadas,139.00
4,Auscultadores Bluetooth,19.50
5,Webcam HD,24.90
6,Suporte para portátil,15.00

Conteúdo de atual.csv:

id,produto,preco
1,Teclado mecânico,34.90
2,Rato sem fios,9.90
3,Monitor 24 polegadas,139.00
5,Webcam HD,24.90
6,Suporte para portátil,15.00
7,Rato gaming RGB,49.90

import csv


def ler_csv_por_id(caminho):
    linhas_por_id = {}
    with open(caminho, encoding="utf-8") as ficheiro:
        leitor = csv.DictReader(ficheiro)
        for linha in leitor:
            linhas_por_id[linha["id"]] = linha
    return linhas_por_id


def comparar(baseline, atual):
    iguais = 0
    diferentes = []
    em_falta = []
    novas = []

    for id_linha, linha_baseline in baseline.items():
        if id_linha not in atual:
            em_falta.append(id_linha)
            continue

        linha_atual = atual[id_linha]
        diferencas_campos = []
        for campo in linha_baseline:
            if campo == "id":
                continue
            if linha_baseline[campo] != linha_atual[campo]:
                diferencas_campos.append(campo)

        if diferencas_campos:
            diferentes.append((id_linha, diferencas_campos))
        else:
            iguais += 1

    for id_linha in atual:
        if id_linha not in baseline:
            novas.append(id_linha)

    return iguais, diferentes, em_falta, novas


def main():
    baseline = ler_csv_por_id("baseline.csv")
    atual = ler_csv_por_id("atual.csv")

    iguais, diferentes, em_falta, novas = comparar(baseline, atual)

    for id_linha, campos in diferentes:
        linha_base = baseline[id_linha]
        linha_atual = atual[id_linha]
        print(f"DIFERENÇA id={id_linha}:")
        for campo in campos:
            print(f"   {campo}: esperado {linha_base[campo]!r}, obtido {linha_atual[campo]!r}")

    for id_linha in em_falta:
        print(f"EM FALTA id={id_linha}: existe no baseline, não existe no atual ({baseline[id_linha]['produto']})")

    for id_linha in novas:
        print(f"NOVA id={id_linha}: não existe no baseline, existe no atual ({atual[id_linha]['produto']})")

    print(f"\n{iguais} iguais, {len(diferentes)} diferente(s), {len(em_falta)} em falta, {len(novas)} nova(s)")


if __name__ == "__main__":
    main()

git init
git add .
git commit -m "Primeira versão do comparador de resultados"
git remote add origin https://github.com/o-teu-utilizador/comparador-resultados.git
git push -u origin main

# Bug Report: Exemplo real

**Título:** Preço do produto id 1 ("Teclado mecânico") está errado em atual.csv

**Passos para reproduzir:**
1. Abrir baseline.csv e confirmar o preço do produto com id 1: 29.90€.
2. Abrir atual.csv e confirmar o preço do mesmo produto (id 1): 34.90€.
3. Correr "python comparador.py" no terminal, dentro da pasta do projeto.
4. Observar a linha "DIFERENÇA id=1" no resultado impresso, com o campo preco assinalado.

**Esperado:** o preço do id 1 deveria ser 29.90€ em atual.csv, igual ao valor em baseline.csv.

**Obtido:** o preço aparece como 34.90€ em atual.csv, sem justificação conhecida.

**Severidade:** Média. O valor mostrado está incorreto e afeta diretamente o que o cliente vê, mas não impede a aplicação de funcionar.