Em ágil como o desenvolvimento, que deve escrever casos de teste? [fechadas]

https://stackoverflow.com/questions/194790

10-07-2019
|

Pergunta

A nossa equipe tem um sistema de tarefas, onde postamos pequenas tarefas incrementais atribuídos a cada colaborador.

Cada tarefa é desenvolvido em seu próprio ramo, e, em seguida, cada ramo é testado antes de ser mescladas para o tronco.

A minha pergunta é: Quando a tarefa for feito, quem deve definir os casos teste que devem ser feitas a esta tarefa?

Idealmente, eu acho que o desenvolvedor a tarefa a si mesmo é mais adequado para o trabalho, mas eu tinha um monte de resistência por parte de desenvolvedores que pensam que é um desperdício de seu tempo, ou que eles simplesmente não gostam de fazê-lo.

A razão que eu não gosto de ter meus QA pessoas fazê-lo, é porque eu não gosto da idéia deles criando seu próprio trabalho. Por exemplo, eles podem deixar de fora coisas que são simplesmente muito trabalho para teste, e eles podem não saber os detalhes técnicos que é necessário.

Mas de igual modo, a parte de baixo de desenvolvedores fazendo os casos de teste, é que eles podem deixar de fora coisas que eles acham que vai quebrar. (Mesmo inconscientemente talvez)

Como gerente de projeto, acabei escrevendo os casos de teste para cada tarefa a mim mesmo, mas meu tempo é tributado e eu quero mudar isso.

Sugestões?

EDIT: por casos de teste refiro-me à descrição das tarefas de controle de qualidade individuais que devem ser feitas para o ramo antes de ser mescladas para o tronco. (Black Box)

Solução

O Team.

Se um defeito chega a um cliente, é da equipe falha, portanto, a equipe deve ser escrever casos de teste para garantir que os defeitos não chegar ao cliente.

O Project Manager (PM) deve compreender o domínio melhor do que ninguém na equipe. O seu conhecimento de domínio é vital a ter casos de teste que fazem sentido no que diz respeito ao domínio. Eles terão de fornecer exemplos de entradas e responder a perguntas sobre as expectativas de entradas inválidas. Eles precisam fornecer pelo menos o caso de teste 'feliz caminho'.
O desenvolvedor (s) vai saber o código. Você sugere o desenvolvedor pode ser melhor para a tarefa, mas que você está procurando casos de teste caixa preta. Quaisquer testes que um desenvolvedor vem com são testes caixa branca. Essa é a vantagem de ter os desenvolvedores a criar casos de teste - eles sabem onde as costuras no código são.

Os bons programadores vão também estar chegando ao PM com perguntas "o que deve acontecer quando ...?" - cada um deles é um caso de teste. Se a resposta é complexa "Se a , em seguida, x , mas se b , em seguida, y , exceto às quintas-feiras" - existem vários casos de teste.
Os Testers (QA) sabe como software de teste. Testadores são susceptíveis de vir para cima com casos de teste que a PM e os desenvolvedores não iria pensar -. É por isso que você tem testadores

Outras dicas

Eu acho que o gerente de projeto, ou Business Analyst deve escrever esses casos de teste.
Eles devem, em seguida, entregá-los para a pessoa QA à carne para fora e teste.

Dessa forma, você garantir que não haja lacunas que faltam entre o spec, e que está realmente testado e entregue.

o desenvolvedor deve definitivamente não fazê-lo, como eles vão estar testando seus testes de unidade. Portanto, é um desperdício de tempo.

Além disso, estes testes irão encontrar erros que o desenvolvedor nunca vai encontrar como eles são, provavelmente, devido a um mal-entendido na especificação, ou um recurso ou rota através do código não tendo sido pensada e implementada corretamente.

Se você achar que você não tem tempo suficiente para isso, contratar alguém, ou promover alguém para este papel, como é a chave para proporcionar um excelente produto.

Nós experimentou com um emparelhamento do desenvolvedor com uma pessoa QA com bons resultados bonitas. Eles geralmente 'manteve o outro honesto' e desde que o desenvolvedor tinha testes de unidade para lidar com o código, ele / ela foi bastante íntima já com as alterações. A pessoa QA não era, mas veio para ele do lado caixa preta. Ambos foram responsabilizados pela completude. Parte do processo de revisão em curso ajudou a deficiências de teste de unidade de captura e por isso não havia muitos incidentes que eu estava ciente de onde ninguém foi propositadamente evitando escrever teste X porque ele provavelmente iria provar que houve um problema.

Eu gosto da idéia de emparelhamento em alguns casos, e acho que funcionou muito bem. nem sempre pode funcionar, mas ter esses jogadores de diferentes áreas interagem ajudaram a evitar o 'jogá-lo por cima do muro' mentalidade que muitas vezes acontece.

De qualquer forma, espero que de alguma forma é útil para você.

A experiência do passado, tivemos muito boa sorte a definição de testes em diferentes níveis para testar as coisas um pouco diferentes:

1ª níveis: ao nível do código / aula, os desenvolvedores devem estar escrevendo testes de unidade atômicas. O objetivo é testar classes e métodos individuais, tanto quanto possível. Estes testes devem ser executados por desenvolvedores como eles codificam, presumivelmente antes de arquivar o código no controle de origem, e por um servidor de integração contínua (automatizado) se um está sendo usado.

2 níveis: No nível de integração de componentes, mais uma vez tem desenvolvedores que criam testes de unidade, mas que o teste da integração entre os componentes. O propósito não é para testar as classes e os componentes individuais, mas para testar como eles interagem uns com os outros. Estes testes devem ser executados manualmente por um engenheiro de integração, ou automatizado por um seerver-integração contínua, se alguém está em uso.

3ª níveis: No nível do aplicativo, têm a equipe de QA executando seus testes do sistema. Esses casos de teste deve ser baseado fora dos pressupostos empresariais ou documentos de requisitos fornecidos por um gerente de produto. Basicamente, o teste como se fosse um usuário final, fazendo as coisas que os usuários finais devem ser capazes de fazer, como documentado int eh requisitos. Esses casos de teste devem ser escritos pela equipe de QA e os gerentes de produto que (presumivelmente) saber o que o cliente quer e como eles são esperados para usar o aplicativo.

Eu sinto que este fornece um bom nível de cobertura. Claro, os níveis 1 e 2 acima devem, idealmente, ser executado antes de enviar um aplicativo criado para a equipe de QA. Claro, você pode adaptar este para o que se adequa ao seu modelo de negócio, mas isso funcionou muito bem no meu último emprego. O nosso servidor contínuo-integração ia chutar para fora um e-mail para a equipe de desenvolvimento se um dos testes de unidade falha durante o processo de construção / integração também, meter alguém se esqueceu de executar seus testes e comprometidos código quebrado no arquivo fonte.

"Os desenvolvedores que pensam que é um desperdício de seu tempo, ou que eles simplesmente não como fazê-lo" Então recompensá-los por isso. O que a engenharia social é necessário para obtê-los para criar casos de teste?

Can QA olhar sobre os casos de código e teste e pronuncie "Not Enough Cobertura - Precisa de mais casos". Se assim for, então o programador que tem cobertura de "suficiente" de imediato será o Big Kahuna.

Então, minha pergunta é: Quando a tarefa for feito, quem deve definir a meta de casos de teste "suficientes" para esta tarefa? Uma vez que você sabe "o suficiente", você pode fazer os programadores responsáveis ??pelo preenchimento de "suficiente" e QA responsável por assegurar que o teste de "suficiente" é feito.

Muito difícil de definir "o suficiente"? Interessante. Provavelmente esta é a causa raiz do conflito com os programadores em primeiro lugar. Eles podem sentir que é um desperdício de seu tempo, porque eles já fizeram "suficiente" e agora alguém está dizendo que não é "suficiente".

o povo QA, em conjunto com o "cliente", deve definir os casos de teste para cada tarefa [nós realmente estamos misturando terminologia aqui], eo desenvolvedor deve escrever-los. em primeiro lugar!

A razão que eu não gosto de ter meus QA pessoas fazê-lo, é porque eu não gosto da idéia deles criando seu próprio trabalho. Por exemplo, eles podem deixar de fora coisas que são simplesmente muito trabalho para teste, e eles podem não saber os detalhes técnicos que é necessário.

Caramba, você precisa ter mais confiança em seu departamento de QA, ou um melhor. Quero dizer, imagine vocês tinha dito "eu não gosto de ter meus desenvolvedores desenvolver software. Eu não gosto da idéia deles criando seu próprio trabalho."

Como um desenvolvedor, eu sei que há riscos envolvidos em escrever meus próprios testes. Isso não quer dizer que eu não fazer isso (eu faço, especialmente se eu estou fazendo TDD), mas eu não tenho ilusões sobre a cobertura do teste. Os desenvolvedores estão indo para escrever testes que mostram que seu código faz o que acha que ele faz. Não muitos estão indo para testes de escrita que se aplicam ao caso de negócio real na mão.

O teste é uma habilidade, e espero que o seu departamento de QA, ou, pelo menos, os líderes nesse departamento, são bem versados ??em que a habilidade.

Select (não apenas escolher aleatoriamente) um ou dois testadores, e deixá-los escrever os casos de teste. Reveja. Também poderia ser útil se um desenvolvedor que trabalha com uma tarefa olha para os casos de teste para a tarefa. Incentivar testadores para sugerir melhorias e adições para conjuntos de teste - às vezes as pessoas têm medo de corrigir o que o chefe fez. Desta forma, você pode encontrar alguém que é bom em design de teste.

Deixe os testadores saber sobre os detalhes técnicos - Acho que todo mundo em uma equipe ágil deve ter acesso de leitura ao código, e qualquer documentação está disponível. A maioria dos testadores que eu conheço pode ler o código (e escrever), para que eles possam encontrar testes de unidade útil, possivelmente, até mesmo estendê-los. Certifique-se os designers de teste obter respostas úteis dos desenvolvedores, se eles precisam de saber alguma coisa.

A minha sugestão seria a de ter alguém olhar outra pessoa nos casos de teste antes do código é fundido para garantir a qualidade. Concedido, isso pode significar que um desenvolvedor tem vista para o trabalho de outro desenvolvedor, mas que segundo par de olhos pode pegar algo que não foi inicialmente capturado. Os casos de teste iniciais pode ser feito por qualquer desenvolvedor, analista ou gerente, não um testador.

QA não deve escrever os casos de teste, pois podem haver situações em que o resultado esperado não foi definido e por este ponto, pode ser difícil ter alguém árbitro entre QA e desenvolvimento se cada lado pensa que sua interpretação é a o certo. É algo que eu tenho visto muitos times e gostaria que não acontece tão frequentemente como ele faz.

Eu vagamente quebrar meus testes para baixo em testes "Desenvolvedor" e testes de "Cliente", o último dos quais seria "testes de aceitação". Os primeiros são os testes que os desenvolvedores a escrever para verificar se seu código está funcionando corretamente. Quanto mais tarde são testes que alguém outros do que os desenvolvedores a escrever para garantir que o comportamento coincide com o spec. Os desenvolvedores devem não escrever os testes accepatance porque sua criação do software que está testando assume que eles fizeram a coisa certa. Assim, os testes de aceitação são, provavelmente, vai fazer valer o que o desenvolvedor já sabia ser verdade.

Os testes de aceitação deve ser impulsionada pela especificação e se eles são escritos pelo desenvolvedor, eles vão obter conduzido pelo código e, portanto, pelo comportamento atual, não o comportamento desejado.

O Agile canon é que você deve ter (pelo menos) duas camadas de testes: testes de desenvolvimento e testes do cliente.

testes Desenvolvedores são escritos pelas mesmas pessoas que escrevem o código de produção, de preferência usando test driven development . Eles ajudam a chegar com um design bem desacoplado, e garantir que o código está fazendo o que os desenvolvedores acha que está fazendo -. Mesmo depois de uma refatoração

testes Customer especificado pelo proxy do cliente ou cliente. Eles são, na verdade, a especificação do sistema, e deve ser escrito de uma forma que ambos são executável (totalmente automatizada) e compreensível pelas pessoas de negócios. Muitas vezes, as equipes de encontrar formas para que o cliente possa mesmo write -los, com a ajuda de pessoas QA. Isso deve acontecer quando - ou mesmo antes -. A funcionalidade fica desenvolvido

O ideal é que as únicas tarefas para QA para fazer exatamente antes da fusão, está pressionando um botão para executar todos os testes automatizados, e fazer alguma exploratório adicional (= improvisado) testando. Você vai querer executar esses testes novamente após a fusão, também, para se certificar de que a integração das mudanças não quebrar alguma coisa.

Um caso de teste começa primeiro no cartão de história.

A finalidade dos testes é dirigir defeitos para a esquerda (no início do processo de desenvolvimento de software quando eles são mais baratos e mais rápido para correção).

Cada cartão história deve incluir critérios de aceitação. Os pares Product Owner com o analista Solução para definir os critérios de aceitação para cada história. Este critério é usado para determinar se o propósito de um cartão de história foi se encontram.

Os critérios de aceitação de cartões de história vai determinar quais testes de unidade automatizados precisam ser codificadas pelos desenvolvedores como fazem Test Driven Development. Ele também irá conduzir o teste funcional automatizado implementado pelos testadores autoamted (e talvez com suporte ao desenvolvedor se estiver usando ferramentas como o FIT).

Tão importante quanto isso, os critérios de aceitação irá conduzir os testes de desempenho automatizado e pode ser usado quando se analisa o profiling da aplicação pelos desenvolvedores.

Finalmente, o teste de aceitação do usuário será determinado pelos critérios de aceitação nos cartões de história e deve ser projetado pelo parceiro de negócios e ou usuários. Siga este processo e você provavelmente vai liberar com zero defeitos.

Eu raramente ouvido ou visto casos gerentes de projeto de teste de escrita, exceto nas equipes menores. Em qualquer aplicativo de software grande e complexo tem que ter um analista que realmente sabe a aplicação. Eu trabalhava em uma empresa de hipoteca como um PM - era eu para entender empréstimos sub-prime, taxas de juros, e o tal? Talvez em um nível superficial, mas verdadeiros especialistas necessários para certificar-se aquelas coisas funcionavam. Meu trabalho era manter a equipe saudável, proteger os princípios ágeis, e procurar novas oportunidades de trabalho para a minha equipa.

O analista de sistemas devem rever sobre todos os estudos de casos e sua relação correta com os casos de uso. Além disso, o analista deve realizar a UAT final, que poderia basear-se em estudos de casos também. Assim, o analista e a qualidade cara está fazendo tipo de peer-review.

A qualidade está revisando os casos de uso, enquanto ele está construindo estudos de casos, e o analista está revisando os estudos de casos depois que eles são escritos e enquanto ele está realizando UAT.

É claro BA é o especialista de domínio, não do ponto de vista técnico. BA compreende as exigências e os casos de teste deve ser mapeado para os requisitos. Os desenvolvedores não devem ser as pessoas que escrevem os casos de teste para teste contra o seu código. QA pode escrever etapas detalham teste por exigência. Mas a pessoa que escreve a exigência deve ditar o que precisa ser testado. Que realmente escreve os casos de teste, eu não me importo muito, enquanto os casos de teste pode ser rastreada com os requisitos. Eu acho que faz sentido que a BA orienta a direção de testes ou extensão, e QA escreve os planos de teste granular.

Precisamos evoluir a partir do "é assim que tem sido feito ou deve ser feito mentalidade" que está a falhar e falhar continuamente. A melhor maneira de resolver o problema plano de teste / casos escrevendo é que os casos de teste deve ser escrito no doc requisitos em cascata ou a história do usuário na ágil como aqueles Reqs / histórias de usuários estão sendo escritos. Desta forma, não há dúvida que precisa ser testado e QA e UAT equipes podem executar o caso de teste (s) e tempo de foco em testes reais e defeito resolução.

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

Não afiliado a StackOverflow