Visual Studio 2017 acaba de ser lançado oficialmente. Ele vem com muitas coisas novas e excelentes, mas um dos meus novos recursos favoritos é o Visual Studio Live Unit Testing integrado (disponível no Visual Studio 2017 Enterprise, ainda não disponível para projetos .NET Core).
Nesta postagem, mostrarei como o Visual Studio Live Unit Testing funciona, bem como algumas considerações sobre o uso de testes unitários em comparação com o uso de testes de vídeo. testes de integração. Você pode acompanhar o processo obtendo o código-fonte completo para isso Exemplo de teste de unidade ao vivo no GitHub.
Teste de unidade do Visual Studio Live com o NUnit
O NUnit é talvez a ferramenta de teste mais popular para desenvolvedores C#/.NET. O Visual Studio Live Unit Testing também pode funcionar com o xUnit e o MSTest, mas, nesta postagem, abordarei apenas o NUnit.
Para usar o NUnit, você o adiciona com o NuGet, como de costume. Para usar o Visual Studio Live Testing, você também precisará adicionar o pacote Adaptador de teste NUnit (Instalar o pacote NUnite3TestAdapter).
Em seguida, inicie o teste ao vivo clicando em Test → Live Unit Testing → Start.
Escrevendo um teste de unidade
Precisaremos de alguns testes unitários para demonstrar. Poderíamos simplesmente fazer Assert.That(1, Is.EqualTo(1))mas qual é a graça disso? Vamos criar uma classe de carrinho de compras.
|
1 2 3 4 5 6 7 8 9 10 |
public class ShoppingCart { public string UserName { get; set; } public DateTime LastUpdated { get; set; } public List<Item> Items { get; set; } public decimal Total { get { return Items.Sum(i => i.Price); } } } |
Esse carrinho de compras tem algumas propriedades e uma coleção de itens. Observe o Total propriedade. Os leitores mais atentos já devem ter percebido alguns problemas com ela, mas vamos começar com um teste unitário único e simples para garantir que ela calcule um total.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
[Test] public void ShoppingCart_Total_Should_Sum_Up_the_Item_Prices() { // arrange: create shopping cart with 2 items and figure out the expected total var item1 = new Item { Name = "Large Pepperoni Pizza", Price = 14.99M }; var item2 = new Item { Name = "Cheese Sticks", Price = 4.99M }; var expectedTotal = item1.Price + item2.Price; var cart = new ShoppingCart { Items = new List<Item> { item1, item2 } }; // act: user the Total method on ShoppingCart var actualTotal = cart.Total; // assert: totals should match Assert.That(actualTotal, Is.EqualTo(expectedTotal)); } |
Se o Live Unit Testing estiver ativado, então o teste está sendo executado automaticamente em segundo plano pelo Visual Studio. Você deverá ver algumas marcas de verificação verdes.
As marcas de verificação verdes também aparecerão sempre que o código que está sendo testado for coberto.
Com o Visual Studio Live Unit Testing, você não precisa parar para executar os testes. Enquanto estiver codificando, os testes serão executados e lhe darão feedback imediato sobre se o seu código está fazendo com que os testes falhem (ou se você escreveu código suficiente para que o teste seja aprovado).
Acima de tudo, isso o incentivará a escrever mais testes.
O que são testes de integração?
Ao escrever testes de unidade, você deve testar um pequeno trecho de código isoladamente. Para o código que interage com algum serviço externo (um serviço da Web, um banco de dados, um sistema de arquivos etc.), você geralmente simula essas partes para que possa se concentrar na unidade.
Você também pode escrever testes de integração com o NUnit. Testes de integração que têm como objetivo ir além do teste de uma única unidade de código e testar se os sistemas funcionam juntos. Vamos escrever um método que grava um registro no Couchbase Server. Esse teste usará um banco de dados real e, portanto, podemos considerá-lo um teste de integração.
|
1 2 3 4 5 6 7 8 |
public void SaveShoppingCart(ShoppingCart cart) { _bucket.Insert(new Document<ShoppingCart> { Id = Guid.NewGuid().ToString(), Content = cart }); } |
Esse método deve salvar um carrinho de compras em um documento no Couchbase Server. Para ter certeza de que está funcionando, podemos escrever um teste NUnit.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
[Test] public void Repo_Can_Save_a_New_Shopping_Cart_to_Database() { // arrange: create a shopping cart var cart = new ShoppingCart { UserName = "Matthew " + Guid.NewGuid().ToString(), LastUpdated = DateTime.Now }; // act: save shopping cart to database Repo.SaveShoppingCart(cart); // assert: check that the cart was saved var cartBackOut = Repo.GetCartByUserName(cart.UserName); Assert.That(cartBackOut, Is.Not.Null); Assert.That(cartBackOut.UserName, Is.EqualTo(cart.UserName)); } |
Observação: para simplificar esta postagem, omiti alguns detalhes do repositório e a configuração do teste. Você pode ver tudo isso em o repositório do GitHub.
Testes de integração com o Visual Studio Live Unit Testing
O Visual Studio Live Unit Testing executará com prazer esse teste de unidade. Talvez você não queira que esses tipos de testes sejam executados automaticamente em segundo plano porque:
- Se você não tiver o Couchbase Server instalado ou um bucket criado e indexado, eles falharão.
- Se você tiver muitos testes que dependem de componentes externos, eles poderão tornar os testes mais lentos (ler/escrever documentos no Couchbase é muito rápido, mas configurar um
Aglomeradopara cada teste ou dispositivo de teste não é). - Esses testes podem adicionar muitos dados de teste desnecessários e inúteis ao seu banco de dados.
Exclusão de testes de integração do teste de unidade do Visual Studio Live
Para excluir testes do Live Unit Testing, basta clicar com o botão direito do mouse no arquivo de teste e selecionar "Exclude" (Excluir) no menu de contexto.
Depois disso, nenhum dos testes desse arquivo será executado pelo Live Unit Testing. Você também pode excluir um projeto inteiro. Portanto, se você organizar os testes de unidade e os testes de integração em projetos separados, estará tudo pronto.
Se você não organizá-los em projetos separados, então esse processo pode ser um pouco tedioso. Além disso, as informações de Incluir/Excluir são uma configuração local que não pode (no momento em que estou escrevendo este texto, e até onde sei) ser confirmada no controle de origem.
Então, depois de perguntar sobre Exclusão de testes ao vivo no StackOverflowEm uma das minhas pesquisas, criei um atributo que você pode colocar nos testes para excluí-los do Live Testing.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class IgnoreForLiveTesting : Attribute, ITestAction { readonly string _ignoreReason; public IgnoreForLiveTesting(string ignoreReason = null) { _ignoreReason = ignoreReason; } public ActionTargets Targets { get; set; } public void AfterTest(ITest test) { } public void BeforeTest(ITest test) { var isLiveTesting = AppDomain.CurrentDomain.GetAssemblies() .Any(a => a.GetName().Name == "Microsoft.CodeAnalysis.LiveUnitTesting.Runtime"); if (isLiveTesting) Assert.Ignore(_ignoreReason ?? "Ignoring this test"); } } |
Esse atributo implementa o atributo ITestAction (que é uma espécie de Aspect-Oriented Programming/AOP para o NUnit, mas esse é um tópico para outra postagem no blog). Ele verificará se está sendo executado por um LiveUnitTesting processo. Se for, ele instrui o NUnit a ignorar o teste.
Além disso, adicionei uma opção ignoreReason ao construtor, para que você possa adicionar uma nota útil a outras pessoas da sua equipe para explicar por que esse teste não deve ser executado com o Live Unit Testing. Você pode usá-lo em um teste de integração da seguinte forma:
|
1 |
[IgnoreForLiveTesting("Integration Test")] |
Resumo
Não estou muito satisfeito com esse método, pois ele é específico do NUnit e não é exatamente o que eu esperava com o Visual Studio Live Unit Testing. Mas, no momento, acho que "o suco vale a pena ser espremido". O Live Unit Testing é um recurso tão bom para escrever código, especialmente o TDD (Test-Driven Development, desenvolvimento orientado por testes), que vale a pena ter que escrever e usar um atributo especial do NUnit.
Se você souber de uma maneira melhor de fazer isso, quero saber. Deixe um comentário abaixo ou entre em contato comigo pelo Twitter @mgroves.
Se você tiver dúvidas sobre o código do Couchbase que viu nesta publicação, terei prazer em ajudar. Ou você pode dar uma olhada na comunidade responsiva e bem informada no site Fórum do SDK do Couchbase .NET. Se você quiser saber mais sobre o Couchbase, confira o Portal do desenvolvedor do Couchbase.
[...] por /u/mgroves [link] [...]
[...] https://www.couchbase.com/visual-studio-live-unit-testing-2017/ [...]
[...] Teste de unidade do Visual Studio Live: Novo no Visual Studio 2017 [...]