Unidade 4

Ferramentas de Teste de Software

Abertura

Olá, amigo(a) discente! Seja bem-vindo(a)!

Chegamos à última unidade de ensino da disciplina de teste de software. Perpassamos

por conteúdos importantes e relevantes apresentando o relacionamento do teste com
os requisitos funcionais e não funcionais do sistema, os fundamentos de teste de
software e os tipos de teste de software passando por modelos como o RUP.
Continuando nosso estudo, nesta Unidade de Ensino estaremos abordando o
desenvolvimento de testes unitários e automatizados por ferramentas.
Todo esse conteúdo será abordado considerando uma didática evolutiva, aliada aos
exemplos de aplicação, sempre buscando elucidar de diferentes formas as dúvidas que
surgirão no caminho.
Concluindo a disciplina de teste de software, nesta unidade serão construídos
exemplos práticos que envolvam os conteúdos de teste de software. Contudo, é
importante o seu engajamento e esforço para que você consiga assimilar o conteúdo
específico dessa unidade de ensino.
Objetivos
 Conhecer o teste unitário;
 Elaborar testes unitário em códigos-fonte;
 Conhecer ferramentas para automatização de testes.

Conteúdo Programático
Aula 01 – Testes Unitários
Aula 02 – Ferramentas para automatização de testes
Testes Unitários

Introdução

O objetivo dessa aula é abordar a prática com testes, seja ela de forma unitária, conjunta,
manual ou automatizada. Durante a disciplina de teste de software muitos conceitos foram
abordados e trabalhados e agora vamos ver como funciona um teste na prática por meio de
uma linguagem de programação. A linguagem utilizada será o Java.

Um outro conteúdo abordado será a automatização de testes. Temos no mercado várias

ferramentas de automação de testes, vamos abordar a extensão do “Selenium” na aula 2 para
testes no browser em aplicações Web, mas nessa aula abordaremos a biblioteca JUnit para
testes unitários na linguagem Java.

Outros assuntos complementares serão trabalhados durante essa aula e também serão úteis
para seu aprendizado.

Testes unitários

A ideia do teste unitário se resume em realizar o teste de um único componente separado do

restante do sistema. Um exemplo seria realizar o teste de apenas um módulo do sistema de
contabilidade do seu cliente, assim, podemos dividir os casos de teste fazendo com que cada
módulo ou parte do sistema seja tratada de forma distinta.

Isso resultaria em benefícios diretamente ligados ao tempo de espera, ou seja, não precisamos
aguardar o término do teste de todo o sistema, pois ele está sendo testado em partes. Esses
benefícios podem incluir (ISTQB, 2019):

 Realocação de recursos em outras atividades similares;

 Otimização do tempo utilizado para testar o sistema;

 Feedback do cliente em relação às diversas situações quando defeitos e falhas são

encontradas.

Como foi estudado no material da Unidade 3 e também reforçado nas videoaulas, o teste
unitário também é chamado de teste de componente.

O processo árduo do testador de software quando ele vai rodar testes unitários. Esse processo
pode se repetir dezenas de vezes, por isso em alguns casos decide-se por fazer a
automatização por uma ferramenta. Lembrando que o fato de se testar 1 ou 1000 vezes não
interfere se o teste é unitário ou não, pois ele se caracteriza como teste unitário se estiver
limitado a testar componentes de forma separada (ISTQB, 2019).

A indicação de leitura abaixo vai abordar um pouco mais o teste unitário. Vale a pena ler o
conteúdo, fazer anotações e se possível colocar isso em prática em um projeto piloto.

Indicação de Leitura

Nesse material desenvolvido pelo ISTQB – International Software Testing Qualifications Board,
distribuído pela BSTQB – Brazilian Software Testing Qualifications Board, você pode estudar
sobre o teste de componentes. No capítulo 2, você vai encontrar o tópico 2.2.1 Teste de
componente na página 33 onde vai encontrar os assuntos:

- Objetivos do teste de componente;

- Base de teste;

- Objetos de teste;

- Defeitos típicos e falhas;

- Abordagens e responsabilidade específicas.

Confira o link: https://www.abramti.org.br/b9/doc/syllabus_ctfl_3.1br.pdf para maiores

informações a respeito do material e seu conteúdo.

Esse material completo está disponível para download e consulta de forma gratuita.

JUnit

O Junit é um pacote dentro do Java para trabalhar com testes unitários. O Test Driven
Development (TDD) que no português significa conceito de Desenvolvimento Guiado por
Testes, orienta que antes de se criar qualquer classe codificada, deve-se escrever um teste, a
fim de testarmos o código-fonte da referida classe. Essa prática gera vários benefícios quando
pensamos em toda a equipe de desenvolvimento, inclusive podem ser utilizados como
métricas em todo o tempo de vida do projeto.

O TDD também torna o processo mais confiável, além de reduzir os custos, pois elaborar os
testes antes mesmo que eles sejam executados, significa que já sabemos os erros e
consequentemente eles serão corrigidos. Outra situação é que os testes já foram criados, e
isso significa que as regras de negócio já foram compreendidas no desenvolvimento dos testes
unitários. Vamos elencar alguns benefícios do TDD (ISTQB, 2019):

 Melhora a confiança no processo;

 Redução dos custos;

 Diminuição do retrabalho;

 Aumento da produtividade do desenvolvimento.

Se repararmos bem, temos benefícios bem interessantes para agregar e refinar o
desenvolvimento do projeto.

Figura 1: Ciclo do TDD

Fonte: Disponível em: https://bityli.com/wzQve. Acesso em: 25 fev. 2022.

A Figura 1 apresenta o ciclo do TDD. Esse ciclo é bem simples, cria-se um teste, constrói-se a
codificação para que o teste seja executado e depois aplica-se o refatoramento (ISTQB, 2019).

O grande objetivo do teste é auxiliar na codificação do sistema reduzindo problemas na etapa

de implementação. No TDD recomenda-se que os testes unitários sejam executados antes
mesmo da codificação. De acordo com Sommerville (2018), “a escrita de testes primeiro define
implicitamente tanto uma interface como uma especificação do comportamento para a
funcionalidade que está sendo desenvolvida”.

Vale lembrar que o desenvolvedor para implementar os testes iniciais deve conhecer
claramente a regra de negócio e os requisitos do sistema. Também de nada vai adiantar criar
testes que não façam a validação do código-fonte, pois os testes precisam validar um conjunto
de unidades, sendo assim, o TDD irá funcionar adequadamente abrangendo toda a estrutura
dos testes.

O modelo F.I.R.S.T. deve ser adotado pensando no desenvolvimento correto de testes

unitários no sistema. Na sequência esse modelo é apresentado:

 F (Fast) – Rápidos: Pois testam apenas uma unidade;

 I (Isolated) – Testes unitários são isolados, testando individualmente as unidades ou

módulos e não sua integração;

 R (Repeateble) – Repetição nos testes, com resultados de comportamento constante;

  S (Self-verifying) – A auto verificação deve indicar se o teste passou ou se não passou
(falha);

 T (Timely) – O teste deve ser oportuno, sendo um teste por unidade.

Videoaula 1
Utilize o QR Code para assistir!

A primeira videoaula, vai apresentar o

ciclo do TDD que será abordado para a
construção dos testes unitários com o
JUnit. O professor vai explicar o tema
apresentando as principais
características desse ciclo do TDD.
Assista e estude essa videoaula para
compreender um pouco mais do ciclo do
TDD.

Exemplo
Para criar um teste com a biblioteca do JUnit no Java, é preciso baixar e configurar no
seu ambiente. Sendo assim, deixarei a indicação de um vídeo que vai ensinar onde
baixar e como configurar o ambiente.

Indicação de Vídeo
Nesse vídeo é explicado como fazer o download, instalação e configuração da
biblioteca do Java (JUnit) com a IDE do Eclipse. Se desejar, você pode utilizar também o
NetBeans ou o IntelliJ.
Confira o link: https://www.youtube.com/watch?v=WHPPQGOyy_Y para realizar todos
os procedimentos necessários.

Uma vez instalado o JUnit, vamos então ao nosso exemplo. A partir de um projeto
criado no Eclipse, vamos criar nosso primeiro caso de teste. Para isso vá no
pacote src e com o botão direito selecione a opção new/other, selecione o diretório
JUnit e então selecione “JUnit Test Case”, figura 2.
 Figura 2: Criando uma JUnit Test Case

Fonte: o autor, 2022.

Após isso, é só colocar o nome da classe e clicar no botão Finish. Seu caso de teste
estará pronto para ser construído conforme apresentado na Figura 3.
Figura 3: Classe do JUnit Test Case

Fonte: o autor, 2022.

Como pode ser observado na Figura 3, o nome dado a classe foi: Macedo. Lembrando
sempre de deixar o primeiro caractere do nome da classe em maiúsculo. Para executar
esse teste basta clicar com o botão direito no nome da classe e selecionar a opção Run
As JUnitTest, figura 4.
 Figura 4: Executando o Junit Test

Fonte: o autor, 2022.

Note que o teste irá falhar por conta da função “fail” que está sendo executada na
linha 11 da Figura 3. Trata-se apenas de um exemplo que já está configurado quando
criamos a classe. Todas as vezes que quiser executar o teste novamente ou executar
outro JUnit Test, proceda da mesma maneira.

Videoaula 2
Utilize o QR Code para assistir!
A segunda videoaula da aula 1, vai
apresentar como fazer a configuração do
JUnit no Eclipse, além dos detalhes da
criação do projeto utilizando a biblioteca
do JUnit. O professor vai explicar como
deve ser feita a criação do projeto e
também como executá-lo.

Construindo e implementando o projeto

Vamos então trabalhar em um exemplo prático. Vamos criar uma classe a fim de
conseguirmos testar alguns métodos básicos. Precisamos então de 2 elementos no
projeto e no mínimo 1 ou 2 métodos para teste, são eles:
 Uma classe com o nome: LogicaTeste;
 Um JUnit Teste com o nome de TesteJUnitTestCase;

 1º Método de teste na classe LogicaTeste (soma);

 2º Método de teste na classe LogicaTeste (soma);
 3º Método de teste na classe LogicaTeste (soma).

Vamos à construção desses métodos pensando em uma implementação simples, mas

que gere os resultados que necessitamos a fim de demonstrar quando o teste passou e
quando ele falhou.
O objetivo do primeiro método será retornar um valor lógico verdadeiro quando o
resto da divisão do valor numérico passado por parâmetro for “Par” e falso quando for
ímpar. Observe a Figura 5.

Figura 5: Método 1

Fonte: o autor, 2022.

O objetivo do segundo método será retornar à concatenação de três valores

caracteres. Qualquer valor de outro tipo o teste deve falhar.

Figura 6: Método 2

Fonte: o autor, 2022.

O objetivo do terceiro método será retornar um valor lógico verdadeiro quando o

primeiro valor numérico passado por parâmetro for divisível de forma exata pelo
segundo, e falso a divisão não der exata.
A Figura 7 a seguir apresenta o retorno quando todos os três métodos da classe
LogicaTeste passarem.
Figura 7: Teste Pass

Fonte: o autor, 2022.

Concluindo, o JUnit é uma biblioteca poderosíssima para a criação e aplicação de
testes em sistemas desenvolvidos em Java. A equipe técnica pode criar um
planejamento desses testes antes mesmo do sistema começar a ser construído.

Videoaula 3
Utilize o QR Code para assistir!

A terceira videoaula da aula 1, vai

apresentar a execução dos testes do
JUnit e como o resultado pode colaborar
no desenvolvimento do projeto.
Ferramentas para automatização de testes

Introdução

Nessa aula, vamos continuar nosso estudo abordando uma ferramenta de automação de
testes. O Selenium é um conjunto de ferramentas open source e multiplataforma usado para
automatizar testes nos navegadores web. Suporta ainda diversas linguagens de programação
como Java, C# (Sharp), Java Script, Python, Kotlin e Ruby. Além das linguagens, os testes
podem ser executados em vários navegadores web como, Chrome, Safari, Firefox, entre
outros.

Selenium IDE

O Selenium IDE funciona como uma extensão do navegador que grava e também reproduz a
atividade do usuário em uma página web. Ele realiza esse procedimento utilizando comandos
existentes do Selenium de acordo com parâmetros fornecidos para cada teste. A extensão do
Selenium IDE está disponível para Google Chrome, Mozilla Firefox e Microsoft Edge. A Figura 8
exibe ao longo dessa extensão.

Figura 8: Selenium Logo

Disponível em: https://pt.m.wikipedia.org/wiki/Ficheiro:Selenium_Logo.png. Acesso em 25 fev. 2022.

Para conhecer um pouco mais do Selenium IDE você pode acompanhar a indicação de leitura a
seguir:
Após ler e estudar os conteúdos dessa indicação de leitura, veja também a indicação desse
vídeo muito bem contextualizado com a ferramenta Selenium.

Importante

Para complementar seu estudo e saber mais curiosidades sobre o Selenium, acesse a
url: https://www.youtube.com/watch?v=Fw9YW5_MZRs, acesso em 07 fev. 2022, onde você
vai poder acompanhar o Overview do Selenium, um pouco da sua história, curiosidades,
variações das suas distribuições, etc. Em todos os tópicos você poderá ter acesso a conteúdo
contendo os conceitos, características e funcionalidades de cada um.

O material é um complemento ao conteúdo abordado nessa aula. Vale a pena conferir!

Ambiente

Antes de iniciarmos nosso trabalho com a criação de testes dentro utilizando o Selenium IDE,
devemos fazer a instalação dessa extensão. Tratando-se de um sistema que será testado no
navegador web, a sua instalação é muito simples.

Você deve pesquisar em seu navegador pela extensão Selenium IDE. Vamos utilizar o Google
Chrome por questões de popularidade. Observe a Figura 9.

Figura 9: Extensão Selenium IDE

Fonte: o autor, baseado em: https://chrome.google.com/webstore/detail/selenium-ide/

Na Figura 9 está sendo exibida a busca pela extensão informando como busca: selenium
extensão. Basta acessar a url exibida na pesquisa para que o Chrome carregue a opção de
utilização da extensão nas extensões do Google em seu navegador.

Para adicionar a extensão, clique no botão azul Usar no Chrome como é exibido na Figura 10.
 Figura 10: Usar a extensão

Fonte: o autor, baseado em: https://chrome.google.com/webstore/detail/selenium-ide/

É verificada a sua solicitação e uma mensagem de confirmação é exibida. Para concluir, clique
em “Adicionar extensão”, figura 11.

Figura 11: Concluindo a instalação

Fonte: o autor, baseado em: https://chrome.google.com/webstore/detail/selenium-ide/

 Videoaula 1
Utilize o QR Code para assistir!

Nessa videoaula, será apresentada a

extensão “Selenium IDE” focando em seu
conceito, característica, instalação e
configuração. O professor vai
demonstrar esse processo na prática.

Acompanhe com atenção e não deixe de

complementar sua pesquisa consultando
a bibliografia da disciplina.

Não deixe de assistir a vídeo aula.

Trabalhando com a Extensão Selenium IDE

Vamos trabalhar com um exemplo prático criando testes com o auxílio dessa extensão
no navegador web. O primeiro passo é abrir o Selenium IDE nas extensões instaladas
em seu navegador. Observe a Figura 5.
Figura 12: Abrindo o Selenium IDE

Fonte: o autor, baseado no navegador web Google Chrome

O programa é inicializado e você já poderá criar seus testes automatizados conhecidos

também como Robôs de teste.

A Figura 13 exibe a tela principal do Selenium IDE.

 Figura 13: Selenium IDE

Fonte: o autor, baseado em Selenium IDE.

Antes de realizar o primeiro exemplo, como é possível observar, a extensão permite

algumas opções de configuração de testes automatizados, tais como:
 Gravar um novo teste em um novo projeto;
 Abrir um projeto existente;
 Criar um novo projeto;

 Fechar o Selenium IDE.

Acompanha a próxima vídeo aula para saber como criar e configurar testes com essa
ferramenta por meio do navegador web.
 Videoaula 2
Utilize o QR Code para assistir!

Nessa videoaula será abordada a criação

e teste de um procedimento simples na
web. A videoaula do professor vai
abordar toda a configuração e
codificação necessária para a criação do
teste.

Acompanhe com atenção e não deixe de

aprofundar o seu caso de teste trocando
as variáveis de entrada.

Não deixe de assistir a mais essa

videoaula. Confira!

Agora que você já aprendeu um pouco sobre como instalar, configurar e a criar um
primeiro caso de teste, vamos aprofundar um pouco criando assim um script de caso
de teste.
Um script ou scripts são códigos que executam duas ou mais funções em sequência,
isso quer dizer que vamos criar um teste que execute dois ou mais testes já criados
anteriormente, ou então que execute várias tarefas em sequência. A Figura 14, exibe
uma prévia da ferramenta Selenium IDE sendo configurada para a execução de um
script de teste.
Figura 14: Script de Teste

Fonte: o autor, baseado em Selenium IDE.

Acompanha a próxima vídeo aula para saber como criar e configurar scripts de testes
com o Selenium IDE.
 Videoaula 3
Utilize o QR Code para assistir!

Nessa videoaula será abordada a criação

de um ou mais casos de teste e também
de scripts de teste. Após a criação, os
scripts serão executados no navegador
para demonstração dos testes. A
videoaula do professor vai abordar toda
a criação e codificação necessária para a
criação do exemplo.

Assista a vídeo aula e anote os principais

pontos, visando futuras revisões de
estudo que você deseja fazer com o
material da disciplina de teste de
software.

Concluindo o estudo dessa aula, podemos dizer que conseguimos iniciar nosso longo
caminho para o desenvolvimento de testes unitários e automatizados com a utilização
de ferramentas de apoio.

Atividades Avaliativas e de Fixação

Prezado(a) aluno(a)!
Chegou a hora de colocarmos em prática os conhecimentos adquiridos até o
momento!
As avaliações nos possibilitam perceber se estamos obtendo bons resultados e quais
são os conteúdos que requerem nossa atenção.

Clique em “Módulos” no “Menu Lateral” e acesse a Atividade Fixação e Atividade

Avaliativa.

Atente-se aos prazos! Após a data limite, a avaliação será encerrada. Bons estudos!
 Videoaula Encerramento
Utilize o QR Code para assistir!
Assista agora ao vídeo de encerramento
de nossa disciplina.

Encerramento
Chegamos ao fim desta Unidade de Ensino e também da disciplina após caminhar por
conteúdos importantes para o seu desenvolvimento no Curso de Tecnologia em
Análise e Desenvolvimento de Sistemas até aqui. A Unidade 4 apresentou o conteúdo
de testes unitários por meio da biblioteca JUnit da linguagem Java e a ferramenta
Selenium IDE para construção e execução de testes automatizados em navegadores
web que permitam o desenvolvimento de projetos com a extensão do Selenium.
Após a assimilação dos conteúdos abordados nesta Unidade, você está apto a
prosseguir estudando um pouco mais sobre a grande área teste de software no
mercado profissional que tem crescido nos últimos anos.
Tenha uma ótima leitura e não se esqueça de ler e estudar a Bibliografia e as
videoaulas ministradas pelo professor.
Obrigado pela oportunidade de ser o mediador entre os conteúdos específicos
abordados e o conhecimento adquirido por você por meio da didática e abordagem
desta Unidade.

Encerramento da Unidade
Espero que os conteúdos dessa disciplina, tenham contribuído para sua formação
acadêmica, bem como, na construção de seus conhecimentos específicos em relação
ao cenário do teste de software. No decorrer do conteúdo, foi possível aprender os
conceitos básicos e os fundamentos de teste de software. Foi possível também, por
meio de exemplos práticos e da realidade profissional, onde são aplicados na prática
esses testes. A disciplina de teste de software apresenta uma área do desenvolvimento
de software que contém a etapa de teste de software muito importante para o ciclo de
vida de desenvolvimento do projeto. Após você aprender e compreender as estruturas
do teste de software e suas aplicações, é possível adquirir uma maturidade
considerável, relacionada aos recursos e técnicas utilizadas para a criação de testes e
casos de teste que ajudem no desenvolvimento do sistema.
Quero agradecer a você, pela parceria e também por poder compartilhar informações
e experiências que com certeza agregaram valor na disciplina.
Continue em frente, bons estudos e um grande abraço!

Referências
DIJKSTRA, E. W. A Discipline of Programming. Englewood Cliffs, New Jersey, EUA:
Prentice Hall, 1976. 217 p.
HOGLUND, Greg.; MCGRAW, Gary. Como quebrar códigos: a arte de explorar e
proteger software. São Paulo: Pearson Makron Books2006.
ISTQB – International Software Testing Qualifications Board, 2019 Disponível em:
https://www.abramti.org.br/b9/doc/syllabus_ctfl_3.1br.pdf. Acesso em: 20 Dez 2021.
SOMMERVILLE, Ian. Engenharia de software. 10. ed. São Paulo: Pearson, 2018. 768 p.
VAZQUEZ, Carlos Eduardo. Engenharia de Requisitos: software orientado ao negócio.
Rio de Janeiro: Brasport, 2016.