Os frameworks de testes são um conjunto de diretrizes e regras usadas para criar e projetar cases de teste. Eles fornecem uma linguagem de teste padronizada e estrutura de relatórios para os aplicativos/softwares que estão sendo testados e podem reduzir os custos de manutenção. Os frameworks vinculam os testes às outras partes do ciclo de vida de desenvolvimento de software (SDLC), como requisitos e defeitos, permitindo que as equipes encontrem e depurem bugs mais rapidamente.
Um framework de testes é composto por todas as ferramentas e práticas destinadas a auxiliar o desenvolvimento de testes de softwares. Estão incluídos: os requisitos necessários, atividades de teste, testes manuais e automatizados, os ambientes/cenários para execução e entre outros.
Os frameworks de testes automatizados se concentram especificamente na otimização dos processos automatizados. Eles proporcionam ciclos mais rápidos, por meio da reutilização de testes e otimizam a criação e a manutenção dos testes, separando os dados da lógica. Existem muitos tipos de frameworks de testes automatizados, por isso é fundamental que opte por um que seja adequado para sua equipe.
Veja como escolher um framework para automação de testes.
Além disto, a utilização de um framework bem estruturado aumenta a eficiência da equipe, a precisão dos testes, a cobertura e reduz os custos e a manutenção, proporcionando um retorno sobre investimento (ROI) maior.
Siga os próximos sete passos apresentados para estabelecer um robusto framework de testes automatizados.
1. Estruture, organize e configure o controle de versão
Comece configurando e organizando uma estrutura de pastas para seus testes. Convém manter diferentes funções separadas umas das outras, como testes, critérios de mapeamento de nomes e scripts. Crie os arquivos que você sabe que precisará em cada um deles. Por exemplo, na pasta “Scripts”, crie arquivos para cada tipo de script: scripts, ações, funções e verificações de eventos. Além disso, certifique-se de criar um arquivo para os dados.
Organizar seus dados desta maneira permitirá que sejam rapidamente encontrados por membros de sua equipe, além de garantir que seus testes sejam estáveis quando as atualizações forem feitas. Este tipo de organização permite revisitar o projeto a qualquer momento, conseguindo encontrar a informação de forma mais rápida e eficaz.
Quando estiver realizando este passo a passo, certifique-se que estará usando uma ferramenta multiplataforma de controle de versão, como o Git ou Mercurial para armazenar o trabalho. No caso de cometer algum erro, nem o trabalho e nem o tempo serão perdidos.
2. Conheça o produto
O segundo passo é se familiarizar com o que será desenvolvido. Ler documentos que descrevam o que o aplicativo/produto deve ou não fazer não é suficiente. É preciso ter informações aprofundadas. Realize testes exploratórios para ter uma ideia de como os fluxos de trabalho internos do sistema são configurados. Esta prática é importante para que você saiba como o produto funciona. Após ter feito isto, será preciso criar um sistema ou atualização para os objetos de UI que estão sendo encontrados. Dependendo da ferramenta que esteja usando, isto pode significar a criação de critérios básicos de mapeamento de nomes ou escrever scripts para as ações que identificam os objetos. O ponto principal desta etapa é o registro das ações. Anote o que foi encontrado e modificado e como a equipe de automação de testes irá testá-los.
3. Determine seus cenários de testes e colete dados
Reúna os dados necessários para os testes e configure os cenários. É primordial que seu setup possa ser executado em mais de um cenário. Nesta etapa, as programações orientadas por eventos são de imensa ajuda. A programação orientada por eventos é uma função composta por códigos, que atua esperando que um evento aconteça para acionar um script ou uma série de scripts. Imagine um aplicativo bancário comum, após um certo tempo de inatividade uma notificação será exibida perguntando se o usuário precisa de mais tempo logado. Se não houver resposta, o aplicativo se desconectará automaticamente por motivos de segurança. A programação de eventos neste cenário é a função que aciona os scripts para a notificação de inatividade e o processo de logout.
Lidar com eventos permite concluir ações que respondem a um evento, sem a necessidade de um conjunto separado de testes para cada ambiente. São instruções de como um sistema deve funcionar, sem as especificações de ambiente e permitirão adicionar complexidade aos seus testes, sem ter que rodá-los manualmente.
Por exemplo, você pode alterar qualquer propriedade de identificação de objetos dinâmicos, como URLs ou nomes de arquivos. Se alterar o nome do aplicativo/produto e precisar apontá-lo para um caminho diferente ou atualizar como ele está instalado, o framework poderá resolver isso com a ajuda da programação de eventos. Os testes neste caso são usados para garantir que partes do aplicativo se comportem conforme o esperado e o framework fornece as ferramentas para tal.
Sobre os dados de testes: o framework deve abrigar os dados separadamente dos testes. Use os repositórios para armazenar dados e manter suas propriedades e referências genéricas, não específicas de teste. Isto permitirá que os dados de objetos sejam compartilhados entre scripts e os dados sejam utilizados em outras partes do projeto, economizando tempo e esforço no futuro.
4. Defina um smoke test
Antes de criar funções e verificações, é essencial que se tenha um projeto de teste de fumaça. Crie um teste de fumaça para certificar-se de que as funções mais essenciais do produto estejam funcionando como esperado e determinar se é necessária a realização de testes adicionais.
Se o smoke test não detectar nada, isto significa que as funções estão funcionando como esperado, desta forma, é possível prosseguir com testes mais complexos. Caso o teste detecte algo, isto significa que a funções básicas não estão respondendo como deveriam. Quando isso acontece, é importante garantir que tais funções sejam resolvidas primeiro. Testes adicionais neste momento só seriam perda de tempo crucial. À medida que seu software/produto amadurece ou se expande em termos de funções e usabilidade, seu conjunto de testes de fumaça também precisa crescer. Lembre que basta apenas um bug para prejudicar um aplicativo e diminuir a reputação de uma empresa.
5. Crie funções para ações na tela
Já tendo se familiarizado com o aplicativo, coletado dados e configurado seus cenários, será preciso criar funções compartilhadas para ações comuns de interface do usuário (UI), como navegação de menu e campos de entrada de texto. Estes são os blocos de testes básicos, que podem se juntar para formar uma lógica de teste. Dependendo da ferramenta que estiver usando, a criação destes blocos pode ser tão simples quanto arrastar e soltar em um teste de palavra-chave. Isto permitirá que o framework coordene seu fluxo de teste e verificações para que precise apenas de uma manutenção mínima para testes individuais.
Uma dica é utilizar classes e frameworks JavaScript em sua estrutura, especialmente para navegação. Desta forma, como estão sendo registradas as ações ou os resultados esperados dos testes, as atualizações poderão ser feitas em apenas em um único local, o que acaba mantendo o registro e os dados consistentes. Isto possibilita que os membros da equipe que não são engenheiros de automação ou desenvolvedores, analisem seus registros de teste e entendam o que está acontecendo. Assim, é capaz de determinar se as falhas são um erro complexo ou simples no aplicativo. Por isso, é importante separar seus dados do framework dos dados de teste reais.
6. Crie e Gerencie as Validações dos Dados
Defina suas validações, aplicando a mesma lógica de como organizou os dados, o que significa que devem ser compartilháveis e reaproveitáveis. Você não quer perder muito tempo ao atualizar todos os testes, especialmente se estiver fazendo isso manualmente. Diferentes inputs devem aceitar dados criados nas etapas anteriores. Esta compatibilidade também permite que quando se faz atualizações em uma área, as novas informações possam ser propagadas em áreas diferentes do seu framework.
7. Configure seu mecanismo de registros e relatórios
A parte final do seu framework de automação é o mecanismo de criação de logs e relatórios. Durante todo o processo de criação, grave e tome notas sobre todas as ações exploratórias, preparações de dados e criação de cenários e verificações. Faça logs das mensagens antes das validações, indicando o que está sendo validado e qual é o resultado esperado. Torne essas mensagens legíveis para que os usuários não técnicos possam ver seu log e saber exatamente onde e como ocorreu uma falha. Erros não devem ser enigmáticos e ninguém deve ter que adivinhar porquê eles aconteceram.
O objetivo desta etapa é ajudar você a padronizar seu processo.
Os relatórios também devem ser automatizados. A automação permitirá reduzir o tempo gasto na geração de relatórios e concentrar a análise dos dados. Se pretende exportar os logs de teste para compartilhar na rede ou em um servidor da web, com a ferramenta certa é possível automatizar todo processo. Se um teste falhar, ficará sabendo imediatamente.