Etapas para manter um bom banco de dados de bugs

Manter o banco de dados de bugs é importante para todos os projetos. Estou acostumado a armazenar os seguintes itens no banco de dados de bugs

• Data e hora da edição
• A quem está atribuído
• Se foi resolvido ou não
• Se resolvido, então, resolvido data e hora

Isso é suficiente para manter um bom banco de dados de bugs?

Um bom banco de dados de erros pode ter os seguintes

// Data e hora relacionadas

• Data e hora do bug
• Data prevista para correção / resolução
• Se resolvido, então, resolvido data e hora

// Atribuído por + a

• Atribuído por (detectado por)
• Atribuído a

// comportamento do bug

• Comportamento (buggy) observado
• Captura de tela (é possível)
• Etapas completas para reproduzir o bug
• Comportamento esperado

// Prioridade

• Prioridade do bug

// Link, status e outros

• Link de bugs relacionados
• Status do bug
• Se foi resolvido ou não
• Se resolvido, então, como resolvido com explicação

EDIT: Eu também quero recomendar

• Em que revisão / ramificação o bug foi descoberto
• Em que revisão / ramificação o bug foi corrigido

EDIT: Gosto do comentário de @ jgauffin

• Não vai corrigir, Não é um bug, Duplicar, Resolvido

EDIT: Um bom sistema de banco de dados de bugs também mantém

• Matriz de atribuição de responsabilidade

Pode haver vários campos personalizados que você pode precisar registrar, dependendo das necessidades do projeto. Eu vim com a seguinte lista que você pode precisar considerar também:

• Emissão DateTimede Bug / Defeito
• Descrição do bug - etapas para recriar.
• Ambiente onde foi encontrado (Dev, QA, QC, Staging, Prod)
• Captura de tela da questão
• Quem o registrou (detectado por)
• A quem é atribuído (atribuído por)
• Gravidade do erro (baixo, médio, alto)
• Resolução esperada DateTime
• Triagem de Estado (Proposta, Em Andamento, Resolvido, Fechado)
• Bug is Closed DateTime- quando um bug é resolvido e fechado
• Designado para ser testado (testado por)

Edit: A maioria das informações comuns que têm valor a ser rastreado são bem descritas em softwares como o Bugzilla . O Bugzilla é uma ferramenta de teste e rastreador de uso geral baseada na Web, originalmente desenvolvida e usada pelo projeto Mozilla, e licenciada sob a Licença Pública Mozilla - e é GRATUITA . Eu recomendaria fortemente tomá-los como exemplo principal e estendê-lo às necessidades do seu projeto.

A maioria dos campos úteis parece já ter sido coberta por outras respostas, mas algumas que acho úteis são:

• Em que revisão / ramificação o bug foi descoberto.
• Em que revisão / ramificação foi corrigida.

Isso é um pouco mais específico do que em que data / hora o bug foi descoberto / corrigido.

Se o seu software for executado em várias plataformas (SO ou hardware), você também pode querer um campo que liste as plataformas em que o erro ocorre.

Mas há mais para manter um banco de dados de bugs do que quais campos ele deve conter. Você também precisa considerar como você usa a base.

Tente manter o número de bugs abertos / não resolvidos o mais baixo possível. Isso pode parecer óbvio, mas pode ser mais difícil do que o esperado, pelo menos para projetos maiores. Muitas vezes vejo pessoas com medo de fechar problemas que não são reproduzíveis ou onde a falta de informações nunca é fornecida pelo remetente original do problema. Além disso, os bugs que existem há muito tempo e foram vistos pela última vez em versões antigas do software não devem ser deixados por aí. Isso faz com que o banco de dados cresça com problemas que podem ou não ser reais e diminui o desenvolvimento.

Você muitas vezes precisa ver o histórico de um bug _ ele pode ser resolvido, reaberto e depois resolvido novamente etc. Portanto, além do que já foi sugerido, aconselho que você tenha uma tabela separada para acompanhar da história de um bug cada vez que é (re) aberto. A tabela estaria em um relacionamento muitos-para-um com a tabela de erros e provavelmente teria campos como:

• Data de abertura
• Aberto por
• Data da resolução
• Resolvido por
• Tempo gasto
• Como foi resolvido
• etc.

Você também pode precisar de uma tabela semelhante para rastrear a quem e quando o bug foi (re) atribuído, especialmente se você trabalha em uma grande equipe.

Eu também sugiro que você dê uma olhada nos sistemas existentes. IMHO Jira é um dos melhores sistemas de rastreamento de problemas. Possui recursos muito avançados e você pode usar alguns deles como um guia para o seu próprio sistema.

O processo de rastreamento de bugs é tão importante quanto os dados. Tente pensar também no seguinte:

• Como os usuários relatam o bug?
• Quem entra no bug no repositório?
• Quem pode confirmar que o bug existe?
• Quem pode confirmar que o bug foi resolvido?
• Quem informa ao usuário final que o bug foi resolvido?

Crie um gráfico RACI para que todos na sua equipe (incluindo os usuários finais saibam suas responsabilidades. Combine isso com técnicas apropriadas de entrada de dados e você terá muito mais valor com o pequeno esforço extra.