Close

Diferentes tipos de testes de software

Compare diferentes tipos de testes de software, como teste de unidade, teste de integração, teste funcional, teste de aceitação e muito mais!

Foto de Sten Pittet
Sten Pittet

Autor colaborador


Existem vários tipos de técnicas de teste de software que você pode usar para garantir que as alterações em seu código funcionem conforme o esperado. No entanto, nem todos os testes são iguais, e exploramos como algumas práticas de teste diferem.

Teste manual vs. automatizado


É importante fazer uma distinção entre testes manuais e automatizados. Teste manual é presencial, ao clicar no aplicativo ou interagir com o software e as APIs com as ferramentas adequadas. Mas o teste manual tem um custo muito alto, já que requer alguém para configurar um ambiente e executar os testes por si mesmo e pode estar propenso a erros humanos, uma vez que o testador pode cometer erros ortográficos ou omitir etapas no script de teste.

Testes automatizados, por outro lado, são realizados por uma máquina que executa um script de teste escrito com antecedência. Esses testes podem variar muito em termos de complexidade, indo desde a verificação de um único método em uma classe à garantia de que realizar uma sequência de ações complexas na interface do usuário leva aos mesmos resultados. São muito mais robustos e confiáveis que testes automatizados. Porém, a qualidade dos testes automatizados depende da qualidade com que seus scripts de teste foram escritos. Se você está apenas começando a usar testes, pode ler o tutorial de integração contínua para ajudar com seu primeiro pacote de teste. Quer conhecer mais ferramentas de teste? Consulte os tutoriais de teste de DevOps.

Testes automatizados são um componente essencial de integração contínua e entrega contínua e é uma ótima maneira de escalar o processo de QA conforme você adiciona novos recursos ao seu aplicativo. Porém, ainda há valor em realizar alguns testes manuais com o que se chama de testes exploratórios, como a gente vai ver neste guia.

Ver solução

Crie e opere softwares com o Open DevOps

Material relacionado

Testes automatizados para DevOps

Os diferentes tipos de testes


Testes de unidade

Testes de unidade são feitos em um nível muito baixo, próximo ao código-fonte do aplicativo. Eles consistem em testar métodos e funções individuais de classes, componentes ou módulos usados pelo software. Testes de unidade, em geral, têm custo baixo para automatizar e podem ser executados com rapidez por um servidor de integração contínua.

Testes de integração

Testes de integração verificam se diferentes módulos ou serviços usados pelo seu aplicativo funcionam bem juntos. Por exemplo, pode ser testar a interação com o banco de dados ou garantir que os microsserviços funcionem juntos conforme o esperado. A execução desses tipos de testes tem um custo maior, uma vez que exigem que várias partes do aplicativo estejam ativas e em execução.

Testes funcionais

Os testes funcionais têm como foco os requisitos de negócios de uma aplicação. Eles só verificam a saída de uma ação e não verificam os estados intermediários do sistema ao executar essa ação.

Às vezes há uma confusão entre testes de integração e testes funcionais, uma vez que ambos exigem vários componentes para interagirem entre si. A diferença é que um teste de integração pode simplesmente verificar que você pode consultar o banco de dados, enquanto um teste funcional esperaria obter um valor específico do banco de dados conforme definido pelos requisitos do produto.

Testes de ponta a ponta

Teste de ponta a ponta replica o comportamento de um usuário com o software em um ambiente de aplicativo completo. Ele verifica se vários fluxos de usuário funcionam como o esperado e podem ser tão simples quanto carregar uma página da web ou fazer login ou cenários muito mais complexos verificando notificações por e-mail, pagamentos on-line etc.

Testes de ponta a ponta são muito úteis, mas têm um alto custo e podem ser difíceis de atualizar quando automatizados. Recomendamos ter alguns testes de ponta a ponta essenciais e contar mais com tipos de testes de nível inferior (testes de unidade e de integração) para poder identificar rapidamente alterações que causam falha.

Teste de aceitação

Os testes de aceitação são testes formais executados para verificar se um sistema atende aos requisitos de negócios. Eles exigem que todo o aplicativo esteja ativo e em execução e foca em replicar os comportamentos do usuário. Porém, também pode ir mais além e medir o desempenho do sistema e rejeitar alterações se determinadas metas não forem cumpridas.

Teste de desempenho

Os testes de desempenho avaliam o desempenho de um sistema sob uma carga de trabalho específica. Esses testes ajudam a medir a confiabilidade, a velocidade, a escalabilidade e a capacidade de resposta de um aplicativo. Por exemplo, o teste de desempenho pode observar tempos de resposta ao executar um grande número de solicitações, ou ver como o sistema se comporta com quantidade significativa de dados. Ele pode determinar se um aplicativo atende aos requisitos de desempenho, localizar gargalos, medir a estabilidade durante picos de tráfego e muito mais.

Teste de sanidade

Testes de sanidade são testes básicos que verificam a funcionalidade básica do aplicativo. Eles são feitos para terem execução rápida e sua meta é garantir que os principais recursos do seu sistema estejam funcionando conforme o esperado.

Os testes de sanidade podem ser úteis logo após um novo build ser feito para decidir se você pode ou não executar testes mais caros, ou logo após uma implementação para garantir que o aplicativo esteja sendo executado como deveria no ambiente recém-implementado.

Como automatizar seus testes


Para automatizar seus testes, você primeiro vai precisar escrevê-los de modo programático usando uma estrutura de teste adequada ao seu aplicativo. PHPUnit, Mocha, RSpec são exemplos de estruturas de teste que você pode usar para PHP, Javascript e Ruby, respectivamente. Há muitas opções por aí para cada linguagem, assim, você precisa pesquisar e pedir para as comunidades de desenvolvedores descobrirem qual seria a melhor estrutura para você.

Quando seus testes podem ser executados por meio de script do seu terminal, você pode fazer com que sejam executados automaticamente por um servidor de integração contínua, como o Bamboo, ou usar um serviço de nuvem, como o Bitbucket Pipelines. Essas ferramentas vão monitorar seus repositórios e executar seu pacote de teste sempre que novas alterações forem enviadas ao repositório principal.

Cada push para o repositório é verificado graças ao Bitbucket Pipelines

Se você está apenas começando a usar testes, pode ler o tutorial de integração contínua para ajudar com seu primeiro pacote de teste.

Teste exploratório


Quanto mais recursos e melhorias forem incluídos no seu código, mais você precisará testar para garantir que seu sistema funcione adequadamente. Então, para cada bug que você corrigir, é bom verificar para que não voltem em novas versões. Automação é crucial para tornar isso possível e escrever testes mais cedo ou mais tarde se tornará parte do seu fluxo de desenvolvimento.

Assim, a pergunta é: ainda vale a pena realizar teste manual? A resposta curta é sim e talvez seja melhor realizar testes exploratórios para descobrir erros não óbvios.

Uma sessão de testes exploratórios não deve exceder duas horas e precisa ter um escopo claro para ajudar os testadores a se concentrar em uma área específica do software. Depois que todos os testadores tiverem sido informados, várias ações devem ser tomadas para verificar como o sistema se comporta.

Uma observação sobre testes


Para terminar este guia, é importante falar sobre o objetivo de testar. Tão importante quanto testar que os usuários conseguem usar o aplicativo (conseguem entrar e salvar um objeto), é testar se seu sistema não quebra quando dados ruins ou ações inesperadas são executadas. Você precisa antecipar o que aconteceria quando um usuário comete um erro de digitação, tenta salvar um formulário incompleto ou usa a API errada. Você precisa verificar se alguém consegue comprometer os dados ou ter acesso a um recurso que não deveria. Uma boa suíte de testes deve tentar quebrar seu aplicativo e ajudar a entender seu limite.

E, finalmente, os testes são código também! Portanto, não os esqueça durante a revisão de código pois eles podem ser o portão final para a produção.

Sten Pittet
Sten Pittet

Estou no ramo de software há 10 anos, em diversas funções, de desenvolvimento a gerenciamento de produto. Depois de passar os últimos 5 anos na Atlassian trabalhando em Ferramentas de Desenvolvimento, agora escrevo sobre como compilar software. Fora do trabalho, estou aprimorando minhas habilidades como pai de uma criancinha maravilhosa.


Compartilhe este artigo
Próximo tópico

Leitura recomendada

Marque esses recursos para aprender sobre os tipos de equipes de DevOps ou para obter atualizações contínuas sobre DevOps na Atlassian.

Ilustração DevOps

Comunidade de DevOps

Ilustração DevOps

Leia o blog

Ilustração do mapa

Comece gratuitamente

Inscreva-se para receber a newsletter de DevOps

Thank you for signing up