Hands-On LabTestes de Unidade e Code Clone Analysis com Visual Studio 2012Versão: 11.0.50727.1 (RTM)

Última atualização: 21/08/2012

Tradução: 10/09/2012

ÍNDICE

RESUMO..................................................................................................................................................... 3

EXERCÍCIO 1: TESTE UNITÁRIO..............................................................................................................3

EXERCÍCIO 2: CODE CLONE ANALYSIS...............................................................................................12

Resumo

Neste estudo, você vai aprender como o Teste Unitário está sendo completamente reformulado no Visual Studio 2012. Ao fazer uma série de Testes Unitários em suas extensões, o Visual Studio 2012 vai abrir as portas para três adaptadores de Testes Unitários como o NUnit e o xUnit.net. Você vai aprender, ainda, como a capacidade do novo Code Clone caminha lado a lado com o fornecimento de software de alta qualidade, ajudando a identificar blocos de códigos semanticamente semelhantes que possam ser candidatos a correções de bugs comuns ou de refatoração.

Pré-requisitos

Com o objetivo de concluir este estudo, você vai precisar de uma máquina virtual com o Visual Studio 2012 fornecida pela Microsoft. Para mais informações sobre a aquisição e utilização da máquina virtual, por favor, veja este link.

O caso da Fabrikam Fiber

Esta parte do estudo prático utiliza uma empresa fictícia, a Fabrikam Fiber, como contexto sobre os casos que você está aprendendo. A Fabrikam Fiber fornece Televisão por assinatura e outros serviços relacionados, para os Estados Unidos. Eles estão crescendo rapidamente e adotaram o Windows Azure para implantar seu web site voltado para clientes usuários finais, que lhes permita acompanhar os tickets de autoatendimento e acompanhar os técnicos. Eles utilizam na aplicação local ASP.NET MVC para seus representantes de serviço ao consumidor para administrar os pedidos dos clientes.

Nesta parte do laboratório prático, você vai participar de uma série de cenários que envolvem a equipe de desenvolvimento e teste da Fabrikam Fiber. A equipe, composta por 8 a 10 pessoas, decidiu utilizar as ferramentas do Visual Studio Application Lifecycle Management para gerenciar seu código fonte, executar seus builds, testar seus web sites, planejar e acompanhar o projeto.

Exercícios

Este laboratório prático inclui os seguintes exercícios:

1. Teste Unitário

2. Code Clone Analysis

Tempo estimado para concluir este laboratório: 30 minutos.

Exercício 1: Testes de Unidade

Neste exercício, você vai aprender sobre algumas das melhorias feitas para a unit testing story no Visual Studio 2012, incluindo melhorias no desempenho e extensibilidade.

1. Log in como Julia. Todos os user passwords são P2ssw0rd.

2. Inicie o Visual Studio 2012 a partir do atalho na barra de tarefas ou a partir de Start | All Programs | Microsoft Visual Studio 2012.

Figura 1Iniciando Visual Studio 2012

3. Abra o FabrikamFiber.CallCenter solution a partir de Dev branch no Source Control Explorer.

Figura 1Janela Source Control Explorer

4. Abra a janela Test Explorer a partir do Test | Windows | Test Explorer.

Figure 2Janela do Test Explorer

5. Selecione Build | Build Solution a partir do menu principal para iniciar o processo de descoberta de novos testes de unidade e mudanças no código que possam afetar os testes existentes. Note que os testes encontrados são inicialmente definidos para o estado Not Run.

Figura 3Testes encontrados

6. Selecione todos os testes, exceto o CodedUITestMethod1 (se você selecioná-lo, você terá que rodar um CodedUI Test sem usar o teclado e mouse), clique com botão direito do mouse sobre os testes selecionados e, em seguida, selecione a opção Run Selected Tests.

Figura 4Executando todos os Testes Unitários

Observação: O Visual Studio 2012 também fornece a funcionalidade Continuous Test Runner que pode ser habilitada na opção Test | Test Settings | Run Test After Build. Com esta opção selecionada, os testes sempre serão executados após os builds.

6. Amplie o grupo Passed Tests e dê um clique duplo em passed test com o nome CreateInsertsCustomerAndSaves para abrir o código fonte.

Figura 5Navegar para um test method que usa MSTest

7. No arquivo CustomersControllerTest.cs que se abre, note que o test method utiliza o atributo esperado TestMethod que é usado pelo MSTest para marcar testes unitários.

Figura 6Código de unidade de teste MSTest

8. No campo Search, no topo da janela de Test Explorer, selecione “index” e observe os filtros de pesquisa disponíveis.

Figura 7Pesquisando com Test Explorer

9. Selecione a tecla Enter para fazer a busca.

10. Nos resultados da pesquisa, clique duas vezes no único teste listado com o nome IndexReturnsNonNullView para abrir o código fonte.

Figure 8Navegar para o test method que utiliza XUnit

11. No arquivo HomeControllerTest.cs que abre, você poderá ver que o teste IndexReturnsNonNullView na verdade utiliza o teste XUnit framework. A última adaptação XUnit para o Visual Studio 2012 pode ser encontrada no site Visual Studio gallery em http://aka.ms/UnitTestAdapters.

Figura 9Exemplo de teste XUnit no Visual Studio 2012

12. Selecione o botão X para limpar o campo atual de pesquisa no Test Explorer.

Figura 10Localização do botão X para limpar o campo de pesquisa

13. Observe que os resultados são agrupados por tests passed e failed, com os tempos de execução listados.

Figura 11Resultados do Test run

14. Para a execução de Teste de desempenho foi dada uma atenção especial no Visual Studio 2012. Anote os tempos de execução e, em seguida, selecione o botão Run… seguido pela opção Repeat Last Run. Observe a diferença no tempo de execução.

Figure 12Repetindo o last test run

Nota: Os tempos de execução que você observará poderão ser diferentes daqueles mostrados nas imagens. A primeira vez que você executar os testes de unidade, eles serão executados mais lentamente do que as execuções subsequentes como as de teste e ferramentas de teste que estão sendo carregadas pela primeira vez.

Figura 13Segundo test run sem alterações para os testes é mais rápido.

15. Dê um clique em Failed Tests para ver o resumo dos resultados dos testes.

Figure 14

Selecionando os failed test

Nota: Você também pode clicar com o botão direito do mouse nos tests results e usar o comando Copy para copiar os detalhes para a área de transferência. Isso pode ser útil ao enviar um e-mail, por exemplo.

16. A exibição do resumo de failed test run mostra que uma exceção ArgumentNullException ocorreu durante a execução e ainda fornece a stack track no momento da exceção. Observe que podemos seguir os links para ir diretamente ao código fonte para o teste ou para os pontos dentro do stack trace. Selecione o source link para ir para o código fonte para o test method.

Figura 15Navegando para a fonte do test method

Figura 16Exibição inicial após navegar para a fonte do test method

17. Encontre a linha de código que está comentada e tire o comentário. Suponha que essa é a causa principal para a falha do teste.

Figura 17Corrigindo a raiz do problema da falha do teste

18. Aperte Ctrl+S para salvar suas alterações.

19. Clique com o botão direito do mouse sobre failed test no Test Explorer e selecione Run Selected Tests para se certificar-se de que o problema foi corrigido.

Figura 18Executando os failed test novamente para validar a correção

20. Feche a janela Test Explorer.

Exercício 2: Code Clone Analysis

Neste exercício, você vai aprender sobre o novo recurso do Code Clone Analysis no Visual Studio 2012. Essa ferramenta procura por um código semanticamente semelhante, usando uma técnica de busca heurística, ao invés de simplesmente procurar por correspondências exatas.

1. Selecione Analyze | Analyze Solution for Code Clones a partir do menu principal no Visual Studio.

Figura 19Analyze solution for code clones

2. Quando a análise estiver concluída, a janela Code Clone Analysis Results irá mostrar candidatos de clone agrupados por fortes combinações. Expanda o grupo Strong Match para expor os dois arquivos que possuem fortes combinações.

Figura 20Visualizando os strong file matches

3. Cada linha mostra a classe e o método, arquivos específicos, e linhas que foram determinadas como fortes combinações. Se você passar o mouse por cima de cada combinação, um trecho de código poderá ser visto rapidamente para parte das combinações dos códigos.

Figura 21Passe o mouse sobre os resultados para ver os detalhes

4. Dê um clique duplo em cada combinação para abri-los na janela code editor, e então clique com o botão direito na aba título para um deles e selecione New Horizontal Tab Group a partir do menu de contexto.

Figura 22Abrindo os dois arquivos para comparação

5. Percorra o código para o método AssignSchedule para cada arquivo, simultaneamente, e observe que é idêntico, exceto para a última linha, que chama o método RedirectToAction. Isto indica que este método é um bom candidato para o refatoramento. Este tipo amplo de pesquisa

é particularmente útil quando se olha para o código que pode ser refatorado para facilitar a manutenção no futuro.

Figura 23Comparando a forte combinação a partir do code clone analysis

6. Selecione Window | Close All Documents a partir do menu principal para renovar nossa área de visualização do Visual Studio.

7. Você também pode restringir o foco de busca para code clones se desejar. No Solution Explorer, navegue para a pasta Controllers do projeto da FabrikamFiber.Web e abra CustomersController.cs no editor de código.

Figura 24Abrindo o CustomersController.cs source file

8. Desloque-se para o método Create que leva ao parâmetro Customer e selecione as três linhas de código dentro da primeira expressão “if”.

Figura 25Selecionando código para o code clone analysis

9. Clique com o botão direito nas linhas de código selecionadas e então selecione a opção Find Matching Clones in Solution a partir do menu de contexto.

Figura 26Encontrando matching clones para o código selecionado

10. Após a conclusão da pesquisa, a janela Code Clone Search Results mostrará trechos de combinação de intensidade variável .

Figura 27Resultados da pesquisa de code clone

11. Expanda todos os clone groups para expor as combinações descobertas, incluindo o clone group original. Você pode querer aumentar o tamanho da janela do Code Clone Search Results, de modo que você possa ver todas as combinações em de uma vez.

Figura 28Resultados de Code clone com os grupos expandidos

12. Mantenha o cursor do mouse sobre o trecho de código original para se lembrar quais code clones estão sendo comparados.

Figura 29Trecho original de código

13. Mantenha o cursor do mouse sobre o resultado Exact Match e observe que o método Edit utiliza exatamente o mesmo código que o código a partir do método Create.

14. Mantenha o cursor do mouse sobre o resultado Strong Match e observe que a única diferença é que a primeira linha é uma chamada para o método Delete.

Figura 30Trecho de código do resultado para o original strong match

15. Mantenha o cursor do mouse sobre o primeiro resultado Medium Match e observe que o trecho é similar ao original, mas agora nós estamos trabalhando com um objeto inteiramente diferente (agora employeeRepository).

Figura 31Trecho de código do resultado para o original strong match

16. Em resumo, existem três cenários principais onde a identificação dos code clones pode ser útil para os desenvolvedores:

a. Identificação de candidatos para refatoramento do código.

b. Correção de bugs ou melhorias feitas no código e o desenvolvedor deseja ver se há outros locais semelhantes que devem ser atualizados.

c. Como uma ferramenta de aprendizagem para um novo desenvolvedor que está começando um trabalho em uma nova equipe de projeto, por exemplo, o desenvolvedor adiciona um código para atualizar um registro de cliente e quer ver se há práticas usadas pelo resto do código base, tais como a utilização de um bloco Try...Catch.