ideiasti

Bem vindo ao Blog ideiasti, um blog voltado para Qualidade de Software e Engenharia de Software

Tipos de Testes de Software: Guia Completo com Exemplos Práticos

Testes Automatizados · 6 de julho de 2026

📖 13 min de leitura

Introdução aos Tipos de Testes de Software

Os testes de software são uma atividade crítica no ciclo de desenvolvimento de sistemas. Compreender os diferentes tipos de testes e quando aplicá-los é fundamental para garantir a qualidade e confiabilidade das aplicações.

Pirâmide de Testes - Hierarquia de Testes

Este guia completo apresenta uma categorização detalhada dos principais tipos de testes de software, suas finalidades, características e quando cada um deve ser utilizado no seu projeto.

Categorização Geral dos Testes

Os testes de software podem ser divididos em duas categorias principais:

1. Testes Funcionais

Verificam se o software funciona conforme especificado, testando funcionalidades específicas e requisitos do negócio.

2. Testes Não-Funcionais

Avaliam características como performance, segurança, usabilidade e confiabilidade, que não estão relacionadas a funcionalidades específicas.

Testes Funcionais: Garantindo o Comportamento Correto

Teste Unitário: A Base de Tudo

O teste unitário é o tipo mais básico de teste, onde cada unidade de código (geralmente uma função ou método) é testada isoladamente. Esta atividade é realizada durante as etapas de desenvolvimento pelos próprios desenvolvedores.

Objetivos dos Testes Unitários

  • Identificar falhas em componentes individuais – Detectar problemas cedo
    1. Garantir que cada função trabalha corretamente – Validação granular
    2. Facilitar a detecção precoce de defeitos – Redução de custos
    3. Documentar o código – Testes como especificação executável
    4. Permitir refactoring seguro – Confiança ao modificar código

    Exemplo Prático em Python (pytest)

    def calcular_desconto(valor_original, percentual):
    """Calcula o valor do desconto."""
    if percentual  100:
        raise ValueError("Percentual deve estar entre 0 e 100")
    desconto = valor_original * (percentual / 100)
    return valor_original - desconto


    def test_calcular_desconto_10_porcento():
        assert calcular_desconto(100, 10) == 90
    


    def test_calcular_desconto_50_porcento():
        assert calcular_desconto(200, 50) == 100
    


    def test_calcular_desconto_invalido():
        with pytest.raises(ValueError):
            calcular_desconto(100, 150)

    Frameworks Populares para Testes Unitários

    Linguagem Framework Características
    Java JUnit 5, TestNG Mais popular, extensível
    JavaScript Jest, Mocha Rápido, Mocking fácil
    Python pytest, unittest Sintaxe simples, fixtures
    C# xUnit, NUnit .NET ecosystem
    Go testing (stdlib) Simples, integrado

    Melhores Práticas para Testes Unitários

    ✅ Teste apenas uma coisa de cada vez – Um assert por teste é ideal
    ✅ Nomes descritivos – test_deve_retornar_erro_quando_usuario_invalido
    ✅ Independência – Testes não devem depender uns dos outros
    ✅ Rapidez – Unit tests devem executar em milissegundos
    ✅ Isolamento – Use mocks para dependências externas

    Teste de Integração: Verificando Conexões

    O teste de integração verifica a comunicação entre diferentes módulos ou componentes do sistema. Este tipo de teste é crucial para garantir que as partes do sistema funcionam corretamente quando combinadas.

    Características Principais

    1. Valida interfaces e interações entre componentes – Fluxo de dados correto
    2. Identifica problemas de comunicação – API mismatches, protocolos
    3. Pode ser realizado de forma incremental ou big-bang – Duas abordagens
    4. Testa camadas de persistência – Bancos de dados, APIs externas

    Estratégias de Integração

    ##### 1. Big-Bang Integration

    Todos os componentes são integrados simultaneamente e testados juntos.

    Vantagens:

    1. Simples de implementar

    2. Bom para sistemas pequenos

    Desvantagens:

    1. Difícil localização de erros

    2. Todos os módulos devem estar prontos

    ##### 2. Incremental Integration (Bottom-Up)

    Começa pelos módulos mais baixos e集成 progressivamente.

    Vantagens:

    1. Defeitos fáceis de isolar

    2. Feedback contínuo

    Desvantagens:

    1. Pode ter módulos de alto nível sem testes até o final

    ##### 3. Incremental Integration (Top-Down)

    Começa pelos módulos de mais alto nível e desce progressivamente.

    Vantagens:

    1. Interface do usuário testada primeiro

    2. Protótipo funcional rápido

    Desvantagens:

    1. Módulos de baixo nível simulados (stubs)

    Exemplo de Teste de Integração (REST API)

    import requests
import pytest


    class TestUserAPI:
        BASE_URL = "https://api.exemplo.com/v1"
    


    def test_criar_usuario(self):
            payload = {
                "nome": "João Silva",
                "email": "joao@exemplo.com",
                "senha": "senha123"
            }
            response = requests.post(f"{self.BASE_URL}/usuarios", json=payload)
    


    assert response.status_code == 201
            data = response.json()
            assert data["nome"] == payload["nome"]
            assert data["email"] == payload["email"]
            assert "id" in data
    


    def test_listar_usuarios(self):
            response = requests.get(f"{self.BASE_URL}/usuarios")
    


    assert response.status_code == 200
            assert isinstance(response.json(), list)

    Teste de Sistema: Visão Holística

    O teste de sistema avalia o software como um todo, verificando se todos os componentes funcionam juntos para atender aos requisitos definidos.

    O Que é Testado no Nível de Sistema?

    1. Integração entre todos os módulos
    2. Fluxos de negócio completos
    3. Conformidade com requisitos funcionais
    4. Interface com sistemas externos
    5. Performance do sistema integrado
    6. Segurança end-to-end

    Exemplo: Fluxo de E-commerce

    Usuário → Login → Navegação → Carrinho → Checkout → Pagamento → Confirmação
    ↓         ↓          ↓           ↓           ↓            ↓            ↓
 Cadastro   Session   Produtos    Estoque     Frete        Stripe     E-mail
   ↕          ↕         ↕          ↕          ↕            ↕          ↕
  DB        Redis     DB/API     DB         Correios      API       SMTP

    Cada seta representa um ponto de integração que deve ser testado no nível de sistema.

    Teste de Aceitação: Validando com o Cliente

    O teste de aceitação determina se um produto ou sistema atende às expectativas e requisitos do cliente. Este é frequentemente o último nível de teste antes da entrega正式.

    Pergunta Fundamental

    > “Estamos construindo o produto certo?”

    Tipos de Teste de Aceitação

    ##### 1. Teste de Aceitação do Usuário (UAT)

    Usuários finais testam o sistema em um ambiente semelhante ao de produção.

    ##### 2. Teste de Aceitação Operacional (OAT)

    Equipe de operações validabackup, recuperação, relatórios.

    ##### 3. Teste de Aceitação Contratual

    Verifica se o sistema atende aos critérios contratuais.

    Características do UAT

    1. Geralmente envolve cooperação ou feedback do cliente
    2. Atividade de validação com dados reais
    3. Foco na usabilidade e fluxo de negócio
    4. Pode revelar requisitos mal entendidos
    5. Último checkpoint antes do go-live

    Teste Funcional: Verificando Funcionalidades

    O teste funcional determina se um recurso ou sistema funciona corretamente sem problemas. Verifica o sistema em diferentes níveis para garantir que todos os cenários são cobertos.

    Pergunta Fundamental

    > “Estamos construindo o produto da forma certa?”

    Técnicas de Teste Funcional

    ##### 1. Teste Baseado em Requisitos

    1. Cada requisito tem casos de teste correspondentes

    2. Rastreabilidade entre requisitos e testes

    3. Cobertura completa

    ##### 2. Teste Baseado em Casos de Uso

    1. Cenários de usuário documentados

    2. Fluxos principais e alternativos

    3. Pré-condições e pós-condições

    ##### 3. Teste de Tabela de Decisão

    1. Combinações de condições e ações

    2. Útil para regras de negócio complexas

    ##### 4. Teste de Transição de Estado

    1. Mudanças de estado do sistema

    2. Diagramas de estado

    Testes Não-Funcionais: Avaliando Qualidade Oculta

    Teste de Desempenho: Rapidez e Estabilidade

    Performance Testing - Testes de Desempenho

    O teste de desempenho avalia a velocidade, responsividade e estabilidade do sistema sob carga de trabalho. É crítico para garantir que a aplicação atende aos SLAs (Service Level Agreements).

    Subtipo 1: Teste de Carga (Load Testing)

    Verifica o comportamento do sistema sob condições de carga esperadas.

    Métricas Coletadas:

    1. Tempo de resposta (média, p95, p99)

    2. Throughput (requisições por segundo)

    3. Utilização de recursos (CPU, memória, disco)

    4. Taxa de erros

    Ferramentas Populares:

    1. JMeter

    2. Gatling

    3. k6

    4. Locust

    Subtipo 2: Teste de Estresse (Stress Testing)

    Avalia os limites do sistema além da capacidade normal para identificar o ponto de quebra.

    Objetivos:

    1. Identificar capacidade máxima

    2. Verificar comportamento sob overload

    3. Medir tempo de recuperação

    4. Validar failovers

    Subtipo 3: Teste de Resistência (Soak Testing)

    Executa o sistema sob carga por períodos prolongados para identificar degradação gradual.

    Problemas Detectados:

    1. Memory leaks

    2. Conexões não fechadas

    3. Acúmulo de logs

    4. Degradação de performance

    Subtipo 4: Teste de Pico (Spike Testing)

    Avalia reações do sistema a picos súbitos de carga.

    Cenário Exemplo:

    Carga normal: 1000 usuários
    Pico: 5000 usuários em 10 segundos
    Recovery: Voltar para 1000 usuários

    Ferramentas de Teste de Desempenho

    Ferramenta Tipo Linguagem Melhor Para
    JMeter Open Source Java Enterprise, complexo
    Gatling Open Source Scala DevOps, CI/CD
    k6 Open Source JavaScript Moderno, extensível
    Locust Open Source Python Python teams
    LoadRunner Comercial Various Enterprise

    Exemplo de Teste de Carga com k6

    // script.js
import http from 'k6/http';
import { check, sleep } from 'k6';


    export const options = {
      stages: [
        { duration: '2m', target: 100 },  // Ramp-up
        { duration: '5m', target: 100 },  // Steady state
        { duration: '2m', target: 200 },  // Spike
        { duration: '5m', target: 200 },  // Steady state
        { duration: '2m', target: 0 },    // Ramp-down
      ],
      thresholds: {
        http_req_duration: ['p(95)<500'],  // 95{6727d158e4474b0847515bd23a8ee4bebd5f1aac7a18bc968e51d8985dccb442} das requisições < 500ms
        http_req_failed: ['rate<0.01'],     // Menos de 1{6727d158e4474b0847515bd23a8ee4bebd5f1aac7a18bc968e51d8985dccb442} de falhas
      },
    };
    


    export default function () {
      const res = http.get('https://api.exemplo.com/produtos');
      check(res, {
        'status é 200': (r) => r.status === 200,
        'tempo  r.timings.duration < 500,
      });
      sleep(1);
    }

    Teste de Segurança: Protegendo Dados e Sistemas

    Security Testing - Escudo de Segurança

    O teste de segurança identifica vulnerabilidades e garante proteção de dados. Em um mundo cada vez mais digital, a segurança é prioridade.

    Tipos de Testes de Segurança

    ##### 1. Teste de Penetração (Pen Test)

    Simula ataques para identificar vulnerabilidades antes que hackers maliciosos o façam.

    Metodologias:

    1. OWASP Testing Guide

    2. PTES (Penetration Testing Execution Standard)

    3. NIST SP 800-115

    Tipos de Pentest:

    1. Black Box: Sem conhecimento prévio

    2. White Box: Código e documentação

    3. Gray Box: Conhecimento parcial

    ##### 2. Varredura de Vulnerabilidade

    Identifica pontos fracos conhecidos através de scanning automatizado.

    Ferramentas:

    1. Nessus

    2. OpenVAS

    3. Qualys

    4. Nexpose

    ##### 3. Teste de Firewall e WAF

    Verifica configurações de segurança de firewalls e Web Application Firewalls.

    O que testar:

    1. Regras de firewall

    2. Block de IPs maliciosos

    3. Detecção de SQL Injection

    4. Proteção XSS

    ##### 4. Análise de Código Estático (SAST)

    Detecta vulnerabilidades no código-fonte sem executá-lo.

    Ferramentas SAST:

    1. SonarQube

    2. Checkmarx

    3. Fortify

    4. Snyk Code

    ##### 5. Análise de Componentes (SCA)

    Identifica vulnerabilidades em bibliotecas e dependências.

    Ferramentas SCA:

    1. Snyk

    2. OWASP Dependency-Check

    3. WhiteSource

    4. Dependabot

    OWASP Top 10: Vulnerabilidades Mais Comuns

    1. A01 – Broken Access Control

    2. A02 – Cryptographic Failures

    3. A03 – Injection

    4. A04 – Insecure Design

    5. A05 – Security Misconfiguration

    6. A06 – Vulnerable Components

    7. A07 – Authentication Failures

    8. A08 – Software and Data Integrity Failures

    9. A09 – Security Logging Failures

    10. A10 – SSRF (Server-Side Request Forgery)

    Teste de Usabilidade: Experiência do Usuário

    Avalia a facilidade de uso e a experiência do usuário com o sistema. O teste de usabilidade é essencial para garantir que os usuários consigam realizar suas tarefas de forma eficiente.

    Critérios de Usabilidade

    Critério Definição Métrica
    Eficácia Usuário consegue completar tarefa? Taxa de sucesso
    Eficiência Quanto tempo leva? Tempo de tarefa
    Satisfação Usuário gostou? Questionários SUS
    Aprendizagem Quanto tempo para aprender? Tempo até proficiência
    Memorização Lembra como usar? Retenção após pausa

    Métodos de Teste de Usabilidade

    1. Testes com Usuários – Sessões gravadas com participantes
    2. Análise Heurística – Avaliação por especialistas
    3. Questionários – SUS, SEQ, NPS
    4. Eye Tracking – Rastreamento ocular
    5. Análise de Tarefas – Tempos e erros

    Frameworks de Avaliação

    1. Nielsen’s Heurísticas (10 princípios)
    2. ISO 9241-11 (Usabilidade)
    3. WCAG 2.1 (Acessibilidade)

    Teste de Compatibilidade: Funciona em Todo Lugar?

    Verifica se o software funciona em diferentes ambientes, navegadores e dispositivos.

    Tipos de Teste de Compatibilidade

    ##### 1. Teste de Navegador (Cross-Browser)

    1. Chrome, Firefox, Safari, Edge

    2. Diferentes versões

    3. Modos de compatibilidade

    ##### 2. Teste Mobile

    1. iOS (iPhone, iPad)

    2. Android (diferentes fabricantes)

    3. Diferentes tamanhos de tela

    4. Diferentes versões de OS

    ##### 3. Teste de Sistema Operacional

    1. Windows 10, 11

    2. macOS (versões diferentes)

    3. Linux (distribuições populares)

    ##### 4. Teste de Hardware

    1. Diferentes processadores

    2. Diferentes quantidades de RAM

    3. Diferentes resoluções de tela

    Ferramentas de Teste Cross-Browser

    Ferramenta Cobertura Preço
    BrowserStack 3000+ dispositivos $29+/mês
    Sauce Labs 1000+ dispositivos $39+/mês
    LambdaTest 3000+ dispositivos $15+/mês
    CrossBrowserTesting 1500+ dispositivos $29+/mês

    Teste de Recuperação: Resistência a Falhas

    Avalia a capacidade do sistema de se recuperar de falhas e disasters. É crucial para sistemas críticos que não podem ficar fora do ar.

    Cenários de Teste

    1. Falha de Hardware

    – Perda de disco
    – Falha de memória
    – Queda de servidor

    1. Falha de Software

    – Crash de aplicação
    – Deadlock
    – Exceções não tratadas

    1. Falha de Rede

    – Perda de conectividade
    – Alta latência
    – Timeout

    1. Desastres

    – Perda de datacenter
    – Corrupção de dados
    – Ataques DDoS

    Métricas de Recuperação

    1. RTO (Recovery Time Objective): Tempo máximo para recuperação
    2. RPO (Recovery Point Objective): Perda máxima de dados aceitável
    3. MTBF (Mean Time Between Failures): Tempo médio entre falhas
    4. MTTR (Mean Time To Repair): Tempo médio para reparo

    Testes de Regressão: Mantendo a Qualidade

    Executados sempre que o código é modificado para garantir que alterações não introduzam novos defeitos. Este é um dos tipos de teste mais importantes e frequentemente executados.

    Quando Executar Testes de Regressão

    ✅ Após cada release de software
    ✅ Após correção de bugs
    ✅ Após atualizações de dependências
    ✅ Após refactoring de código
    ✅ Antes do deploy de produção

    Estratégias de Testes de Regressão

    1. Regressão Completa

    Executa toda a suite de testes.

    Vantagens:

    1. Cobertura total

    2. Alta confiança

    Desvantagens:

    1. Tempo longo

    2. Custo elevado

    2. Regressão Seletiva

    Seleciona testes relevantes baseados em mudanças.

    Vantagens:

    1. Mais rápido

    2. Mais econômico

    Desvantagens:

    1. Pode perder cobertura

    3. Regressão Prioritária

    Executa testes por prioridade (críticos > altos > médios > baixos).

    Vantagens:

    1. Cobertura do crítico rápido

    2. Decisões baseadas em risco

    Automação de Testes de Regressão

    A automação é essencial para testes de regressão eficazes:

    Benefícios:

    1. Execução frequente

    2. Resultados consistentes

    3. Rapidez

    4. Cobertura ampla

    Ferramentas Recomendadas:

    1. Selenium WebDriver

    2. Playwright

    3. Cypress

    4. Appium (mobile)

    5. RestAssured (API)

    Pirâmide de Testes: Arquitetura Ideal

    A pirâmide de testes é um conceito fundamental que guia a distribuição dos tipos de teste:

                        /
                   /  
                  / E2E        ← Poucos testes E2E (lentos, caros)
                 /      
                /Integração   ← Alguns testes de integração
               /            
              /  Unitários     ← Muitos testes unitários (rápidos, baratos)
             /________________

    Proporções Ideais

    1. Unitários: 70{6727d158e4474b0847515bd23a8ee4bebd5f1aac7a18bc968e51d8985dccb442} dos testes
    2. Integração: 20{6727d158e4474b0847515bd23a8ee4bebd5f1aac7a18bc968e51d8985dccb442} dos testes
    3. E2E: 10{6727d158e4474b0847515bd23a8ee4bebd5f1aac7a18bc968e51d8985dccb442} dos testes

Conclusão

Compreender os diferentes tipos de testes de software é fundamental para construir uma estratégia de QA eficaz. Cada tipo de teste tem seu propósito específico e deve ser aplicado no momento adequado do ciclo de desenvolvimento.

Resumo dos Tipos de Testes:

Categoria Tipo Quando Usar Objetivo
Funcional Unitário Desenvolvimento Isolar componentes
Funcional Integração Pós-unitário Verificar conexões
Funcional Sistema Pré-produção Validar requisitos
Funcional Aceitação UAT Validar com cliente
Não-Funcional Performance Carga esperada Velocidade e stability
Não-Funcional Segurança Pré-produção Proteger dados
Não-Funcional Usabilidade Design/UX Experiência do usuário

Próximos Passos:

  1. Avalie seu contexto – Nem todo projeto precisa de todos os tipos

  2. Priorize – Comece com unitários e integração

  3. Automatize – Regressão deve ser automática

  4. Meça – Cobertura, tempo, defeitos encontrados

  5. Melhore – Itere constantemente

FAQ – Perguntas Frequentes sobre Tipos de Testes

P: Quantos tipos de testes existem?
R: Existem dozens de tipos de testes classificados de diferentes formas. Os principais são funcionais e não-funcionais, cada um com subtipos específicos.

P: Qual a diferença entre teste de sistema e teste de aceitação?
R: Teste de sistema verifica se o sistema atende aos requisitos técnicos. Teste de aceitação verifica se o sistema atende às expectativas do usuário/cliente.

P: Testes manuais podem ser substituídos por automatizados?
R: Não completamente. Testes manuais são essenciais para exploratory testing, UX e cenários complexos. A automação complementa, não substitui.

P: Quando devo começar a testar?
R: O mais cedo possível! O conceito de Shift-Left recomenda testes desde as primeiras fases do desenvolvimento.

P: Qual a ordem ideal de execução dos testes?
R: Unitários → Integração → Sistema → Aceitação. Cada nível depende do anterior.

Fonte: Selenium.dev, Atlassian, Vericode, ISTQB, OWASP