O que é teste de Unidade, Teste de Integração, teste de Fumo, o Teste de Regressão?

https://stackoverflow.com/questions/520064

21-08-2019
|

Pergunta

O que é teste de Unidade, Teste de Integração, teste de Fumo, o Teste de Regressão e quais são as diferenças entre eles?E Quais ferramentas posso utilizar para cada um deles?

Por exemplo eu uso o JUnit e NUnit para o teste de Unidade e Teste de Integração.Há algum Teste de Fumo ou o Teste de Regressão de ferramentas?

Solução

Teste de unidade: Especifique e teste um ponto do contrato de método único de uma classe. Isso deve ter um escopo muito estreito e bem definido. Dependências e interações complexas para o mundo exterior são manchado ou zombado.
Teste de integração: Teste a inter-operação correta de vários subsistemas. Há um espectro inteiro lá, desde a integração de testes entre duas classes até o teste de integração com o ambiente de produção.
Teste de fumaça (também conhecido como verificação de sanidade): Um teste de integração simples, onde apenas verificamos que, quando o sistema em teste é invocado, ele retorna normalmente e não explode.
- O teste de fumaça é uma analogia com a eletrônica, onde ocorre o primeiro teste ao acender um circuito (se fuma, é ruim!) ...
- ... e, aparentemente, com encanamento, onde um sistema de tubos é literalmente preenchido pela fumaça e depois verificado visualmente. Se alguma coisa fuma, o sistema está vazando.
Teste de regressão: Um teste que foi escrito quando um bug foi corrigido. Ele garante que esse bug específico não ocorra novamente. O nome completo é "Teste de não regressão". Também pode ser um teste feito antes de alterar um aplicativo para garantir que o aplicativo forneça o mesmo resultado.

Para isso, vou acrescentar:

Teste de aceitação: Teste que um recurso ou caso de uso é implementado corretamente. É semelhante a um teste de integração, mas com foco no caso de uso a ser fornecido e não nos componentes envolvidos.
Teste do sistema: Testes um sistema como uma caixa preta. As dependências de outros sistemas são frequentemente ridicularizadas ou matizadas durante o teste (caso contrário, seria mais um teste de integração).
Verificação antes do vôo: Testes repetidos em um ambiente semelhante à produção, para aliviar a síndrome 'construir minha máquina'. Muitas vezes, isso é realizado fazendo um teste de aceitação ou fumaça em uma produção como o ambiente.

Outras dicas

Teste de unidade: Um teste automático para testar o funcionamento interno de uma classe. Deve ser um teste independente que não esteja relacionado a outros recursos.
Teste de integração: Um teste automático feito em um ambiente, tão semelhante aos testes de unidade, mas com recursos externos (dB, acesso ao disco)
Teste de regressão: Após a implementação de novos recursos ou correções de bugs, você re-testes que funcionavam no passado. Aqui você cobre a possibilidade em que seus novos recursos quebram os recursos existentes.
Teste de fumaça: Primeiros testes nos quais os testadores podem concluir se eles continuarão testando.

Todos terão definições ligeiramente diferentes, e muitas vezes há áreas cinzentas. No entanto:

Teste de unidade: esse pouco (o mais isolado possível) funciona?
Teste de integração: esses dois (ou mais) componentes trabalham juntos?
Teste de fumaça: Todo esse sistema (o mais próximo possível do sistema de produção) se junta razoavelmente bem? (ou seja, estamos razoavelmente confiantes de que não criará um buraco negro?)
Teste de regressão: inadvertidamente reintroduzimos algum bug que corrigimos anteriormente?

Uma nova categoria de teste que acabei de conhecer é o:

Teste canário

UMA Teste canário é um teste automatizado e não destrutivo que é correr regularmente em um VIVER ambiente, de modo que, se alguma vez falhar, algo muito ruim aconteceu.

Exemplos podem ser:

Tem dados que só devem estar disponíveis no Dev/Test apareceu no LIVE.
Tem um processo de segundo plano falhou em executar
Um logon de usuário pode

Curiosidades históricas apócrifais: "Teste de fumaça" vem da engenharia submarina (herdada do encanamento), onde a fumaça literal seria bombeada para o casco para ver se alguma coisa saiu novamente, o que seria um fracasso dramático para um submarino!

Resposta de um dos melhores sites para técnicas de teste de software:

Tipos de teste de software - Lista completa Clique aqui

É uma descrição bastante longa, não vou colar aqui: mas pode ser útil para alguém que quer conhecer todas as técnicas de teste.

Espero que seja útil :)

Teste de unidade: Verificando esse componente específico (isto é, classe), funções criadas ou modificadas, conforme projetado. Este teste pode ser manual ou automatizado, mas não vai além do limite do componente.

Teste de integração: verificando se a interação de componentes específicos funcionam conforme projetado. Os testes de integração podem ser realizados no nível da unidade ou no nível do sistema. Esses testes podem ser manuais ou automatizados.

Teste de regressão: Verificando se novos defeitos não são introduzidos no código existente. Esses testes podem ser manuais ou automatizados.

Dependendo do seu SDLC (cachoeira, rúpula, ágil, etc.), testes específicos podem ser realizados em 'fases' ou podem ser realizados, mais ou menos ao mesmo tempo. Por exemplo, o teste de unidade pode ser limitado aos desenvolvedores que entregam o código aos testadores para testes de integração e regressão. No entanto, outra abordagem pode ter desenvolvedores fazendo testes de unidade e algum nível de integração e teste de regressão (usando uma abordagem TDD, juntamente com integração contínua e testes de unidade e regressão automatizados).

O conjunto de ferramentas dependerá em grande parte da base de código, mas existem muitas ferramentas de código aberto para testes de unidade (JUNIT). O HP (Mercury) QTP ou a seda de Borland são ferramentas para testes automatizados de integração e regressão.

teste de unidade: O teste de módulo individual ou componente independente em um aplicativo é conhecido por ser testes de unidade, o teste de unidade será realizado pelo desenvolvedor.

teste de integração: Combinando todos os módulos e testando o aplicativo para verificar a comunicação e o fluxo de dados entre os módulos estão funcionando corretamente ou não, esse teste também é realizado pelos desenvolvedores.

teste de fumaça No teste de fumaça, eles verificam a aplicação de maneira superficial e ampla, nos testes de fumaça, eles verificam a principal funcionalidade do aplicativo, se houver algum problema de bloqueador no aplicativo que eles se reportarão à equipe de desenvolvedores, e o desenvolvimento da equipe o consertará e corrigirá o Defeito, e devolvê -lo à equipe de teste e agora a equipe de testes verificará todos os módulos para verificar as alterações do TAT feitas em um módulo, afetarão ou não o outro módulo. Nos testes de fumaça, os casos de teste são roteirizados

Teste de regressão A execução dos mesmos casos de teste repetidamente para garantir que o módulo inalterado não cause defeito. Os testes de regressão estão em teste funcional

Teste de regressão-

"Um teste de regressão reencontra testes anteriores em relação ao software alterado para garantir que as alterações feitas no software atual não afetem a funcionalidade do software existente".

Teste de unidade é direcionado para a menor parte da implementação possível. Em Java, isso significa que você está testando uma única classe. Se a classe depende de outras classes, elas são falsificadas.

Quando o seu teste liga mais de uma classe, é um teste de integração.

As suítes de teste completas podem levar muito tempo para ser executado; portanto, após uma mudança, muitas equipes realizam testes rápidos para concluir para detectar quebras significativas. Por exemplo, você quebrou os URIs a recursos essenciais. Estes são os testes de fumaça.

Testes de regressão Corra em todas as compilações e permita que você refatora efetivamente pegando o que você quebra. Qualquer tipo de teste pode ser o teste de regressão, mas acho que os testes de unidade são mais úteis para encontrar a fonte de falha.

Teste de regressão: Verificando se novos defeitos não são introduzidos no código existente. Esses testes podem ser manuais ou automatizados.

Um tipo de teste que parece valer a pena mencionar neste thread são os testes de estresse/desempenho/carga que podem ser simplesmente colocados como descobrindo os limites além dos quais um certo pedaço de software quebra. Observe que, em termos de ferramentas, é essencial determinar com precisão o escopo do que se propõe para estressar os testes da perspectiva do sistema. Por exemplo, no caso de um teste de estresse de "aplicativo da web" pode incluir em seu escopo o próprio aplicativo do servidor da web e, portanto, as ferramentas poderia intervir nesse final. Aqui está um bom post sobre Teste de carga HTTP

Teste de integração: o teste de integração é a integração do outro elemento
Teste de fumaça: o teste de fumaça também é conhecido como teste de versão Build. Teste de fusão é o processo de teste inicial exercido para verificar se o software em teste está pronto/estável para testes adicionais.
Teste de regressão: O teste de regressão é reagido. Se o novo software é efetuado em outro módulo ou não.
Teste de unidade: é um teste de caixa branca. Apenas os desenvolvedores envolvem nele

Teste de unidade:- O teste de unidade geralmente é feito pelo lado dos desenvolvedores, onde os testadores são parcialmente evoluídos nesse tipo de teste em que o teste é feito unidade por unidade. Nos casos de teste de Java Junit, também pode ser possível testar se o código escrito está perfeitamente projetado ou não.

Teste de integração:- Esse tipo de teste é possível após o teste de unidade quando todos os componentes são integrados. Esse tipo de teste garantirá que, quando os componentes estiverem integrados, eles afetam os recursos de trabalho ou funcionalistas.

Teste de fumaça:- Esse tipo de teste é realizado no último, quando o sistema é integrado com sucesso e pronto para entrar no servidor de produção. Esse tipo de teste garantirá que todas as funcionalidades importantes do início ao fim estejam funcionando bem e o sistema esteja pronto para implantar no servidor de produção.

Teste de regressão:- Esse tipo de teste é importante para testar que defeitos não intencionais/indesejados não estão presentes no sistema quando o desenvolvedor corrigiu alguns problemas. Este teste também garante que todos os bugs sejam resolvidos com sucesso e, por isso, não ocorreram outros problemas.

Teste de unidade: ele sempre é executado pelo desenvolvedor após o desenvolvimento feito para descobrir o problema do lado dos testes antes que eles façam qualquer requisito pronto para o controle de qualidade.

Teste de integração: significa que o testador deve verificar o módulo para verificação do sub -módulo quando alguma saída de dados/função é direcionada para um módulo para outro módulo. Ou no seu sistema, se estiver usando a ferramenta de terceiros que usando os dados do sistema para integrar.

Teste de fumaça: o testador executado para verificar o sistema para testes de alto nível e tentar descobrir o bug do show stopper antes que as alterações ou o código sejam lançados.

Teste de regressão: o testador realizou a regressão para verificação da funcionalidade existente devido a alterações implementadas no sistema para aprimoramento recente ou alterações no sistema.

Os testes de fumaça e sanidade são realizados após uma criação de software para identificar se deve começar a testar. A sanidade pode ou não ser executada após o teste de fumaça. Eles podem ser executados separadamente ou ao mesmo tempo - a sanidade imediatamente após a fumaça.

Como o teste de sanidade é mais aprofundado e leva mais tempo, na maioria dos casos, vale a pena ser automatizado.

O teste de fumaça geralmente não leva mais de 5 a 30 minutos para execução. É mais geral: verifica um pequeno número de funcionalidades principais de todo o sistema, a fim de verificar se a estabilidade do software é boa o suficiente para testes adicionais e que não há problemas, bloqueando a execução dos casos de teste planejados.

O teste de sanidade é mais detalhado que a fumaça e pode levar de 15 minutos até um dia inteiro, dependendo da escala da nova construção. É um tipo mais especializado de teste de aceitação, realizado após progressão ou reestuário. Ele verifica os principais recursos de certas novas funcionalidades e/ou correções de bugs, juntamente com alguns recursos intimamente relacionados a eles, a fim de verificar se eles estão funcionando quanto à lógica operacional necessária, antes que o teste de regressão possa ser executado em maior escala.

Algumas boas respostas já, mas gostaria de refiná -las mais:

O teste de unidade é a única forma de teste de caixa branca aqui. Os outros são testes de caixa preta. O teste de caixa branca significa que você conhece a entrada, conhece o funcionamento interno do mecanismo e pode inspecioná -lo e conhece a saída. Com os testes de caixa preta, você sabe apenas qual é a entrada e qual deve ser a saída.

Tão claramente o teste de unidade é o único teste de caixa branca aqui.

Teste de unidade Teste de peças específicas de código. Geralmente métodos.
Teste de teste de integração se o seu novo software pode interferir com todo o resto.
Teste de regressão. Isso está testando para garantir que você não quebrou nada. Tudo o que costumava funcionar ainda deve funcionar.
O teste de fumaça é feito como um teste rápido para garantir que tudo pareça bem antes de se envolver nos testes mais vigorosos.

Teste de regressão - é um tipo de teste de SW, onde tentamos cobrir ou verificar a correção de bugs. A funcionalidade em torno da correção do bug não deve ser alterada ou alterada devido à correção fornecida. Os problemas encontrados nesse processo são chamados de problemas de regressão.

Teste de fumaça: é um tipo de teste feito para decidir se aceita a construção/software para testes adicionais de controle de qualidade.

O teste de fumaça já foi explicado aqui e é simples. O teste de regressão está no teste de integração.

Testes automatizados podem ser divididos em apenas 2.

Teste de unidade e teste de integração. (Isso é tudo o que importa)

Eu chamaria o uso da frase de "teste longo" (LT) para todos os testes, como teste de integração, teste funcional, teste de regressão, teste de interface do usuário, etc. e teste de unidade como "teste curto".

Um exemplo de LT pode ser carregando automaticamente uma página da web, efetuando login na conta e comprando um livro. Se o teste passar, é mais provável que seja executado no site ao vivo da mesma maneira (daí a referência de 'sono melhor'). Long = Distância entre a página da web (Iniciar) e o banco de dados (END).

E este é um ótimo artigo discutindo os benefícios de Teste de integração (teste longo) sobre testes de unidade

Testes de unidade Testes de unidade são de um nível muito baixo, próximo da fonte de sua aplicação.Eles consistem em testes individuais de métodos e funções das classes, componentes ou módulos utilizados pelo software.Unidade os testes são em geral muito baratos para automatizar e pode ser executado muito rapidamente através de um servidor de integração contínua.

Testes de integração Testes de integração de verificar que diferentes módulos ou serviços usados pelo seu aplicativo de trabalhar bem juntos.Por exemplo, pode estar testando a interação com o banco de dados ou certificando-se de que microservices trabalhar juntos, como esperado.Estes tipos de testes são mais caro executar como eles necessitam de várias partes do aplicativo para estar ativo e em execução.

Testes funcionais Testes funcionais foco sobre os requisitos de negócio de uma aplicação.Eles só verificar a saída de uma ação e não verifique os estados intermediários do sistema quando executar que a ação.

Às vezes há uma confusão entre os testes de integração e testes funcionais como ambos necessitam de vários componentes para interagir uns com os outros.A diferença é que um teste de integração pode simplesmente verifique se que você pode consultar o banco de dados, enquanto que um teste funcional seria esperar para obter um valor específico do banco de dados, conforme definido pela os requisitos de produto.

End-to-end testes End-to-end de testes replica o comportamento do usuário com o software em um ambiente completo da aplicação.Ele verifica que vários fluxos de usuário funciona como esperado e pode ser tão simples como carregar um página da web ou de registo ou muito mais complexos cenários de verificação de e-mail notificações de pagamentos on-line, etc...

End-to-end testes são muito úteis, mas eles são caros para executar e pode ser difícil de manter quando eles estão automatizados.Ele é recomendado para tem alguns tecla end-to-end testes e confiar mais no nível inferior tipos de testes (unitários e testes de integração) para ser capaz de identificar rapidamente alterações de última hora.

Testes de aceitação Testes de aceitação são testes formais executado para verificar se o sistema satisfaz suas necessidades de negócio.Eles exigem todo o aplicativo para ser instalado e em execução e foco em replicar comportamentos do usuário.Mas eles também podem ir mais longe e medir o o desempenho do sistema e rejeitar alterações se determinadas metas não são conheci.

Os testes de desempenho Testes de desempenho de verificação do comportamento da sistema quando está sob carga significativa.Estes testes são não-funcional e pode ter várias formulário para compreender o confiabilidade, estabilidade e disponibilidade da plataforma.Para instância, pode ser observar os tempos de resposta durante a execução de uma alta número de pedidos, ou para ver como o sistema se comporta com um significativa de dados.

Os testes de desempenho são, por natureza, bastante dispendiosa e executar, mas eles podem ajudar você a entender se a novas mudanças vão degradar o seu sistema.

Fumaça de testes Fumaça testes são testes básicos que verifique básico a funcionalidade do aplicativo.Eles são feitos para ser rápido para executar, e seu objetivo é dar-lhe a garantia de que os principais recursos do seu sistema estão funcionando como esperado.

Fumaça testes podem ser úteis para a direita depois de uma nova compilação é feita para decidir se você pode ou não executar mais caro testes, ou o direito depois de um implantação para se certificar de que eles aplicativo está sendo executado corretamente em o recém-implantado ambiente.

fonte: https://www.atlassian.com/continuous-delivery/software-testing/types-of-software-testing

Eu só queria acrescentar e dar mais alguns contexto no qual temos esses níveis de teste, o que eles realmente querem dizer com exemplos

Mike Cohn em seu livro "Sucesso com o Agile" veio com o "Teste de Pirâmide", como uma forma de abordagem de testes automatizados em projetos.Há várias interpretações a este modelo.A modelo explica que tipo de testes automatizados precisam ser criados, quão rápido eles podem dar feedback sobre a aplicação sob teste e quem escreve estes testes.Basicamente, existem 3 níveis de testes automatizados são necessários para qualquer projeto e eles são como se segue.

Testes De Unidade- Estes testes o menor componente da sua aplicação de software.Este poderia ser literalmente uma função em um código que calcula um valor com base em algumas entradas.Esta função faz parte de várias outras funções do hardware/software de base de código que faz a aplicação.

Por exemplo, Vamos tomar um aplicativo de calculadora.O menor componentes desta aplicação que precisa ser unidade testada poderia ser uma função que executa disso, outro que realiza a subtração e assim por diante.Todas essas pequenas funções juntos compõe a aplicação calculadora.

Historicamente programador escreve estes testes, como eles são geralmente escritos na mesma linguagem de programação como o aplicativo de software.O teste de unidade de frameworks como o JUnit e NUnit (para java), MSTest (para C# e .NET) e Jasmim/Mocha (JavaScript) são utilizados para esta finalidade.

A maior vantagem de testes de unidade são, eles correm muito rápido por baixo da INTERFACE do usuário e podemos obter feedback rápido sobre a aplicação.Isso deve representar mais de 50% dos testes automatizados.

API/Testes de Integração- Estes testar vários componentes do sistema de software em conjunto.Os componentes podem incluir testes de bancos de dados, API (Interface de Programação de Aplicativo), 3 ferramentas e serviços, juntamente com a aplicação.

Por exemplo - Em nossa calculadora exemplo acima, o aplicativo da web pode usar um banco de dados para armazenar os valores, use a API para fazer algumas validações do lado do servidor e pode usar uma festa de 3 ferramenta/serviço para publicar os resultados para a nuvem, para torná-lo disponível em diferentes plataformas.

Historicamente, um programador ou técnico de QA iria escrever estes testes usando várias ferramentas, tais como Carteiro, SoapUI, o JMeter e outras ferramentas como Testim.

Estes correr muito mais rápido do que testes de INTERFACE do usuário, como eles ainda correm por baixo do capô, mas pode consumir um pouco mais de tempo do que testes de unidade como ele tem, para verificar a comunicação entre os vários componentes independentes do sistema e garantir que eles tenham a perfeita integração.Isso deve representar mais que 30% dos testes automatizados.

Testes de INTERFACE do usuário- Finalmente, temos testes que validam a INTERFACE de usuário do aplicativo.Estes testes são geralmente escritos para o teste final para terminar flui através do aplicativo.

Por exemplo, No aplicativo de calculadora, uma ponta a ponta fluxo poderia ser, a abertura do navegador-> Introduzir o aplicativo calculadora url -> fazer o login com nome de usuário/senha -> Abrir a aplicação calculadora -> execução de algumas operações na calculadora -> verificar os resultados a partir da INTERFACE do usuário -> registro em Log do aplicativo.Este poderia ser um fim para fim de vazão que seria um bom candidato para automação de INTERFACE do usuário.

Historicamente, a técnica de QA ou manual testadores escrever testes de INTERFACE do usuário.Eles usam frameworks open source, como o Selênio ou de teste de UI plataformas, como Testim ao autor, executar e manter os testes.Estes testes dão mais feedback visual como você pode ver como os testes são executados, a diferença entre os resultados previstos e reais, através de imagens, logs, relatórios de ensaio.

A maior limitação de testes de INTERFACE do usuário é, eles são relativamente lento quando comparado com Unidade e nível de API de testes.Por isso, ele deve conter apenas 10% a 20% do total de testes automatizados.

Os próximos dois tipos de testes pode variar com base no seu projeto, mas a idéia é-

Fumaça Testes

Esta pode ser uma combinação de acima de 3 níveis de teste.A ideia é executá-lo durante todo o código de verificação no e assegurar a crítica funcionalidades do sistema ainda estão funcionando conforme o esperado;após o novo código de alterações são mescladas.Eles normalmente precisam para executar com 5 - 10 minutos para chegar mais rápido feedback sobre falhas

Testes De Regressão

Eles normalmente são executados uma vez por dia pelo menos e cobrir várias funcionalidades do sistema.Eles garantem que o aplicativo ainda está funcionando como esperado.Eles são muito mais detalhes do que a fumaça testes e cobrir mais cenários de aplicação, incluindo as não-críticas.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow