Partilhar via

Dia na vida de um desenvolvedor devops: suspenda o trabalho, corrija um bug e conduza uma revisão de código

  • Artigo

Serviços de DevOps do Azure | Azure DevOps Server 2022 - Azure DevOps Server 2019

Visual Studio 2019 | Visual Studio 2022

Os recursos do Visual Studio My Work e Code Review oferecem suporte à alternância de contexto de um thread de trabalho para outro. Além disso, os membros da equipe podem facilmente trocar mensagens sobre alterações propostas no código. Este artigo ilustra esses recursos, continuando o tutorial de Day in the life of a devops developer: Write new code for a user story.

Nota

Os recursos Visual Studio My Work e Code Review estão disponíveis com as seguintes edições:

  • Visual Studio 2022: Comunidade do Visual Studio, Visual Studio Professional e Visual Studio Enterprise
  • Visual Studio 2019: Visual Studio Professional e Visual Studio Enterprise

Este tutorial descreve como você pode suspender o trabalho em uma tarefa atual para corrigir imediatamente um bug que está bloqueando colegas de equipe em outro item de trabalho. Depois de corrigir o bug, você pode pedir aos colegas que revisem a correção e, depois que a revisão for aprovada, verifique a correção e retome o trabalho na tarefa original.

Suspender o trabalho atual

Enquanto você está trabalhando em um item de lista de pendências, você pode descobrir sobre um bug em outro item que está bloqueando colegas de equipe. Se for uma área com a qual você está familiarizado, você pode criar uma tarefa para corrigir o bug e atribuí-la a si mesmo para trabalhar imediatamente.

Antes de começar a trabalhar no novo bug, você quer ter certeza de que seu trabalho atual é reservado em um lugar seguro no servidor da equipe. No Visual Studio Team Explorer, na página Meu Trabalho , escolha Suspender para salvar no servidor:

  • Todo o trabalho que você fez, incluindo alterações no código, testes e outros arquivos.

  • Abra soluções, janelas, pontos de interrupção, variáveis de janela de observação e outros bits do estado do Visual Studio.

Agora que seu espaço de trabalho está limpo, arraste a nova tarefa de Itens de Trabalho Disponíveis para Trabalho em Andamento. Você está pronto para pesquisar e escrever a correção.

Nota

Seu contexto de trabalho está vinculado aos itens de trabalho que são mostrados como Em andamento na página Meu trabalho . Usando Suspender e Retomar, você pode alternar rapidamente entre diferentes tarefas. Suas soluções e arquivos abertos, alterações de código e layout do Visual Studio são alternados juntos.

Para suspender o trabalho atual e começar a trabalhar em uma tarefa diferente

Mude o seu contexto de trabalho:

  1. Se você ainda não estiver conectado ao projeto no qual deseja trabalhar, conecte-se ao projeto.

  2. Na página inicial do Team Explorer, escolha Meu trabalho.

  3. Na página Meu Trabalho, na seção Trabalho em Andamento, escolha Suspender.

  4. Na caixa apresentada, altere opcionalmente o nome que pretende atribuir a este conjunto de trabalhos suspensos e, em seguida, selecione Suspender. O item aparece em Trabalho Suspenso.

    Captura de ecrã a mostrar a suspensão de algum trabalho.

  5. Arraste um item de trabalho de Itens de Trabalho Disponíveis para Trabalho em Andamento. Ou, você pode alternar para um item de trabalho que você suspendeu anteriormente arrastando-o de Trabalho Suspenso.

    Se o item de trabalho que você deseja atribuir a si mesmo não aparecer em Itens de Trabalho Disponíveis, você poderá:

    • Crie uma nova tarefa ou outro item de trabalho escolhendo Novo.
    • Selecione uma consulta diferente selecionando Abrir consulta.

Gorjeta

Os itens de trabalho em andamento vinculam às alterações de código atuais e ao estado do Visual Studio. Para permitir que o Visual Studio o ajude a organizar seu trabalho, certifique-se de que os itens apropriados estejam no estado Trabalho em Andamento quando você alternar de uma tarefa para outra.

Investigue o bug

Abra o novo bug e leia a descrição. Neste exemplo, a descrição por um membro da equipe de teste afirma que uma fatura paga às vezes é sinalizada incorretamente como não paga. Um instantâneo do ambiente de laboratório é anexado ao item de trabalho do bug. Abra a máquina virtual (VM) na qual o teste foi executado, veja a fatura incorreta e volte atrás no log do IntelliTrace. Você pode rastrear a falha para o seguinte método:

public class LocalMath
{
    public static bool EqualTo(double a, double b)
    {
        return a == b;
    }

No log do IntelliTrace, você vê que, às vezes, o método retorna false porque os parâmetros diferem em uma quantidade extremamente pequena. Você sabe que erros de arredondamento desse tipo são inevitáveis na aritmética de ponto flutuante, e que é uma má prática testar números de ponto flutuante para igualdade.

Aumente os testes para mostrar o erro

Quando um bug é encontrado, ele mostra que houve uma lacuna nos testes de unidade, ou que o teste não correspondeu às necessidades reais dos usuários. Portanto, antes de corrigir o bug, adicione um teste que demonstre a presença desse erro:

// Added 2022-02-02 for bug 654321:
/// <summary>
/// Make sure that number equality test allows for 
/// small rounding errors.
/// </summary>
[TestMethod]
public void TestDoublesEqual()
{
    // Allow a rounding error of 1 in 1000000:
    TestEqual(1, 1e-7, true); // Less than allowed error
    TestEqual(1, 1e-5, false); // More than allowed error
    TestEqual(1000, 1e-7, true); // Less than allowed error
    TestEqual(1000, 1e-5, false); // More than allowed error
}
private void TestEqual(double value, double error, bool result)
{
    // Try different combinations of error and value:
    Assert.IsTrue(result == LocalMath.EqualTo(value + error, value));
    Assert.IsTrue(result == LocalMath.EqualTo(value, value + error));
    Assert.IsTrue(result == LocalMath.EqualTo(value - error, value));
    Assert.IsTrue(result == LocalMath.EqualTo(value, value - error));
}

Execute o teste e ele falha conforme o esperado.

Captura de tela do Unit Test Explorer mostrando o teste reprovado para igual.

Faça com que os testes sejam aprovados

Corrija o código:

public static bool EqualTo(double a, double b)
{
    // Allow for rounding errors.
    // For example, a == 2.0 and b = 1.99999999999

    const double allowedError = 1/1000000;
    return System.Math.Abs(a - b) < allowedError;
}

O teste agora passa:

Captura de tela do Unit Test Explorer mostrando o teste aprovado para igual.

Solicite uma revisão de código

Quando estiver satisfeito com a correção do bug, não faça check-in do seu trabalho ainda. As equipes usam revisões de código para aumentar a qualidade geral do código e reduzir o risco de criar mais bugs. Use o Team Explorer para solicitar revisões de código de colegas de equipe.

Para solicitar uma revisão de código

  1. No Team Explorer, na página Meu Trabalho em Trabalho em Andamento, escolha Solicitar Revisão.

    A página New Code Review (Nova revisão de código) é exibida.

    Captura de tela que mostra a página Solicitar revisão de código.

    • No campo Digite o nome de um revisor, especifique um ou mais revisores e pressione Enter após cada seleção.
    • No campo seguinte, altere o nome da avaliação, se desejar.
    • No campo seguinte, verifique se o caminho da área correta aparece.
    • No campo seguinte, digite uma descrição opcional.

  2. Escolha Enviar solicitação.

Os revisores são notificados do pedido por e-mail.

Você também pode solicitar uma revisão de código do trabalho suspenso, um conjunto de prateleiras ou um conjunto de alterações. Para ver uma lista de conjuntos de alterações, abra o Gerenciador de Controle do Código-Fonte e escolha o botão Histórico .

Fazer uma revisão de código

Um revisor pode aceitar a solicitação de revisão de código. O revisor revisa o código, escreve alguns comentários nos níveis de arquivo e bloco de código e, em seguida, envia a revisão de código de volta para você. Um revisor solicitado que esteja muito ocupado para revisar o código pode recusar a avaliação.

Nos comentários, o revisor aponta que o teste está errado. O erro admissível deve ser uma fração especificada dos valores de entrada, não uma quantidade constante. Assim, o teste deve multiplicar o erro pelo valor.

// We allow a rounding error of 1 in 1000000
// as a fraction of the value:
TestEqual(1, 1e-7, true); // Less than allowed error
TestEqual(1, 1e-5, false); // More than allowed error
TestEqual(1000, 1000*1e-7, true); // Less than allowed error
TestEqual(1000, 1000*1e-5, false); // More than allowed error

Gorjeta

Os membros da equipe usam os testes como foco de discussão. Se os testes forem corretos e suficientes, o código também será. Ao contrário do código, cada teste representa um caso separado. Por esta razão, os testes são muitas vezes mais fáceis de discutir do que o código.

Para fazer uma revisão de código

  1. Na página Meu Trabalho no Team Explorer, clique com o botão direito do mouse na revisão de código na seção Revisões de código e selecione Abrir.

    A página Revisão de código é exibida.

    Captura de ecrã da página Revisão de Código.

  2. Na página Revisão de código, você pode:

    • Escolha Adicionar revisor para adicionar outros revisores à solicitação de revisão de código.

    • Selecione cada link de arquivo para ver as alterações nos arquivos que foram atualizados para este item de trabalho.

    • Use Comentários para discutir as alterações com o autor e outros revisores.

      Para adicionar comentários:

      • Escolha Adicionar comentário geral para adicionar um comentário geral à avaliação.
      • Ao visualizar um arquivo, selecione uma linha ou bloco de código, clique com o botão direito do mouse e selecione Adicionar comentário.

      Depois de adicionar cada comentário, selecione Salvar ou pressione Ctrl+Enter.

  3. Quando terminar de inserir comentários, selecione Enviar comentários para tornar suas contribuições visíveis para o autor e outros revisores.

Responder a uma revisão de código

Você recebe e responde à revisão de código dos revisores. Você e os revisores podem trocar comentários quantas vezes quiserem. A avaliação termina quando você a fecha.

Para responder a uma revisão de código

  1. No Team Explorer, na página Meu Trabalho , vá para a seção Revisões de Código e clique duas vezes na solicitação ou clique com o botão direito do mouse na solicitação e escolha Abrir.

    A página Revisão de código é exibida.

    Captura de tela mostrando como responder a uma revisão de código.

  2. Na seção Comentários, leia os comentários e responda-os conforme necessário. Para responder a um comentário, escolha Responder, insira seu comentário na caixa exibida e escolha OK.

  3. Para exibir um arquivo e ver os blocos de código que têm comentários, ou para editar ou comentar em um arquivo, vá para a subseção Arquivos . Clique com o botão direito do mouse no arquivo e escolha:

    • Comparar (somente leitura)
    • Editar arquivo local ou
    • Adicionar comentário de arquivo

    Você também pode marcar a caixa de seleção ao lado de um comentário para indicar que o comentário foi endereçado.

  4. Para enviar seus comentários, escolha Enviar comentários.

  5. Quando você e os outros revisores terminarem de responder aos comentários um do outro e estiverem prontos para fechar a avaliação, selecione Fechar revisão e, em seguida, selecione:

    • Preencher para indicar que a revisão foi concluída, ou
    • Abandone para indicar que está cancelando a avaliação.

Corrigir o teste e o código

Depois de ler os comentários da revisão, você pode corrigir seu teste de unidade conforme sugerido. O teste agora falha. Isso mostra que o código ainda não está correto.

Você corrige o código:

/// <summary>
/// Returns true if two numbers are equal.
/// </summary>
public static bool EqualTo(double a, double b)
{
    // Allow for rounding errors.
    const double allowedErrorMultiple = 1/1000000;
    double allowedError = (System.Math.Abs(a) + System.Math.Abs(b)) * allowedErrorMultiple/2;
    return System.Math.Abs(a - b) < allowedError;
}

O teste passa mais uma vez.

Gorjeta

Para corrigir um bug, siga a mesma prática do desenvolvimento de código. Escreva um teste que falhar e, em seguida, faça o teste passar. Verifique o código e os testes apenas quando os testes forem aprovados.

Agora você volta sua atenção para o caso de teste em que o bug foi descoberto. As etapas para reproduzir o bug são claramente descritas no item de trabalho do caso de teste. Você segue as etapas e descobre que as faturas estão listadas corretamente.

Verifique a correção

Você verifica o código fixo e os testes de unidade. O estado do bug é automaticamente definido como Resolvido e o valor Atribuído a é automaticamente reatribuído ao membro da equipe de teste que descobriu o bug. Esse membro da equipe verificará se o bug foi corrigido e fechará o item de trabalho.

Para fazer check-in da correção

  1. No Team Explorer, na página Meu Trabalho , escolha Check-in para abrir a página Alterações Pendentes .

    Captura de tela de Fazendo check-in de uma atualização para corrigir um bug.

  2. Na página Alterações Pendentes, certifique-se de que:

    • Todas as alterações relevantes estão listadas em Alterações incluídas

    • Todos os itens de trabalho relevantes estão listados em Itens de Trabalho Relacionados.

  3. Insira um comentário para ajudar sua equipe a entender o objetivo dessas alterações quando examinar o histórico de controle de versão dos arquivos e pastas alterados.

  4. Selecione Check-in.

Retomar o trabalho numa tarefa

Retome o trabalho na sua tarefa original. Você pode voltar ao trabalho rapidamente porque todas as alterações de código são restauradas no espaço de trabalho, juntamente com bits importantes de estado, como janelas abertas, pontos de interrupção e variáveis de janela de observação.

Para retomar o trabalho em uma tarefa

  • No Team Explorer, na página Meu Trabalho , selecione seu item de trabalho original em Trabalho Suspenso e selecione Retomar.

    Captura de ecrã de Retomar uma tarefa.

    Ou, se quiser mesclar o trabalho suspenso com as alterações pendentes no espaço de trabalho, escolha Mesclar com em andamento.

Quando você retoma seu trabalho, o Visual Studio restaura:

  • A sua solução aberta
  • Suas alterações de código
  • O estado e a posição das janelas abertas
  • Pontos de interrupção
  • Variáveis e expressões da janela de observação
  • Marcadores