Visual Studio Live Unit Testing: New to Visual Studio 2017

Visual Studio 2017 acaba de ser lanzado oficialmente. Viene con un montón de cosas nuevas y geniales, pero una de mis nuevas características favoritas es Visual Studio Live Unit Testing integrado (disponible en Visual Studio 2017 Enterprise, aún no disponible para proyectos .NET Core).

En este post, voy a mostrarte cómo funciona Visual Studio Live Unit Testing, así como algunas reflexiones sobre el uso de pruebas unitarias vs. pruebas de unidad. pruebas de integración. Puedes seguirlo obteniendo el código fuente completo de este Ejemplo de pruebas unitarias en GitHub.

Pruebas unitarias en vivo de Visual Studio con NUnit

NUnit es quizás la herramienta de pruebas más popular para los desarrolladores C#/.NET. Visual Studio Live Unit Testing también puede trabajar con xUnit y MSTest, pero para este post voy a cubrir sólo NUnit.

Para usar NUnit, lo añades con NuGet, como de costumbre. Para utilizar Visual Studio Live Testing, también tendrá que añadir el módulo Adaptador de pruebas NUnit (Install-Package NUnite3TestAdapter).

A continuación, inicie Live Testing haciendo clic en Test → Live Unit Testing → Start.

Start Visual Studio Live Unit Testing

Escribir una prueba unitaria

Necesitaremos algunas pruebas unitarias para demostrarlo. Podríamos hacer Assert.That(1, Es.IgualA(1))pero, ¿dónde está la diversión en eso? Vamos a crear una clase de carrito 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 clase Carrito de la compra

{

público cadena Nombre de usuario { consiga; configure; }

público FechaHora ÚltimaActualización { consiga; configure; }

público Lista<Artículo> Artículos { consiga; configure; }

público decimal Total

{

consiga { devolver Artículos.Suma(i => i.Precio); }

}

Este carrito de la compra tiene un par de propiedades, y una colección de artículos en él. Fíjese en Total propiedad. Los lectores astutos ya pueden notar algunos problemas con ella, pero vamos a empezar con una simple prueba unitaria para asegurarnos de que calcula un 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));
}

[Prueba]

público void Carro_de_compra_Total_Debe_Sumar_los_precios_de_los_artículos()

{

// organizar: crear una cesta de la compra con 2 artículos y calcular el total previsto

var artículo1 = nuevo Artículo { Nombre = "Pizza grande de pepperoni", Precio = 14.99M };

var artículo2 = nuevo Artículo { Nombre = "Palitos de Queso", Precio = 4.99M };

var expectedTotal = artículo1.Precio + artículo2.Precio;

var carro = nuevo Carrito de la compra { Artículos = nuevo Lista<Artículo> { artículo1, artículo2 } };

// actuar: utilizar el método Total en ShoppingCart

var actualTotal = carro.Total;

// assert: los totales deben coincidir

Afirme.Que(actualTotal, Es.EqualTo(expectedTotal));

}

Si la prueba unitaria en vivo está activada, Visual Studio ejecuta automáticamente la prueba en segundo plano. Usted debe ver algunas marcas verdes aparecen.

Visual Studio Live Unit Testing in action

Las marcas verdes también aparecerán siempre que el código que se está probando esté cubierto.

Visual Studio Live Unit Testing code under test

Con Visual Studio Live Unit Testing, no tienes que detenerte para ejecutar las pruebas. Mientras codificas, las pruebas se ejecutarán y te darán información inmediata sobre si tu código está haciendo que las pruebas fallen (o si has escrito suficiente código para hacer que tu prueba pase).

Sobre todo, esto le animará a escribir más pruebas.

¿Qué son las pruebas de integración?

Cuando se escriben pruebas unitarias, se pretende probar un pequeño fragmento de código por sí solo. Para el código que interactúa con algún servicio externo (un servicio web, una base de datos, un sistema de archivos, etc.), a menudo se simulan esas piezas, para que pueda centrarse en la unidad.

También puede escribir pruebas de integración con NUnit. Pruebas de integración que pretenden ir más allá de probar una sola unidad de código, y probar que los sistemas funcionan juntos. Escribamos un método que escriba un registro en Couchbase Server. Esta prueba utilizará una base de datos real, por lo tanto podemos considerarla una prueba de integración.

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

público void SaveShoppingCart(Carrito de la compra carro)

{

_bucket.Inserte(nuevo Documento<Carrito de la compra>

{

Id = Guía.NuevaGuid().ToString(),

Contenido = carro

});

}

Este método debería guardar un carrito de la compra en un documento en Couchbase Server. Para asegurarnos de que funciona, podemos escribir un test 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));
}

[Prueba]

público void Repo_Can_Save_a_New_Shopping_Cart_to_Database (en inglés)()

{

// organizar: crear un carrito de la compra

var carro = nuevo Carrito de la compra

{

Nombre de usuario = "Matthew" + Guía.NuevaGuid().ToString(),

ÚltimaActualización = FechaHora.Ahora

};

// act: guardar la cesta de la compra en la base de datos

Repo.SaveShoppingCart(carro);

// assert: comprueba que el carrito se ha guardado

var cartBackOut = Repo.GetCartByUserName(carro.Nombre de usuario);

Afirme.Que(cartBackOut, Es.No.Nulo);

Afirme.Que(cartBackOut.Nombre de usuario, Es.EqualTo(carro.Nombre de usuario));

}

Nota: Para mantener este post simple, he omitido algunos de los detalles del repositorio, y la configuración de prueba. Usted puede ver todo esto en el repositorio GitHub.

Pruebas de integración con Visual Studio Live Unit Testing

Visual Studio Live Unit Testing ejecutará felizmente esta prueba de unidad. Es posible que no desee que este tipo de pruebas se ejecuten automáticamente en segundo plano porque:

Si no tienes Couchbase Server instalado, o un bucket creado e indexado, entonces fallarán.
Si tienes muchas pruebas que dependen de componentes externos, podrían ralentizar las pruebas (leer/escribir documentos en Couchbase es muy rápido, pero configurar un Grupo para cada prueba o banco de pruebas).
Estas pruebas podrían añadir un montón de datos de prueba basura innecesarios a su base de datos.

Excluir las pruebas de integración de las pruebas unitarias de Visual Studio Live

Para excluir pruebas de Live Unit Testing, basta con hacer clic con el botón derecho del ratón en el archivo de prueba y seleccionar "Excluir" en el menú contextual.

Exclude from Live Unit Testing

Después de esto, ninguna de las pruebas en ese archivo será ejecutada por Live Unit Testing. También puede excluir un proyecto entero. Por lo tanto, si organiza las pruebas unitarias y las pruebas de integración en proyectos separados, entonces está todo listo.

Si usted no organizarlos en proyectos separados, entonces este proceso podría ser un poco tedioso. Además, la información de Incluir/Excluir es una configuración local que no puede (en el momento en que estoy escribiendo esto, y que yo sepa) comprometerse con el control de código fuente.

Así que, después de preguntar por Exclusión de pruebas en vivo en StackOverflowHe creado un atributo que se puede colocar en las pruebas para excluirlas de las pruebas en vivo.

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 clase IgnoreForLiveTesting : Atributo, ITestAction

{

sólo lectura cadena _ignoreReason;

público IgnoreForLiveTesting(cadena ignoreReason = null)

{

_ignoreReason = ignoreReason;

}

público Objetivos de la acción Objetivos { consiga; configure; }

público void Después de la prueba(ITest prueba) { }

público void Antes de la prueba(ITest prueba)

{

var isLiveTesting = AppDomain.DominioActual.GetAssemblies()

.Cualquier(a => a.ObtenerNombre().Nombre == "Microsoft.CodeAnalysis.LiveUnitTesting.Runtime");

si (isLiveTesting)

Afirme.Ignore(_ignoreReason ?? "Ignorando esta prueba");

}

Este atributo implementa la función ITestAction (que es algo así como la Programación Orientada a Aspectos/AOP para NUnit, pero ese es un tema para otra entrada del blog). Comprobará si está siendo ejecutado por un LiveUnitTesting proceso. Si lo es, indica a NUnit que ignore la prueba.

Además, he añadido un ignoreReason al constructor, para que pueda añadir una nota útil a otras personas de su equipo para explicar por qué esta prueba no debe ejecutarse con Live Unit Testing. Puede utilizarlo en una prueba de integración así:

[IgnoreForLiveTesting("Integration Test")]

1	[IgnoreForLiveTesting("Prueba de integración")]

Resumen

No estoy muy contento con este método, ya que es específico de NUnit, y no es exactamente lo que esperaba con Visual Studio Live Unit Testing. Pero en este momento creo que "el jugo vale la pena el apretón". Live Unit Testing es una característica tan grande para escribir código, especialmente Test-Driven Development (TDD), que vale la pena tener que escribir y utilizar un atributo especial de NUnit.

Si conoce una forma mejor de conseguirlo, quiero saberlo. Déjeme un comentario a continuación o envíeme un ping a Twitter @mgroves.

Si tienes preguntas sobre el código de Couchbase que has visto en este post, estaré encantado de ayudarte. También puedes consultar la comunidad de Couchbase en el sitio web Foro del SDK .NET de Couchbase. Si desea obtener más información sobre Couchbase, consulte la página Portal para desarrolladores de Couchbase.

Matthew Groves

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

Todos los mensajes

Pruebas unitarias en vivo de Visual Studio: Nuevo en Visual Studio 2017

Pruebas unitarias en vivo de Visual Studio con NUnit

Escribir una prueba unitaria

¿Qué son las pruebas de integración?

Pruebas de integración con Visual Studio Live Unit Testing

Excluir las pruebas de integración de las pruebas unitarias de Visual Studio Live

Resumen

Autor

Publicado por Matthew Groves

3 Comentarios

Dejar una respuesta Cancelar respuesta