Aula Prática – Qualidade e Automação de Testes

Veja o Manual / Enunciado Completo

Roteiro

Aula Prática

QUALIDADE E AUTOMAÇÃO DE TESTES

Público

ROTEIRO DE AULA PRÁTICA

NOME DA DISCIPLINA: Qualidade e Automação de Testes

Unidade: U1_FORMAS E QUALIDADE DE TESTES
Aula: A3_ DIFERENTES TIPOS DE TESTES

OBJETIVOS

Definição dos objetivos da aula prática:

Compreender e aplicar a técnica de teste de caixa branca para validar o comportamento lógico de trechos de código.

SOLUÇÃO DIGITAL:

Replit Languages Python3

Utilizar um computador com acesso à Internet. Necessário acessar o Replit Languages Python3, um website de edição de código para Python.

Link disponível em: https://replit.com/languages/python3

PROCEDIMENTOS PRÁTICOS E APLICAÇÕES

Procedimento/Atividade nº 1

Grafo de Fluxo

Atividade proposta: Desenvolva um grafo de fluxo de programa para o código que representa uma operação de saque.

Procedimentos para a realização da atividade:

O grafo de fluxo de controle (CFG, do inglês Control Flow Graph) é uma representação fundamental em muitas áreas da ciência da computação, especialmente no desenvolvimento de software e na análise de sistemas. Nos testes de software, os CFGs são utilizados para entender e analisar o fluxo de execução de programas. Eles são particularmente úteis para identificar e avaliar os caminhos de execução, permitindo uma série de atividades relacionadas aos testes, como a criação de casos de teste e a análise de cobertura de código.

Um grafo de fluxo de controle é um diagrama direcionado que consiste em um conjunto de nós, que representam instruções ou grupos de instruções, e um conjunto de arestas, que representam o fluxo de controle entre essas instruções. Cada nó no grafo corresponde a uma operação básica ou a uma decisão, enquanto as arestas indicam o caminho que o controle pode seguir durante a execução do programa.

Componentes-chave

• Nós de Decisão: Estes são pontos no programa onde o fluxo de controle pode divergir. Exemplos incluem instruções condicionais como if, else, e laços como for e while.
• Nós de Sequência: Representam a execução sequencial de instruções que não envolvem nenhuma tomada de decisão.
• Nós de Convergência: Onde caminhos divergentes se reencontram. São críticos para entender como diferentes caminhos de execução se integram.
• Nó de Início e de Término: Cada grafo possui um único nó de início e geralmente um nó de término, que indicam respectivamente o começo e o fim do fluxo de controle do programa.

Sabendo disso, crie um grafo para o código a seguir:

def saque(valor, saldo, limite_credito):
    status = False

    if valor <= saldo:
        saldo = saldo - valor
        status = True
    elif valor <= limite_credito:
        limite_credito = limite_credito - valor
        status = True

    return status, saldo, limite_credito

Avaliando os resultados:

Para esta atividade, deve-se construir o Grafo de Fluxo de Controle (CFG) para o método saque, apresentado no código fornecido. O CFG é uma representação gráfica que ilustra todos os possíveis caminhos de execução de um programa, sendo amplamente utilizado em testes de software para analisar o comportamento do código, verificar a cobertura de testes e garantir que todas as possibilidades de execução foram consideradas. A construção do grafo exige a identificação dos elementos fundamentais do código, como a inicialização de variáveis, as decisões condicionais e o retorno da função.

Ao construir o grafo, espera-se que a representação correta do início do método, a atribuição inicial da variável status, os dois pontos de decisão correspondentes às instruções if e elif, os blocos de instruções executados em cada caso, bem como o ponto de convergência onde os fluxos se unem antes da instrução de retorno. O grafo deve conter nós representando cada uma dessas etapas, conectados por arestas que indicam o fluxo de execução, com setas direcionadas que mostrem claramente os caminhos possíveis.

Procedimento/Atividade nº 2

Escrita e Validação da Escrita de Teste

Atividade proposta: Entender como funciona a escrita e validação de testes, através de um editor/IDE. Criar um relatório no final da atividade.

Procedimentos para a realização da atividade:

Os testes de caixa branca, também conhecidos como testes estruturais ou de código, visam avaliar o comportamento interno do sistema, testando a lógica, fluxo de dados, caminhos de execução, entre outros aspectos.

Na prática, os testes de caixa branca envolvem a análise do código-fonte do software e a criação de casos de teste que cubram todas as possíveis condições de execução do código, incluindo casos de sucesso e de falha. Algumas técnicas comuns de teste de caixa branca incluem:

1. Cobertura de código: essa técnica mede a quantidade de código que foi executada durante os testes. O objetivo é garantir que todas as instruções do código sejam executadas pelo menos uma vez;
2. Análise de fluxo de dados: essa técnica verifica se os dados são processados corretamente dentro do sistema, identificando possíveis erros de lógica;
3. Teste de caminho crítico: essa técnica visa identificar os caminhos mais importantes do código e testá-los minuciosamente para garantir que o software esteja funcionando corretamente.
4. Teste de valores limite: essa técnica avalia o comportamento do software quando os valores de entrada são máximos, mínimos ou próximos aos limites especificados.

Os testes de caixa branca são importantes para garantir a qualidade do software, identificando possíveis falhas de lógica e comportamento. Esses testes são realizados por desenvolvedores ou profissionais de teste especializados em análise de código e podem ser automatizados para facilitar o processo de teste.

Nesta atividade você deverá:

Acessar o website https://replit.com/languages/python3. O replit é um website de edição de código para Python que permite a digitação e a validação de códigos. Pode-se utilizar outro editor/IDE para realizar essa atividade.

A função saque representa uma operação de retirada de dinheiro em uma conta bancária. Essa função verifica primeiro se há saldo suficiente disponível para realizar o saque. Caso não haja, tenta realizar a retirada utilizando o limite de crédito disponível. Se nenhuma das duas opções for suficiente, o saque não é realizado. A função retorna True quando o saque é efetuado com sucesso e False caso contrário. A seguir, temos o código, já com um exemplo de uso:

def saque(valor, saldo, limite_credito):
     status = False


     if valor <= saldo:
           saldo = saldo - valor
           status = True
     elif valor <= limite_credito:
           limite_credito = limite_credito - valor
           status = True


     return status, saldo, limite_credito


saldo = 1000
limite_credito = 500


status, saldo, limite_credito = saque(1200, saldo, limite_credito)
print("Saque realizado?", status)
print("Saldo:", saldo)
print("Limite de crédito:", limite_credito)

OBS: lembre-se que em Python é validado espaços em brancos e a identação do código.

Para realizar o teste de caixa branca da função acima, podemos utilizar a técnica de cobertura de código e criar casos de teste que cubram todas as instruções presentes na função. Sendo assim, crie uma sequência de testes que valide as seguintes questões:

1. Analisar os caminhos possíveis da função saque, considerando as condições estabelecidas. Para isso, você pode utilizar o Grafo desenvolvido na Atividade 1.
2. Criar três casos de teste distintos, cada um cobrindo um caminho de execução:
   • O primeiro caso deve verificar se a função realiza corretamente o saque quando o valor solicitado é menor ou igual ao saldo disponível.
   • O segundo caso deve testar a situação em que o valor excede o saldo, mas está dentro do limite de crédito disponível.
   • O terceiro caso deve verificar o comportamento da função quando o valor do saque ultrapassa tanto o saldo quanto o limite de crédito.
3. Para cada teste, informe os valores de saldo, limite_credito, valor do saque e o resultado esperado da operação (True ou False).

Descreva a lista dos valores utilizados para responder as questões 1, 2 e 3 acima.

Avaliando os resultados:

Para realizar a atividade proposta, é necessário compreender os princípios dos testes de caixa branca, especialmente a técnica de cobertura de código. A primeira etapa consiste em analisar cuidadosamente o código da função saque, identificando os diferentes caminhos lógicos que podem ser percorridos durante sua execução. A partir dessa análise, devem ser definidos casos de entrada que levem a função a passar por cada uma das possibilidades: quando o valor do saque é menor ou igual ao saldo, quando o valor excede o saldo, mas está dentro do limite de crédito, e quando o valor ultrapassa ambos. Em seguida, é preciso implementar esses casos de teste em um ambiente de desenvolvimento, como o Replit, observando a resposta gerada pela função e comparando com o comportamento esperado. A execução correta dos testes dependerá da tradução precisa da lógica para os dados de entrada e da verificação atenta dos resultados retornados. Embora o exemplo esteja em Python, é possível realizar a atividade em outra linguagem de programação, desde que o código seja corretamente adaptado, respeitando a estrutura condicional e a lógica implementada. O importante é garantir que todos os caminhos possíveis do código sejam testados, assegurando uma análise completa da sua execução interna.

Checklist:

• Saber criar um grafo de fluxo de controle para testes.
• Utilizar um editor/IDE de Python ou da linguagem desejada.
• Executar a função saque() para realizar os testes.
• Analisar os testes desenvolvidos de acordo com a função dada.
• Avaliar os resultados.

RESULTADOS

Resultados do experimento:

Desenvolvimento de um um relatório (documento eletrônico) com o grafo de fluxo referente a Atividade 1 e os resultados obtidos através do teste do código da Atividade 2.

Resultados de Aprendizagem:

Espera-se que o estudante seja capaz de entender os conceitos fundamentais de grafo de fluxo e da execução de um programa de computador , reconhecer a lógica dos comandos (comparação de valores) e os resultados apresentados, conforme os valores utilizados.