Existe uma maneira correta de implementar um processo de melhoria contínua (endurecimento software AKA)?

Question

Cada versão parece que nossos clientes a encontrar alguns problemas antigos com o nosso software. Ele faz parecer que cada lançamento tem vários erros, quando na realidade o nosso novo código é geralmente sólida.

Temos tentado implementar alguns testes adicionais onde temos testadores fazer várias horas de testes de regressão mensal em um único aplicativo a cada mês, em um esforço para ficar à frente de pequenas questões. Nós nos referimos a este processo como o nosso processo de Software endurecimento, mas não parece que estamos pegando o suficiente dos erros e parece um processo muito backburner desde há sempre novo código para escrever.

Existe um truque para este tipo de teste? Preciso alvo característica um específico de cada vez?

Answer 1

Quando você desenvolver seus procedimentos de teste, você pode querer implementar este tipo de testes:

• teste de unidade (testando componentes invididual do seu projeto para testar a sua funcionalidade), estes testes são importantes porque permitem que você identificar onde no software o erro pode vêm. Basicamente nestes testes que você vai testar uma única funcionalidade e usar objetos mock para simular o comportamento, valor de retorno de outros objetos / entidades.

• testes de regressão, que você mencionou

• testes de caracterização, um exemplo pode ser executado automaticamente o programa de entrada gerado automaticamente (simulando a entrada de utilizador), armazenando os resultados e comparar os resultados de cada versão de encontro a estes resultados.

Ao iniciar este será muito pesado para colocar no lugar, mas com mais lançamentos e sendo adicionados aos testes não-regressão automatizados mais correções de bugs, você deve estar começando a economizar tempo.

É muito importante que você não caia na armadilha de projetar um grande número de testes mudos. O teste deve facilitar a sua vida, se você gastar muito tempo compreensão onde os testes têm quebrado você deve redesenhar os testes como eles dão-lhe melhores mensagens de / compreensão do problema para que você possa localizar o problema rapidamente.

Dependendo do seu ambiente, estes testes podem ser ligados ao processo de desenvolvimento.

No meu ambiente, usamos SVN para controle de versão, um bot executa os testes contra todas as revisões e retorna os testes de falha e mensagens com o nome da revisão que partiu-o e o contribuinte (seu login).

EDIT:

No meu ambiente, usamos uma combinação de C ++ e C # para fornecer análises utilizados em Finanças, o código era C ++ e é bastante antigo, enquanto estamos tentando migrar as interfaces em relação a C # e manter o núcleo das análises em C ++ ( principalmente por causa de requisitos de velocidade)

A maioria do C ++ testes são testes de unidade escritos à mão e testes de regressão.

No # lado do C estamos usando NUnit para testes de unidade. Temos um par de testes gerais.

Temos uma política de avisos 0, nós explicitamente proíbem as pessoas a cometer o código que está gerando avisos a menos que possam justificar por que é útil para ignorar o aviso para esta parte do código. Temos como convenções bem sobre a segurança de exceção, o uso de padrões de design e muitos outros aspectos.

Definir explicitamente convenções e melhores práticas é outra maneira de melhorar a qualidade de seu código.

Answer 2

Existe um truque para este tipo de teste?

Você disse, "temos testadores fazer várias horas de testes de regressão mensal em um único aplicativo a cada mês, em um esforço para ficar à frente de pequenas questões."

Eu acho que por "teste de regressão" quer dizer "exercício manualmente recursos antigos".

Você deve decidir se você está procurando por erros antigos que nunca foram encontrados antes (o que significa, a execução de testes que você nunca são executados antes); ou , se você está repetindo testes anteriormente executados para verificar se a funcionalidade previamente testado é inalterada. Estas são duas coisas opostas.

"teste de regressão" implica para mim que você está fazendo o último.

Se o problema é que "os clientes a encontrar alguns problemas antigos com o nosso software", então quer seus clientes estão executando testes que você nunca são executados antes (caso em que, para encontrar esses problemas que você precisa para executar novo testes de software de idade), ou eles estão encontrando bugs que você Have anterior testado e, mas que você aparentemente nunca fixo depois que você os encontrou.

Preciso característica um específico alvo de cada vez?

O que você está tentando fazer, exatamente:

• Encontre os erros antes que os clientes encontrá-los?
• convencer os clientes de que há pouco errado com o new desenvolvimento?
• Passe tão pouco tempo quanto possível em testes?

conselho muito geral é que os bugs vivem em famílias: assim, quando você encontrar um bug, olhar para os seus pais e irmãos e primos, por exemplo:

• Você pode ter este exatamente o mesmo erro em outros módulos
• Este módulo pode ser buggier do que outros módulos (escrito por somone em um dia de folga, talvez), assim que olhar para qualquer outro tipo de erro neste módulo
• Talvez este é um de uma classe de problemas (problemas de desempenho ou problemas de pouca memória) que sugere toda uma área (ou todo tipo de exigência) que necessita de uma melhor cobertura de teste

Outro conselho é que tem a ver com a gestão de expectativas do cliente: você disse: "Ele faz parecer que cada lançamento tem vários erros, quando na realidade o nosso novo código é geralmente sólida", como se o verdadeiro problema é a percepção equivocada de que o bug é recém-escrita.

ela se sente como um processo muito backburner desde há sempre novo código para escrever

Software develoment não acontece no fundo, em um queimador: ou alguém está trabalhando nisso, ou eles não são. A administração deve decidir se a ninguém atribuir a esta tarefa (ou seja, olhar para os erros anteriormente não encontrados ou-fix anteriormente encontrados-mas-ainda-não-relatada erros existentes), ou se eles preferem concentrar-se no desenvolvimento de novos e deixar o clientes a fazer o de detecção de erro.

---

Editar: Vale a pena mencionar que o teste não é a única maneira de encontrar bugs. Há também:

• informais revisões de projeto (35%)
• inspeções concepção formal (55%)
• informais revisões de código (25%)
• inspeções de código formais (60%)
• mesa de verificação pessoal de código (40%)
• Teste de unidade (30%)
• teste de componentes (30%)
• Teste de integração (35%)
• teste de regressão (25%)
• teste do sistema (40%)
• Baixa teste de volume de beta (<10 locais) (35%)
• teste de alto volume beta (> 1000 locais) (70%)

A porcentagem que eu coloquei ao lado de cada um é uma medida da taxa de defeito de remoção para cada técnica (tomada a partir da página 243 de McConnel do Software Estimativa livro). As duas técnicas mais eficazes parecem ser inspeção de código formal, e os testes beta de alto volume.

Assim, pode ser uma boa idéia para introduzir comentários formais de código:. Que poderia ser melhor na detecção de defeitos do que teste de caixa-preta é

Answer 3

Assim que seus fins de codificação, primeiro você deve ir para o teste de unidade. Lá você vai ter alguns erros que devem ser corrigidos e você deve realizar uma nova rodada de testes de unidade para descobrir se novos bugs vieram ou não. Depois de terminar a unidade de teste que você deve ir para testes funcionais.

Você mencionou aqui que o testador está realizando testes de regressão em uma base mensal e ainda existem erros velhos que saem. Por isso, é melhor sentar-se com o testador e rever os casos de teste como eu sinto que eles precisam ser atualizados regularmente. Também durante a revisão colocar pressão sobre o módulo ou funcionalidade os erros estão chegando. Estresse sobre essas áreas e adicionar mais casos de teste nessas áreas e adicionar aqueles em seus casos de teste rgression modo que uma vez nova compilação vem esses casos de teste deve ser executado.

Você pode tentar mais uma coisa se o seu projeto é um longo prazo, então você deve falar com o testador para automatizar os casos de teste de regressão. Ela irá ajudá-lo a executar os casos de teste em off tempo como noite e no dia seguinte você vai obter os resultados. Também os casos de teste de regressão deve ser atualizado como o principal problema surge quando os casos de teste de regressão não são atualizados regularmente e executando casos de teste de regressão antigos e novos casos de teste progressão que está faltando alguns módulos que não são testados.

Answer 4

Há um monte de falar aqui sobre o teste de unidade e eu não poderia concordar mais. Espero que Josh entende que o teste de unidade é um processo mecanizado. Não concordo com PJ em que os testes de unidade deve ser escrito antes da codificação do aplicativo e não depois. Isso é chamado de TDD ou Test Driven Development.

Algumas pessoas escrevem testes de unidade que exercem o código de camada intermediária, mas negligenciam a testar o código GUI. Isso é imprudente. Você deve escrever testes de unidade para todos os níveis na sua aplicação.

Uma vez que testes de unidade também são código, há a questão de QA para o seu conjunto de testes. É a cobertura de código bom? Existem falsos positivos / negativos erros nos testes de unidade? Você está testando para as coisas certas? Como você garantir a qualidade do seu processo de garantia de qualidade? Basicamente, a resposta para isso se resume a revisão por pares e valores culturais. Todo mundo na equipe tem que estar comprometidos com uma boa higiene teste.

Quanto mais cedo um erro é introduzido no seu sistema, mais tempo ele permanece no sistema, mais difícil e mais caro é para removê-lo. É por isso que você deve olhar para o que é conhecido como integração contínua. Quando configurado corretamente, os meios de integração contínua que o projeto é compilado e executado com o conjunto completo de testes de unidade logo após o check-in suas alterações para o dia.

Se os testes construir ou unidade falhar, então o codificador ofender e o mestre de construção recebe uma notificação. Eles trabalham com o líder da equipe para determinar o que a correção de curso mais adequado deve ser. Às vezes é tão simples como corrigir o problema e verificar a correção. Mestre A construção e as necessidades da equipe de chumbo para se envolver para identificar quaisquer padrões globais que exigem intervenção adicional. Por exemplo, uma crise familiar pode causar qualidade de codificação de um desenvolvedor para a parte inferior. Sem CI e alguns supervisão gerencial, pode demorar seis meses de erros antes de perceber o que está acontecendo e tomar medidas correctivas.

Você não mencionou o seu ambiente de desenvolvimento é. Se o seu caso fosse uma loja J2EE, então eu sugiro que você olhar para o seguinte.

• CruiseControl para integração contínua
• Subversion para controle de versão de código-fonte porque integra bem com CruiseControl
• Spring porque DI torna mais fácil de mecanizar a unidade de ensaio para fins de integração contínua
• JUnit para unidade testar a camada intermediária
• HttpUnit para unidade testar a GUI
• Apache JMeter para teste de estresse

Answer 5

Voltando e implementação de uma estratégia de ensaio para (todo) o material existente é uma dor. É longo, é difícil, e ninguém vai querer fazê-lo. No entanto, eu recomendo fortemente que como um novo bug vem, um teste ser desenvolvida em torno desse bug. Se você não receber um relatório de bug sobre ele, então, ou é (a) obras ou (b) o usuário não se importa que ele não funciona. De qualquer forma, um teste é um desperdício de seu tempo.

Assim que a sua identificada, escrever um teste que vai vermelho . Agora mesmo. Em seguida, corrigir o erro. Confirmar que é fixo. Confirmar que o teste é agora verde . Repita que novos bugs entrar.

Answer 6

Desculpe dizer isso, mas talvez você simplesmente não está testando o suficiente, ou muito tarde, ou ambos.