Testes de aceitação feitos primeiro ... como isso pode ser realizado?

A essência básica da maioria dos métodos Agile é que um recurso não é "concluído" até que seja desenvolvido, testado e, em muitos casos, lançado. Supõe-se que isso aconteça em períodos de tempo rápidos, como "Sprints" no processo Scrum.

Uma parte comum do Agile também é o TDD, que afirma que os testes são feitos primeiro.

Minha equipe trabalha em um programa GUI que faz muitos desenhos específicos e coisas do tipo. Para fornecer testes, a equipe de teste precisa ser capaz de trabalhar com algo que pelo menos tente executar o que está tentando testar. Não encontramos nenhuma maneira de contornar esse problema.

Eu posso ver muito bem de onde eles vêm, porque se eu estivesse tentando escrever um software que visasse uma interface basicamente misteriosa, teria muita dificuldade. Embora tenhamos um comportamento bastante bem especificado, o processo exato de interação com vários elementos da interface do usuário quando se trata de automação parece ser muito exclusivo de um recurso para permitir que os testadores escrevam scripts automatizados para direcionar algo que não existe. Mesmo se pudéssemos, muitas coisas acabaram surgindo mais tarde, como tendo faltado na especificação.

Uma coisa que consideramos fazer foi pedir aos testadores que escrevessem "scripts" de teste que mais se assemelham a um conjunto de etapas que devem ser executadas, conforme descrito da perspectiva de casos de uso, para que possam ser "automatizadas" por um ser humano. Isso pode ser realizado pelo (s) desenvolvedor (es) escrevendo o recurso e / ou verificado por outra pessoa. Quando os testadores mais tarde obtêm uma oportunidade, eles automatizam o "script" principalmente para fins de regressão. Isso não acabou pegando no time.

A parte de teste da equipe está realmente ficando para trás por uma margem considerável. Essa é uma das razões pelas quais o tempo aparentemente extra de desenvolvimento de um "script" para um ser humano executar simplesmente não aconteceu ... eles estão em dificuldades para acompanhar os desenvolvedores. Se esperássemos por eles, não conseguiríamos fazer nada. Na verdade, não é culpa deles, eles são um gargalo, mas estão fazendo o que deveriam e trabalhando o mais rápido possível. O processo em si parece estar contra eles.

Muitas vezes, acabamos tendo que voltar um mês ou mais no que fizemos para corrigir bugs que os testadores finalmente conseguiram verificar. É uma verdade feia sobre a qual gostaria de fazer algo.

Então, o que outras equipes fazem para resolver essa cascata de falhas? Como podemos levar os testadores à nossa frente e como podemos fazê-lo para que haja tempo para eles escreverem testes para os recursos que fazemos em um sprint sem nos fazer sentar e mexer o polegar enquanto isso? No momento, para concluir um recurso, usando definições ágeis, seria fazer com que os desenvolvedores trabalhassem por 1 semana, os testadores trabalhassem na segunda semana e os desenvolvedores esperançosamente capazes de corrigir todos os bugs que surgirem nos últimos dois dias. Isso simplesmente não vai acontecer, mesmo se eu concordasse que era uma solução razoável. Preciso de melhores ideias ...

primeiro, livre-se da divisão entre 'testadores' e 'desenvolvedores'. Todo mundo testa

segundo, no TDD, os desenvolvedores codificam os testes antes de codificar o recurso / matéria

O que você descreveu não é TDD [pode ser o Scrum; Scrum é uma metodologia de gerenciamento de projetos independente da metodologia de desenvolvimento; Scrum não é relevante para o seu problema]

Cenários onde o teste automatizado é impossível são extremamente raros. Cenários em que os testes automatizados são difíceis, caros ou inconvenientes são muito mais comuns - mas são precisamente nesses cenários que os testes automatizados são mais necessários.

Pela descrição vaga, presumo que o software esteja desenhando algo na tela. Se o que está sendo desenhado é determinado por dados, fórmulas ou etapas funcionais, pelo menos escreva testes automatizados que testem no nível dos dados / fórmulas / etapas funcionais. Se a saída da tela for determinística (as mesmas etapas resultam na mesma saída do desenho todas as vezes), teste manualmente uma vez, faça uma captura de tela e permita que testes futuros comparem a saída com a captura de tela verificada. Se a saída da tela for não determinística e não for governada por dados, fórmulas ou etapas funcionais, você estará nessa rara área em que o teste automatizado pode ser impossível. Mas duvido.

Suponho que o único motivo pelo qual o teste não foi automatizado até agora é que os desenvolvedores não se importam com isso . No TDD, os desenvolvedores fazem os testes, para que sintam a dor da repetição chata de testar o mesmo processo de 62 etapas cem vezes até que todos os bugs acabem. Nada fará com que uma solução de teste automatizada seja desenvolvida mais rapidamente do que fazer os desenvolvedores fazerem o teste.

Minhas equipes descobriram que o TDD não era adequado para projetar testes de GUI. Todas as estruturas de teste automatizadas no nível da GUI que usamos exigiram que o código fosse escrito antes do teste. Então, mudamos para o Desenvolvimento orientado ao comportamento . Certamente, os testes não são automatizados, mas nos deram uma maneira de avaliar se a interface do usuário foi "concluída" desde o início.

Achamos ATDD para a GUI difícil / caro.

Geralmente, fazemos o front-end primeiro. Como escrevemos aplicativos da Web, geralmente ele é em HTML / CSS / JS e, em seguida, obtemos aprovação na aparência, no fluxo etc. Isso acabará por ser traduzido em modelos com as partes apropriadas substituídas por bits dinâmicos.

Depois que a maquete da interface do usuário é concluída, escrevemos testes que imitam uma solicitação da web. XPath é usado para afirmar que os dados existem nas tags HTML corretas.

Nós achamos que esse estilo de teste nos dá um bom valor pelo tempo que gastamos. Ainda afirmamos que os dados são retornados e alguma estrutura geral sobre o html. Como já analisamos a aparência de antemão no estágio de maquete, não nos preocupamos em tentar afirmar o posicionamento dos pixels. Apenas olhamos para a página à medida que desenvolvemos tanto como parte do desenvolvimento quanto uma verificação dupla.

Para GUI que não seja desenvolvedor da Web, provavelmente tentaria adicionar alguns ganchos para tornar o front end com script. Provavelmente também maquete a interface do usuário primeiro, mesmo que esteja no papel.

 > Acceptance tests done first…how can this be accomplished?

Prefiro um estilo de desenvolvimento bdd-tdd, conforme descrito neste artigo: Desenvolvimento orientado a comportamento com SpecFlow e WatiN .

O Exemplo usa .net para desenvolvimento com SpecFlow + NUnit + WaitN. Se você está desenvolvendo com (j) ruby ​​/ java, pode experimentar pepino + junit + waitr

Uma coisa que consideramos fazer foi pedir aos testadores que escrevessem "scripts" de teste que mais se assemelham a um conjunto de etapas que devem ser executadas, conforme descrito da perspectiva de casos de uso, para que possam ser "automatizadas" por um ser humano. Isso pode ser realizado pelo (s) desenvolvedor (es) escrevendo o recurso e / ou verificado por outra pessoa. Quando os testadores mais tarde obtêm uma oportunidade, eles automatizam o "script" principalmente para fins de regressão. Isso não acabou pegando no time.

Isso é mais ou menos o que fazemos. Cada recurso é desenvolvido paralelamente ao caso de teste (script) e nenhum recurso é 'concluído' até que as três etapas sejam concluídas: desenvolvimento, caso de teste e teste. Todos os casos de teste são escritos a partir dos requisitos pelos testadores e verificados com os desenvolvedores, para que todos tenhamos um entendimento comum do problema. Como sua sugestão 'a cada duas semanas', exceto que, quando os desenvolvedores estão trabalhando no recurso, os testadores estão trabalhando nos casos de teste e quando os testadores estão testando, os desenvolvedores estão investigando o próximo recurso.

Eu acho que o maior problema que você tem é que

[ele] testando parte da equipe está realmente ficando para trás por uma margem considerável. [...] se esperássemos por eles, não conseguiríamos fazer nada

Como a equipe de teste está muito atrasada, acho que você deve esperar por eles. Tenho certeza de que há algo produtivo que você pode fazer - como desenvolver alguns recursos fáceis de testar, mas que levam muito tempo para serem desenvolvidos. Também pode ajudar a levar em consideração o tempo de teste ao planejar um sprint; nem os desenvolvedores nem os testadores devem estar sobrecarregados ou inativos.

O desenvolvimento orientado a testes de aceitação (distinto, mas complementar ao desenvolvimento orientado a testes) é uma ótima maneira de garantir que você tenha os requisitos definidos antes de começar a codificar.

Na minha equipe, nós (proprietário do produto, analistas de controle de qualidade e desenvolvedores) sentamos juntos e usamos o FitNesse dois testes de aceitação de gravação. Essas sessões geralmente são conduzidas pelo controle de qualidade, mas todos nós participamos. Isso não será executado imediatamente, pois é necessário algum esforço de desenvolvimento para adicionar os equipamentos (a cola entre as páginas da wiki e o código de produção). Esses testes formam os critérios de aceitação de uma história . O FitNesse foi projetado para interagir com a camada abaixo da interface do usuário.

Como desenvolvedores, trabalhamos para fazer esses testes de aceitação passarem. Usamos o TDD para isso, mas o TDD não deve ser confundido com o ATDD.

Quando as páginas do FitNesse ficam verdes, estamos quase terminando, ainda temos algum trabalho a ser feito (testes exploratórios, geralmente liderados por controle de qualidade, e assim por diante).

Talvez escrever testes de interface do usuário codificados possa ajudá-lo. Se você estiver trabalhando com o Visual studio 2010, poderá usar um suplemento chamado "teste da interface do usuário codificada" para gravar e codificar um script muito específico para interagir com a interface do usuário do seu aplicativo. Gravar uma interação em um script introduz um nível extra de abstração que protege você contra pequenas alterações na interface do usuário. No entanto, a introdução dessa forma de teste também apresenta o ônus de manter os testes.