Visual Studio Live Unit Testing: New to Visual Studio 2017

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.

Start Visual Studio Live Unit Testing

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.

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); }
    }
}

público classe ShoppingCart

{

público string Nome de usuário { obter; definir; }

público DateTime LastUpdated (Última atualização) { obter; definir; }

público Lista<Item> Itens { obter; definir; }

público decimal Total

{

obter { retorno Itens.Soma(i => i.Preço); }

}

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.

[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));
}

[Teste]

público vazio ShoppingCart_Total_Should_Sum_Up_the_Item_Prices()

{

// organizar: criar um carrinho de compras com 2 itens e calcular o total esperado

var item1 = novo Item { Nome = "Pizza grande de pepperoni", Preço = 14.99M };

var item2 = novo Item { Nome = "Cheese Sticks" (palitos de queijo), Preço = 4.99M };

var total esperado = item1.Preço + item2.Preço;

var carrinho = novo ShoppingCart { Itens = novo Lista<Item> { item1, item2 } };

// act: usuário do método Total no ShoppingCart

var total real = carrinho.Total;

// assert: os totais devem corresponder

Afirmar.Isso(total real, É.EqualTo(total esperado));

}

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.

Visual Studio Live Unit Testing in action

As marcas de verificação verdes também aparecerão sempre que o código que está sendo testado for coberto.

Visual Studio Live Unit Testing code under test

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.

public void SaveShoppingCart(ShoppingCart cart)
{
    _bucket.Insert(new Document<ShoppingCart>
    {
        Id = Guid.NewGuid().ToString(),
        Content = cart
    });
}

público vazio SalvarShoppingCart(ShoppingCart carrinho)

{

_bucket.Inserir(novo Documento<ShoppingCart>

{

Id = Guia.NovoGuia().ToString(),

Conteúdo = carrinho

});

}

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.

[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));
}

[Teste]

público vazio Repo_Can_Save_a_New_Shopping_Cart_to_Database()

{

// organizar: criar um carrinho de compras

var carrinho = novo ShoppingCart

{

Nome de usuário = "Matthew" + Guia.NovoGuia().ToString(),

LastUpdated (Última atualização) = DateTime.Agora

};

// act: salvar o carrinho de compras no banco de dados

Recompra.SalvarShoppingCart(carrinho);

// assert: verifica se o carrinho foi salvo

var cartBackOut = Recompra.GetCartByUserName(carrinho.Nome de usuário);

Afirmar.Isso(cartBackOut, É.Não.Nulo);

Afirmar.Isso(cartBackOut.Nome de usuário, É.EqualTo(carrinho.Nome de usuário));

}

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 Aglomerado para 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.

Exclude from Live Unit Testing

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.

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");
    }
}

público classe IgnoreForLiveTesting (Ignorar para testes ao vivo) : Atributo, ITestAction

{

somente leitura string _ignoreReason;

público IgnoreForLiveTesting (Ignorar para testes ao vivo)(string ignoreReason = nulo)

{

_ignoreReason = ignoreReason;

}

público ActionTargets Metas { obter; definir; }

público vazio Após o teste(Teste de TI teste) { }

público vazio Antes do teste(Teste de TI teste)

{

var isLiveTesting = Domínio do aplicativo.CurrentDomain (domínio atual).GetAssemblies()

.Qualquer(a => a.GetName().Nome == "Microsoft.CodeAnalysis.LiveUnitTesting.Runtime");

se (isLiveTesting)

Afirmar.Ignorar(_ignoreReason ?? "Ignorando este teste");

}

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:

[IgnoreForLiveTesting("Integration Test")]

1	[IgnoreForLiveTesting (Ignorar para testes ao vivo)("Teste de integração")]

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.

Matthew Groves

Compartilhe este artigo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Teste de unidade do Visual Studio Live: Novo no Visual Studio 2017

Teste de unidade do Visual Studio Live com o NUnit

Escrevendo um teste de unidade

O que são testes de integração?

Testes de integração com o Visual Studio Live Unit Testing

Exclusão de testes de integração do teste de unidade do Visual Studio Live

Resumo

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por Matthew Groves

3 Comentários

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato