O que fazer com problemas abandonados no GitHub?

Se alguém abrir um problema no GitHub, mas mais informações para reproduzir o erro forem solicitadas e nunca fornecidas, qual é o procedimento normal? Exemplo .

Aqui o autor afirma que o "nav quebra". Embora eu acredite que seja consertado, gostaria que as palavras do autor garantissem que estávamos falando da mesma coisa. Mas às vezes o repórter da questão simplesmente desaparece. É uma boa prática comum definir uma data de validade para problemas abandonados?

Algo como estas condições:

• Uma questão é levantada sobre o problema para poder depurá-lo.
• Mais de 2 a 6 meses se passaram desde a última pergunta / resposta não respondida da equipe de desenvolvimento.
• O bug não pode ser reproduzido no momento do fechamento (por qualquer motivo, talvez eles nunca possam ser reproduzidos).
• Um aviso é emitido 2 semanas antes de fechá-lo.

O que os projetos normalmente fazem? Não encontrei nada no Google. Além disso, como eu documentaria isso? Uma simples observação no README.md detalhando os pontos acima e um comentário no problema explicando por que está sendo fechado são suficientes?

Nota: é diferente desta pergunta, pois o bug ainda pode ser relevante (ou não), no entanto, há falta de informações.

Este é um dilema: você não pode fechar o problema como "corrigido", porque na verdade você não sabe se foi corrigido ou, pelo menos, mesmo que algum problema tenha sido corrigido, você não sabe se esse foi o problema do repórter. estava falando. Por outro lado, você não deseja deixar um problema que possa ter sido corrigido em aberto, especialmente se você nunca conseguirá fechá-lo porque nunca receberá confirmação.

Portanto, você deve fechá-lo, mas provavelmente não como "fixo". Você pode inventar um motivo de fechamento personalizado "pode ​​ter o código fixo" ou "correção não confirmada" se quiser ser positivo ou "repórter" se não quiser. Você também pode dizer "não foi possível reproduzir" e aguardar o mesmo bug aparecer para um repórter mais responsivo.

No entanto, você não deve gastar recursos com um bug para o qual nunca saberá se ele foi realmente corrigido ou não.

Sua pergunta principal já foi respondida, mas você também perguntou sobre a documentação do processo e isso também precisa ser respondido.

A solução que eu já vi em muitos projetos não é colocá-lo no arquivo README.md, mas em uma contribuição especial README - um arquivo README para colaboradores. Este arquivo descreve tudo o que você deseja que as pessoas que contribuem para o seu projeto saibam - sobre o código (convenções de nomenclatura, organização do módulo etc.) ou sobre o processo (como escrever confirmações, como manipular tickets etc.). Esse arquivo pode ser outro .MDarquivo no projeto ou ser colocado em um repositório totalmente diferente (para que possa ser compartilhado entre todos os seus projetos). Só não se esqueça de vincular a ele a partir do principal README.md!

O ponto de separar essas informações do README principal é que geralmente apenas uma fração do usuário do projeto contribui diretamente para elas. A maioria dos usuários não precisa se entediar com essas informações - elas apenas precisam saber o que o seu projeto faz e como usá-lo, e é isso que o README principal deve conter. No caso do seu projeto, a seção de contribuição é muito pequena, portanto não sobrecarrega o README principal - mas se você documentar todos os fluxos de trabalho que deseja que os colaboradores sigam, não caberá mais lá ...

Observe que qualquer usuário pode abrir um bug; portanto, se você tiver requisitos especiais sobre a abertura de bug, deve colocá-lo no README principal (tente mantê-lo no lugar - ao contrário dos contribuidores de código, os repórteres de bugs provavelmente estarão menos dispostos a fazer grandes esforços estudar e estar em conformidade com suas regras). No entanto, a pessoa que realmente corrige o erro e fecha o ticket (seja você ou um dos colaboradores que você confirmou) é um colaborador direto e pode-se esperar que leia a contribuição README - portanto, o processo de fechamento de tickets quando o repórter o faz não responder deve ser descrito lá.

Eu li isso como mais uma pergunta sobre as práticas sobre como lidar com um bug não verificado (usando o rastreador de problemas do github) do que qualquer outra coisa.

Para mim, essa é uma resposta bastante direta com base em outros rastreadores de problemas que eu usei. O Github não força ninguém a usar nenhum fluxo de trabalho e isso o torna muito flexível ... e bastante inútil em sua configuração padrão.

Observando o fluxo de trabalho padrão do Bugzilla, obtemos:

Vou apontar uma coisa muito importante lá - ela é resolvida como corrigida antes de ser fechada após ser verificada . O fluxo de trabalho básico do Github mostra apenas os estados vermelho (aberto) e verde (fechado).

Portanto, uma abordagem é usar os rótulos no Github ( rótulos do seu aplicativo ) para tentar mostrar as informações adicionais. Você pode criar um par de rótulos 'não verificados' e 'verificados' para serem aplicados depois que você fechar o problema. Observe que essa é apenas uma abordagem - se você pesquisar, poderá encontrar dezenas de abordagens diferentes para o uso de rótulos. Aqui, a pergunta Como gerenciar problemas do github para (prioridade, etc)? aborda isso.

Você o corrigiu, do ponto de vista de um desenvolvedor, isso é feito. Feche o problema no Github. Aplique o rótulo 'não verificado' a ele. Quando alguém familiarizado com o bug na versão anterior disser "sim, isso foi corrigido", você poderá alterar o rótulo para 'verificado'. Se eles disserem que não, você reabrirá.

Observe também que existem outros estados resolvidos além de 'fixo'. Há 'wontfix' (a correção é algo que simplesmente não pode ser feito com a estrutura atual) e 'worksforme' (o bug não pode ser reproduzido) e 'inválido' (você está registrando um bug sobre o sistema operacional, não as coisas do tipo de aplicativo).

Eu adotaria uma de duas visões, dependendo da confiança que estava falando sobre a mesma coisa que o repórter original:

1) Como o repórter não está mais disponível, considere que o erro em questão significa o que você corrigiu. Se ajudar, anexe os casos de teste para esclarecer quais falhas você encontrou. Descreva em detalhes no relatório de bug o que você corrigiu e deixe uma observação como "Acredito que isso é o que significa 'quebra de nav' ', reabra ou crie um novo bug, se não foi isso que você quis dizer". Marque o bug como corrigido.

2) Como o repórter não está mais disponível, considere que o bug não pode ser (conhecido por) reproduzido, pois apenas a palavra do repórter confirmaria que é a mesma coisa que eles relataram. Crie um novo bug para descrever a coisa que você corrigiu; para fins de crédito, mencione que foi observado nas condições descritas pelo relator ausente, observe que ambos podem ser duplicados, marque o novo bug corrigido e marque este inválido ou não pode ser reproduzido com uma nota como "Não consigo entender o que você quis dizer com 'quebra de nav' ', mas resolvi o problema que encontrei. Reabra ou abra um novo bug se o nav ainda quebrar, descrevendo em mais detalhes do que está errado ".

Quanto à escala de tempo, acho que deve depender do projeto. Se você for muito responsivo e estiver lidando com esse bug poucos dias após o seu surgimento, as pessoas devem entender que você não esperará semanas por uma resposta antes de resolver o problema. Por outro lado, se estiver na sua pilha de lixo por meses, ele poderá ficar aberto por mais um mês ou dois sem causar nenhum problema.

Por esse motivo, não acho que exista um limite de tempo específico que constitua "boas práticas" ou que você precise publicar sua política e cumpri-la. Certamente você não gostaria de registrar que o repórter não pode ser contatado até que você faça um esforço para contatá-los. Mas também não vejo sentido em deixar vários avisos com contagem regressiva até o prazo: eles revisam o bug e querem dizer alguma coisa, ou não.