Testes de Softwares

Conceitos

Os testes podem somente mostrar a presença de erros, não sua ausência.

Verificação: Confirma se o software está sendo construído corretamente, de acordo com as especificações e diretrizes. É uma atividade de controle de qualidade interna.

Validação: Garante que o software atende às necessidades e expectativas do usuário final. É uma atividade de controle de qualidade externa.

Testes: São métodos práticos de verificar e validar o software, podendo ser de várias formas, como testes de unidade, caixa-preta, caixa-branca, estresse, entre outros.

Princípios

• Testes demonstram a presença de defeito e não sua ausência.
• Testes exaustivos são impossíveis.
• Princípio de Pareto, 80% dos defeitos são causados por 20% do código.
• Teste o mais breve possível, é melhor corrigir agora do que em fase de produção.
• Paradoxo do pesticida: Caso os mesmos testes sejam aplicados repetidamente, em determinado momento eles deixam de ser úteis.
• Ausência de erros é ilusão: Identificar e corrigir os problemas de um software não garantem que ele está pronto.

Caixa Preta - Funcional

A Técnica Caixa-Preta (também conhecida como Comportamental, Funcional, Orientada a Dado, Orientada à Entrada/Saída ou Caixa-Escura) se baseia em pré-condições e pós-condições, geralmente sendo utilizada nas etapas posteriores da disciplina de testes.

Ela busca funções incorretas ou inexistentes, erros de comportamento ou desempenho, erros de inicialização e interface, entre outros.

• Tem o objetivo de verificar a funcionalidade e aderência aos requisitos.

Técnicas:

1. Baseado em Grafos: Permite identificar os objetos e gera grafos para representá-los, testando-os e seus relacionamentos com o intuito de descobrir erros.

2. Partição de Equivalência: Permite agrupar os valores de entrada em categorias de dados para evitar redundância e aumentar a cobertura de testes do sistema.

3. Análise de Valor Limite: Permite exercitar os limites do domínio de entrada, tendo em vista que a maioria dos erros se encontram nas extremidades da entrada. Utilizada em conjunto com a técnica de partição de equivalência.

4. Matriz Ortogonal: Utilizado com entradas relativamente pequenas, casos de testes são espalhados uniformemente pelo domínio do teste para detectar falhas.

---

Caixa Branca - Estrutural

A abordagem caixa branca testa a lógica interna do código, analisando fluxo de controle, estruturas condicionais e loops. Utiliza técnicas como cobertura de instrução, decisão, caminho e condição. É aplicada em testes unitários para validar a implementação interna, exigindo conhecimento do código-fonte. Objetiva garantir que todos os caminhos independentes de um módulo seja executado pelo menos uma vez.

Técnicas

1. Testes de caminho: analisam todos os possíveis fluxos de execução em um código. Úteis para encontrar loops infinitos, condições não testadas e caminhos lógicos inválidos.

2. Testes de estrutura de controle: Analisam o fluxo de controle do código, verificando decisões, loops e condições. Usam critérios como cobertura de instrução, decisão, condição e caminho para garantir que todas as ramificações sejam testadas, identificando falhas lógicas e melhorando a confiabilidade do software.

3. Complexidade ciclomática(Métrica): Usada para medir a complexidade do código e definir a quantidade mínima de testes de caminho necessários.

---

Teste de Unidade

Primeiro nível de testes, onde os componentes individuais são testados isoladamente para assegurar que os mesmos operam de forma correta.

Exemplo: Métodos individuais, classes com atributos e métodos.

• Em testes de classes, todos os eventos devem ser simulados.
• Os testes são realizados pelo desenvolvedor.
• Se houver defeitos nos componentes, estes devem ser revelados por casos de teste.

Stubs: Simulam respostas predefinidas de dependências. Ele fornece uma resposta fixa para que você possa testar outras partes do seu sistema.

Mocks: Simulam comportamentos e verificam interações. Ele verifica se as interações estão ocorrendo como esperado.

Ferramentas: Junit(Java) e Pytest(Python).

Testes de Integração

O teste de integração verifica a comunicação entre módulos ou sistemas, garantindo interoperabilidade e coerência. (Devem ser integrados gradualmente)

Utiliza técnicas como Big Bang, Top-Down, Bottom-Up e Incremental, identificando falhas na interface e fluxo de dados. Envolve stubs e drivers para simular dependências e é essencial para validar a interação entre componentes antes da fase de testes de sistema.

• Big Bang: Todos os módulos são integrados de uma vez e testados em conjunto.
• Top-Down: Testa a hierarquia do sistema começando dos módulos de alto nível para os de baixo nível, usando stubs.
• Bottom-Up: Começa pelos módulos de baixo nível e sobe na hierarquia, utilizando drivers.
• Incremental: Integra e testa os módulos progressivamente, combinando Top-Down e Bottom-Up.

Testes de Aceitação

Os testes de aceitação validam se o sistema atende aos requisitos do usuário e aos critérios de negócio. São realizados pelos clientes ou stakeholders, garantindo que o software esteja pronto para produção.

• Teste Alfa: Realizado por um público interno da empresa em um ambiente controlado, focando em identificar falhas antes do lançamento externo.

• Teste Beta: Feito por um grupo seleto de usuários externos, validando a funcionalidade em um ambiente real e identificando problemas que não foram detectados no teste alfa.

Exemplo: WhatsApp Beta

• Nesse caso, o desenvolvedor não está mais presente com o cliente.

Testes de Sistema

É uma fase do processo de testes em que o sistema é testado como um todo (Hardware e pessoas), verificando a integração de todos os seus componentes, módulos e subsistemas.

O objetivo é garantir que o sistema funcione conforme os requisitos especificados, testando funcionalidades, desempenho, segurança e usabilidade em um ambiente completo. Esse teste é realizado após os testes unitários e de integração, e antes dos testes de aceitação.

Teste de Regressão

Verifica se novas alterações ou correções no código não causaram falhas ou impactaram negativamente funcionalidades que já estavam funcionando corretamente.

Esse tipo de teste é crucial após atualizações, correções de bugs ou adição de novas funcionalidades, garantindo que o sistema continue funcionando como esperado. Ele pode ser automatizado para testar rapidamente versões anteriores do software.

Teste de Fumaça

Foca em testar as funcionalidades básicas e críticas do sistema para garantir que ele funcione de maneira estável após uma nova build ou release. É uma verificação inicial, como se fosse uma checagem rápida para "ver se o sistema pega fogo". Se o teste de fumaça falhar, o desenvolvimento é interrompido até que o problema seja resolvido.

É uma abordagem do teste de integração usada à medida que o software é desenvolvido.

Teste de Recuperação

O teste de recuperação avalia a capacidade do sistema de se recuperar de falhas (como quedas de energia ou falhas de rede), garantindo que o sistema restaure suas operações sem perdas significativas de dados ou funcionalidade.

Automação

Um bom framework de automação de testes deve ser altamente manutenível.

Isso significa que ele deve ser fácil de atualizar, modificar e expandir à medida que o software em teste evolui. Algumas características que contribuem para a manutenibilidade incluem:

• Código modular e reutilizável.
• Boa documentação.
• Baixa dependência entre os testes.
• Facilidade de adaptação a mudanças no sistema.

Manutenibilidade é essencial para garantir que o framework continue eficaz à medida que novas funcionalidades são adicionadas ou problemas surgem no software.

Debugging

Debugging é o processo de identificar, analisar e corrigir erros (bugs) no código de um software. Envolve técnicas como:

• Força Bruta: É um método onde o desenvolvedor tenta diversas abordagens para encontrar o erro, sem um plano específico ou estratégico. (Menos eficiente)
• Pontos de interrupção (breakpoints): Pausar a execução do programa para inspecionar o estado do código.
• Rastreamento (tracing): Acompanhar a execução do programa linha a linha.

É uma prática contínua durante o desenvolvimento desde o início.