Por que deixar / não permitir que os desenvolvedores testem seu próprio trabalho

Quero reunir alguns argumentos sobre por que deixar um desenvolvedor testar seu próprio trabalho como a última etapa antes que o produto entre em produção é uma má ideia, porque, infelizmente, meu local de trabalho às vezes faz isso (a última vez que surgiu , o argumento se resumia a muitas pessoas ocupadas demais com outras coisas e sem tempo para familiarizar outra pessoa com essa parte do programa - é um software muito especializado).

Existem planos de teste neste caso (embora nem sempre), mas sou muito favorável a fazer uma pessoa que não fez as alterações testadas na verdade fazendo o teste final. Por isso, estou perguntando se você poderia me fornecer uma lista boa e sólida de argumentos que eu possa apresentar na próxima vez que isso for discutido. Ou para fornecer contra-argumentos, caso você ache perfeitamente correto, especialmente quando houver casos de teste formais para testar.

Como outros (e você) notaram, os desenvolvedores devem testar seu próprio código. No entanto, depois disso, qualquer produto não trivial também deve ser testado por pessoa (s) independente (s) (departamento de controle de qualidade e / ou o próprio cliente).

Os desenvolvedores normalmente trabalham com a mentalidade de "como fazer isso funcionar?" . Um bom testador está pensando em "como quebrar isso?" - uma mentalidade muito diferente. O teste de unidade e o TDD ensinam os desenvolvedores a mudar de chapéu em certa medida, mas você não deve confiar nisso. Além disso, como outros observaram, há sempre a possibilidade de entender mal os requisitos. Portanto, os testes finais de aceitação devem ser conduzidos por alguém o mais próximo possível do cliente .

O desenvolvedor sabe como seu código funciona e terá o hábito de testar seu código de acordo com esse conhecimento.

O desenvolvedor achará difícil remover-se da mentalidade de 'como funciona' em oposição a 'como deve funcionar'.

Por isso, é melhor fazer com que alguém com um alto grau de objetividade teste o programa, como controle de qualidade ou engenheiros de teste

Testadores Teste para quebrar, Simples. Esse tipo de viés é necessário para realmente descobrir as rolhas do programa.

Os desenvolvedores DEVEM testar seu trabalho. É uma responsabilidade implícita.

Suponho que você não tenha uma equipe dedicada a fazer os testes com base em sua declaração. No entanto, ter uma equipe dedicada a testes realmente ajudará, pois os desenvolvedores tendem a testar seu código da maneira que o codificou. Isso não significa que, uma vez que você tenha algum tipo de equipe de garantia da qualidade, já poderá realizar os testes como uma responsabilidade dos desenvolvedores.

Os desenvolvedores geralmente usam redes com buracos enormes para capturar bugs. Como resultado, pequenos bugs escapam.

Porque os desenvolvedores não são bons em tentar quebrar seu próprio código. Sua mente simplesmente segue o caminho correto de entrada de dados e interação com o aplicativo. Muitos erros são o resultado de interagir com o sistema como um cara normal . Os desenvolvedores não são usuários normais. Eles são usuários profissionais.

Existem algumas boas razões para ter uma equipe de testes dedicada. Primeiro, como mencionado acima, os desenvolvedores são muito bons em testar se seu código funciona, mas não em quebrá-lo.

Além disso, como você diz, um desenvolvedor sabe o que escreveu, mas uma equipe de teste sabe o que deveria ter sido escrito. Às vezes, esses dois conceitos não correspondem. Um dos trabalhos da equipe de teste é garantir que o software atenda aos requisitos. Em muitos casos, um desenvolvedor conhece apenas algumas partes do sistema muito bem, mas a equipe de controle de qualidade sabe tudo.

O que leva ao próximo motivo: as equipes de teste fazem testes de integração completa. O trecho de código que você acabou de escrever pode funcionar por si só, mas pode quebrar outras funcionalidades desconhecidas.

Tendo trabalhado com uma equipe de controle de qualidade e sem, posso dizer que aprecio 100% o trabalho que eles fazem e vou dizer que eles são uma parte valiosa da equipe de software. Quando você tem uma equipe de controle de qualidade, a liberação do código é muito mais fácil, porque você sabe que foi testado completamente e isso significa que você receberá menos chamadas às três da manhã.

Os desenvolvedores devem testar seu próprio código de unidade.

Os testadores independentes não apenas testam para quebrar, mas também testam as suposições não declaradas e indefinidas que os desenvolvedores fizeram ao codificar.

Eu esperaria que o desenvolvedor fizesse alguns testes iniciais antes de confirmar qualquer alteração e se certificasse de que o código funciona. Eu esperaria que o desenvolvedor alimentasse nos casos de teste qualquer conhecimento específico de 'caixa branca' que eles tivessem. Por exemplo, detalha outras áreas do código que podem ter sido afetadas.

A principal objeção aos desenvolvedores que testam seu próprio código é que você está testando apenas um ponto de vista. O desenvolvedor leu a especificação e a interpretou. Esperamos que a especificação seja clara, completa e inequívoca, mas nem sempre é esse o caso. O desenvolvedor pode ter interpretado mal parte da especificação. Se eles testarem seu próprio código, isso não será detectado, pois eles descobrirão que a função opera conforme o esperado.

Pessoas diferentes também tendem a usar um produto de maneira diferente e, como resultado, seguem rotas diferentes pelo código. Um desenvolvedor garantirá que o código funcione para eles, mas pode não ter considerado um caso delicado encontrado por outro testador.

Os desenvolvedores devem testar seu próprio trabalho. Permitir que os desenvolvedores enviem trabalhos não testados para uma equipe de controle de qualidade ou seus colegas de desenvolvimento é uma péssima idéia. Isso desperdiça o tempo de desenvolvedores e testadores e arruina os relacionamentos.

No entanto, isso nem sempre é suficiente. É provável que os desenvolvedores sigam um caminho feliz pelo sistema ou fiquem cegos a algumas idiossincrasias às quais foram expostos repetidamente ao longo do desenvolvimento.

Outro ponto é que pode haver várias camadas de comunicação entre especificação e implantação. Isso pode levar a um efeito de sussurros chineses na implantação final. É melhor se quem definiu o requisito ou o relatório de erros testar se funciona da maneira que queria.

Como desenvolvedor, você é responsável por seu próprio código, deve testá-lo. Does the feature work as expected?Se a resposta for sim, você está pronto.

Por que você não deveria fazer casos de teste?

1. Você é subjetivo , pois os erros encontrados são escritos por você (ou por seus colegas).
2. Você é muito caro para a empresa executar testes de caso. (Eu espero).

Normalmente, os desenvolvedores não serão, na maioria dos casos, os que usam o código, exceto em certos casos especializados. Portanto, a última etapa de teste antes da promoção para um sistema de produção deve ser o teste de aceitação do usuário, UAT. Eles geralmente [deveriam] estar mais familiarizados com o que eles esperam que o pacote esteja fazendo. E geralmente são mais capazes de interromper as coisas com fluxos de entrada desconhecidos para alguém que não as usa no dia a dia.

Seus planos de projeto não atendem a testes de usuários? Se você conseguir que os usuários o testem, poderá detectar erros antes da pós-implementação, o que no meu mundo não é ruim.

Os desenvolvedores não devem testar seu próprio código, porque isso é semelhante a julgar a arte de seu próprio filho. Vai ficar lindo para você de qualquer maneira, e você realmente precisa de um profissional para apontar as falhas. O teste de unidade, por outro lado, é semelhante a garantir que seu filho não esteja tentando pintar com chumbo.

Caso você REALMENTE não queira contratar controle de qualidade, peça aos desenvolvedores que escrevam código de teste para outros desenvolvedores. Esse é um bom primeiro passo - em breve você verá desenvolvedores solicitando recursos de controle de qualidade, porque a maior parte do tempo é gasta no teste de códigos de terceiros, além do CR.

Não são apenas os desenvolvedores que protegem seu código, se eles não percebem um caso específico ou interpretam mal uma especificação na maneira como desenvolvem algo, eles vão sentir falta desses casos ao testar seu código.

As técnicas e habilidades para testes também são muito diferentes.

A maioria dos testes realizados por uma equipe de teste é funcional (que um produto funciona de acordo com uma especificação) e caixa preta (a equipe de teste não verá o funcionamento interno de um aplicativo). Os testadores funcionais não precisam se preocupar com o modo como as coisas funcionam, eles precisam apenas se concentrar se o fazem.

Na minha experiência, pelo menos na minha pequena organização, o usuário final precisa testar. Quase todos os projetos que obtemos, eles não fornecem todas as informações necessárias e sempre deixam de fora certos detalhes. O desenvolvedor está sempre em desvantagem de teste porque ele não sabe como fazer o trabalho do usuário, portanto, embora saiba que o software funciona de acordo com as informações que recebeu, ele não sabe se isso ajudará o usuário final. fazem o trabalho deles.

Os desenvolvedores interpretam mal e interpretam mal os requisitos, e os responsáveis ​​pelos requisitos geralmente falham em especificar coisas importantes. Se ninguém, exceto o desenvolvedor, testar, ninguém encontrará essas desconexões antes de entrar no ar. Quando os desenvolvedores testam, eles sabem muito sobre como deve funcionar e não tentam as coisas estúpidas que os usuários podem tentar. Os desenvolvedores também escrevem seus testes com base em sua própria interpretação do requisito, que muitas vezes não é o que realmente significava. Portanto, os testes são aprovados, mas o requisito não foi atendido. Quando você faz um teste de pessoa diferente, essa pessoa pode ter uma idéia diferente dos requisitos e geralmente encontra os locais onde a exigência foi mal expressa pela forma como duas pessoas diferentes a interpretam. Muito melhor descobrir isso nos testes do que depois que você for ao vivo.

O desenvolvedor deve fazer o teste inicial para que possamos saber que a peça que codificamos funcionaria da maneira que se espera que funcione, conforme os requisitos que obtivemos. Portanto, realizamos os testes normais e escrevemos testes de unidade para o código que escrevemos.

O próximo passo é o trabalho dos QAs para descobrir o que os desenvolvedores não veem quando escrevemos o código. Um desenvolvedor pensa em um nível superior, mas o usuário pode não pensar no mesmo nível. Quando o desenvolvedor está testando sua peça e precisa inserir algum texto em uma caixa de texto, ele pode sempre inserir uma string completa, pensando que o usuário também faria isso. Pode ser que o usuário faça isso também, mas aleatoriamente quando ele digita um caractere especial como% & $ ^ no texto e que quebra o aplicativo, ele não fica bem no usuário final. Um desenvolvedor não pode nem vai pensar em todas as possibilidades que poderiam acontecer porque ele não é treinado para pensar dessa maneira. Quando se trata de um controle de qualidade (testador), eles sempre pensam no que o usuário pode fazer para quebrar esse aplicativo e tentar todas as coisas estúpidas do livro, não os usuários são estúpidos, mas não devemos deixar nada ao acaso.

Agora também temos que entender que geralmente há mais de uma peça feita ao mesmo tempo e ambas irão para a produção. O desenvolvedor pode testar apenas sua peça e achar que está funcionando bem, mas o teste de regressão geral precisa ser feito para todas as peças que estão sendo empurradas, além de descobrir que a combinação de duas peças diferentes pode interromper o aplicativo. também não parece bom. Também precisamos considerar os cenários de teste de carga e outras coisas com as quais os testadores estão mais familiarizados.

Finalmente, temos que passar pelo UAT (Teste de aceitação do usuário) para ver se a peça que fizemos é o que é esperado. Geralmente, embora os requisitos atinjam os bacharéis, a pessoa final pode não saber exatamente como ela se parece e ele / ela pode pensar que não é o que eles esperavam ou podem querer adicionar outra coisa para torná-la melhor ou, por algum motivo, eles podem descartar o peça inteira como eles acham que a peça não iria com a funcionalidade já disponível.

Conforme explicado acima, eles são muito importantes e não podem ser feitos apenas pelo desenvolvedor e são absolutamente necessários para que o aplicativo funcione bem. A gerência pode dizer que esta é uma abordagem conservadora, mas é a melhor abordagem. Podemos fazer alguns ajustes no que foi dito acima, mas não podemos evitar o todo.

Os comentários acima levantam grandes pontos.

Um adicional não mencionado anteriormente é que ter um código de teste individual separado atua como uma verificação adicional dos requisitos e se o sistema os implementa corretamente.

Requisitos e documentação não são perfeitos, e muitas vezes a implementação é resultado da interpretação dos requisitos por um desenvolvedor.

Quando o teste é realizado por um indivíduo separado, eles também fornecem sua própria interpretação dos requisitos ao criar o plano de teste e executar os testes.

Quando as atividades de teste são realizadas independentemente das atividades de desenvolvimento e as saídas de ambos "concordam", isso fornece uma confirmação adicional de que o sistema está correto e realmente corresponde à intenção original dos requisitos.

Um programador, ao testar, verá uma caixa de texto chamada "Quantidade" e inserirá "1". Um programador altamente experiente fará um teste de acompanhamento com o valor "2".

Um usuário verá uma caixa de texto chamada "Quantidade" e digitar "~~ unicorns ROX !!! ~~". Um usuário experiente também tentará "-12 1/2".

Felizmente, um testador estará lá em algum lugar para alertar o programador sobre o que o usuário experimentará quando fizer essas coisas.

Uma razão é porque os desenvolvedores estão muito próximos de seu próprio código. Eles sabem que é peculiar, são pequenos comportamentos estranhos. Eles tendem a testar em torno das pequenas idiossincrasias que eles conhecem tão bem. Eles não são objetivos o suficiente sobre isso. As equipes de teste o tratam como uma caixa preta. Eles escrevem matrizes de dezenas ou centenas de casos de teste e os percorrem metodicamente para ver o que o código fará. Muitas vezes, eles criam cenários com os quais a equipe de desenvolvimento nunca sonharia.

Outra razão é o tempo. Para grandes projetos construídos em estágios, a equipe de desenvolvimento criará o Estágio 1. Em seguida, os testadores o testarão enquanto o Estágio 2 estiver sendo construído e os defeitos do Estágio 1 serão corrigidos. Isso acontece em todas as etapas, portanto, a etapa que está sendo testada é a anterior que foi construída.

Quero reunir alguns argumentos sobre por que deixar um desenvolvedor testar seu próprio trabalho como a última etapa antes do teste entrar em produção é uma má ideia, porque, infelizmente, meu local de trabalho às vezes faz isso (a última vez que surgiu , o argumento se resumia à maioria das pessoas ocupadas demais com outras coisas e não tendo tempo para familiarizar outra pessoa com essa parte do programa - é um software muito especializado).

Os testes não são opcionais para um desenvolvedor. Um desenvolvedor precisa testar o código que ele escreveu. De que outra forma ele pode ter certeza de que a tarefa foi realizada com sucesso? Você precisa escrever algum tipo de teste automatizado (unittests) ou executar o trabalho de verificar "a máquina está fazendo o que eu quero" manuall (usando a GUI, chamando o comando na linha de comando ou o que for).

Tudo o que está sendo testado depois disso é "apenas" testes adicionais por outras pessoas (colegas de trabalho, controle de qualidade, ...). Não há alternativa ao teste direto por um desenvolvedor. Todo mundo que me diz que um desenvolvedor não precisa testar (ou mesmo não tem permissão para) o código / recurso que ele escreveu simplesmente não tem entendimento de como o software está sendo desenvolvido.

Ele é testado por alguém não familiarizado com o código, quer você goste ou não. A questão é se você deseja que alguém seja seu cliente.

Ótima pergunta. Na sua situação, existem casos de teste - às vezes - e o software parece ser complexo o suficiente para que não seja prático obter um iniciante na velocidade do produto. Você também diz que o teste realizado é o teste final antes da produção

Motivos pelos quais o desenvolvedor pode fazer o teste final

• Existem outras coberturas de testes suficientes ... Existem testes de unidade, existe um ambiente de teste de integração e é usado, testes de interface do usuário, testes exploratórios etc. foram executados etc. etc. Um teste final é menos um critério de aceitação rigoroso do que um final " percorrer "
• Existe um conjunto de casos de teste escritos por um SQA / Tester profissional que alguém (um desenvolvedor) pode / precisa seguir explicitamente
• O risco de falha do recurso / produto / módulo foi mitigado para níveis baixos (deixe o profissional testar as áreas de alto risco e um "novato" testar o menor risco)
• A realidade da situação comercial é que liberar um produto com defeitos em potencial é melhor do que atrasar o lançamento
• O desenvolvedor em questão também é um testador muito qualificado e é capaz de fazer mentalmente a mudança de papéis
• A mudança é uma correção de bug feita em campo pelo desenvolvedor quando o site do cliente é desligado ou perde receita devido ao sistema estar offline (um patch que será trazido de volta ao escritório e testado / lançado em uma versão controlada o mais rápido possível) )

Motivos pelos quais um desenvolvedor não deve fazer o teste

• Algo mais

Em geral, parece que você está no caminho certo para atacar a solução real - peça ao especialista em SQA que gere os casos de teste ...

Nota: Em geral, sou a favor de permitir que os desenvolvedores façam o teste, mas asseguro que o primeiro ponto esteja disponível ....

Os seres humanos, sendo humanos, tendem a sofrer de viés cognitivo - onde seus julgamentos em dois cenários quase idênticos serão diferentes, simplesmente por causa de algumas coisas que mudaram - uma coisa que notei em 8 anos de desenvolvimento é que, quando um desenvolvedor Quando se depara com o teste de seu próprio código, em oposição ao código que um colega escreveu, o teste realizado em seu próprio código tem uma qualidade muito pior.

Isso não quer dizer que o desenvolvedor tenha uma falha direta - seu cérebro usará o viés que o escreveu, para reforçar o fato de acreditar que é certo e realizará apenas verificações básicas, em oposição a um desenvolvedor que está olhando o código de outra pessoa, fará verificações muito mais completas.

Existem milhares de exemplos por aí em que procedimentos foram implementados para evitar viés cognitivo, ou comumente conhecido como "O fator humano", como sistemas computadorizados de controle de tráfego aéreo, para impedir que duas aeronaves diferentes ocupem o mesmo espaço aéreo ao mesmo tempo. tempo, aos procedimentos médicos implementados, para que mais de um médico tenha que fazer um diagnóstico.

Já era hora de o setor de TI adotar uma atitude mais profissional e implementar procedimentos para impedir o teste de seu próprio código.

• Todos devem testar - desenvolvem código de teste, QA'ers, funcionalidade de teste, mensagens de teste de marketing. Dessa forma, todos compartilham as mesmas filosofias e linguagem em torno dos testes, o que é metade da batalha.

• Testar é manutenção de rotina e eu costumo usar analogias para comparar . Por exemplo, a analogia da troca de óleo do carro. Você nunca 'precisa mudar' seu óleo. Mas você faz isso regularmente de qualquer maneira. O mesmo para escovar os dentes. Há uma razão para você mantê-los diariamente - eles não vão quebrar 'hoje', é tudo sobre o amanhã e os dias futuros e fazer um investimento.

• Todos devem compartilhar a responsabilidade de testar. Uma equipe de controle de qualidade é importante, no entanto, fazer "testes" como algo que somente a equipe de controle de qualidade faz com que seja uma atividade "separada" que não é integrada ao desenvolvimento e fluxo de trabalho do produto, o que não é uma coisa boa.

• Quando alguma coisa quebra na produção, faça duas coisas:

  1. Diga "hmm, temos um teste para isso " como o primeiro comentário.
  2. Faça com que qualquer correção inclua testes para o problema , primeiro a reproduzir, que corrigi-lo.

Na minha empresa, criamos alguns aplicativos financeiros bastante complexos. Nossa política geral é que o desenvolvedor garanta que nenhum erro técnico ocorra. Basicamente, tente de tudo para quebrá-lo, considerando os recursos do usuário. Quando você não encontrar um erro de tempo de execução, envie-o aos BAs para teste. Tivemos alguns desenvolvedores que se perderam nos testes de requisitos de negócios a ponto de esgotar-se, mas apenas porque todos esses testes não eram de sua responsabilidade. A menos que haja algum erro flagrante que seja claramente visível, enviamos para as pessoas que são pagas para entender o resultado. Além disso, os usuários devem ter um papel real na verificação dos resultados. O balconista de uma loja de varejo não experimenta as roupas para você, elas apenas o ajudam com os "detalhes técnicos", como encontrar roupas do tamanho certo.

Uma questão é que os desenvolvedores têm pouco incentivo para quebrar seu próprio código - poucas pessoas estão dispostas a procurar defeitos em seus próprios trabalhos ou estão dispostas a cometer erros. Ter uma equipe separada ajuda a garantir que as coisas sejam quebradas.

Uma função de Garantia da qualidade é essencial, entre outros motivos, para que alguém possa verificar se o desenvolvedor entendeu os requisitos. O desenvolvedor não pode fazer isso sozinho, porque se eles pensassem que haviam entendido mal, isso exigiria esclarecimentos.