Cómo crear una prueba de unidad AC # en Visual Studio

Siempre que esté escribiendo algún software, es probable que a menudo llegue a cierto punto y luego compile y ejecute el programa para ver si funciona. A medida que se acumula más y más código, ejecutar e inspeccionar los resultados usted mismo consume mucho tiempo. En C # y Visual Studio, es posible configurar pruebas automatizadas mediante pruebas unitarias . Una prueba unitaria es simplemente cuando un desarrollador escribe un código C # para probar otro código C # de forma automatizada. En este tutorial, veremos los conceptos básicos de la configuración de una prueba unitaria en Visual Studio.

Proyecto de prueba unitaria (.NET Framework)

Existe un tipo de proyecto en Visual Studio que se dedica a crear pruebas. Esto se denomina apropiadamente Proyecto de prueba unitaria. Querríamos usar este tipo de proyecto para crear pruebas que verifiquen que las clases que construimos funcionen según lo previsto. El tipo de proyecto de prueba unitaria crea un nuevo ensamblaje con el código de prueba que escribimos. Ese nuevo ensamblado hará referencia a otro ensamblado con el código que se está probando. Si queremos verificar que nuestra clase StockPortfolio.cs está funcionando correctamente, creamos un nuevo proyecto de prueba y escribimos un código de prueba donde ese proyecto de prueba hará referencia al ensamblado con StockPortfolio. Agreguemos un nuevo proyecto en nuestra solución para mostrar esta técnica. Para comenzar, haga clic con el botón derecho en la ventana del explorador de soluciones en el nombre de la solución. Esto abrirá un nuevo submenú donde puede elegir Agregar-> Nuevo proyecto.
nuevo proyecto del explorador de soluciones

Una vez allí, ahora elegiría la opción Prueba en el área de Visual C #, elegir Proyecto de prueba unitaria (.NET Framework) y darle un nombre al nuevo proyecto.
agregar nueva prueba unitaria de proyecto

Una vez que haga clic en Aceptar, notará que el explorador de soluciones en Visual Studio ahora tiene dos proyectos. El original y el nuevo de prueba que se acaba de crear.
nuevo proyecto de prueba en el explorador de soluciones

La inspección del nuevo proyecto Stocks.Test revela un nuevo archivo de clase llamado UnitTest1.cs que tiene este código repetitivo configurado para usted.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace Stocks.Test
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}

Ejecución de las pruebas

Ahora, cuando crea la solución, lo que sucede es que ambos proyectos contenidos en la solución se compilan al mismo tiempo. En nuestro caso, eso significa que se construyen los proyectos de Stocks y Stocks.Test. Vamos a construirlo ahora solo por diversión haciendo clic en Ctrl + Shift + B. Efectivamente, este es el resultado que obtenemos.

1> ------ Construcción iniciada: Proyecto: Acciones, Configuración: Depurar cualquier CPU ------
2> ------ Construcción iniciada: Proyecto: Stocks.Test, Configuración: Depurar cualquier CPU ------
2> Stocks.Test -> C: UsersusersourcereposStocksStocks.TestbinDebugStocks.Test.dll
1> Acciones -> C: UsersusersourcereposStocksStocksbinDebugStocks.exe
========== Compilación: 2 tuvo éxito, 0 falló, 0 actualizado, 0 omitido ==========

Así que ahora tenemos un ensamblado Stocks.exe y un ensamblado Stocks.Test.dll. Aprendimos sobre los diferentes tipos de ensamblajes en nuestro tutorial de ensamblajes. Incluso podemos ejecutar las pruebas de inmediato. Todavía no tenemos ninguna prueba que pruebe ninguna lógica válida, pero ese código repetitivo inicial es de hecho una prueba. Podemos seleccionar Prueba-> Ejecutar-> Todas las pruebas para ver qué sucede.
prueba de visual studio ejecutar todas las pruebas
La ventana de salida nos muestra lo que está haciendo Visual Studio.

[2/11/2019 11:19:41 a.m. Informativo] ------ Prueba de descubrimiento iniciada ------
[2/11/2019 11:19:46 AM Informativo] ========== Prueba de descubrimiento finalizada: 1 encontrado (0: 00: 04.8223994) ==========
[2/11/2019 11:19:46 AM Informativo] ------ Ejecutar prueba iniciada ------
[2/11/2019 11:19:49 AM Informativo] ========== Prueba de ejecución finalizada: 1 ejecución (0: 00: 02.5658109) ==========

Luego, en la GUI de Visual Studio podemos ver una nueva ventana, la ventana Test Explorer .
prueba de la ventana del explorador visual studio

En el Explorador de pruebas hay un único método llamado TestMethod1 . Podemos ver una marca de verificación verde que debe significar buenas noticias. Bueno, ¡significa que la prueba pasó! Pasó porque todavía no estamos probando ninguna funcionalidad, pero pronto lo haremos.

Estructura de una prueba unitaria

La inspección de ese proyecto Stocks.Test nos muestra un archivo llamado UnitTest1.cs . Dentro de ese archivo hay una clase del mismo nombre, UnitTest1. Finalmente, vemos un método dentro de esa clase con el nombre TestMethod1 . Justo antes vimos el código repetitivo que se produjo para nosotros. Hay una sintaxis peculiar que vemos allí donde vemos tanto [TestClass] como [TestMethod] . ¿Que son esos?

Los nombres entre paréntesis le indican al ejecutor de pruebas qué clases y métodos son realmente pruebas. Estos deben ejecutarse durante las pruebas para ver si pasan o fallan y la sintaxis de los corchetes se conoce como atributos en C #. Un atributo es un dato asociado a una clase o método. Se pueden usar para muchas cosas, pero al configurar las pruebas es importante recordar que al escribir una prueba que el ejecutor de la prueba ejecutará por usted, deberá colocar ese código dentro de un método que tenga un atributo TestMethod que usa corchetes alrededor. Además, la clase en la que reside el método de prueba debe ser una clase pública que también tenga el atributo TestClass .

Presentamos Assert

La clase Assert es donde puede comenzar a trabajar con la lógica real. Puede utilizar la clase Assert para realizar afirmaciones sobre los datos del programa. Si esas afirmaciones no vuelven a ser verdaderas, la prueba fallará con un error. La clase Assert tiene una gran colección de métodos para probar como AreEqual, AreNotEqual, AreNotSame, AreSame, Equals, Fail, Inconclusive, IsFalse, IsInstanceOfType, IsNotInstanceOfType, IsNotNull, IsNull, IsTrue, ReplaceNullChars y ThrowsException, ThrowsException. Probemos uno. Intentaremos afirmar que 1 es igual a 2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace Stocks.Test
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            Assert.AreEqual(1, 2);
        }
    }
}

Ahora podemos ejecutar todas las pruebas y, por supuesto, Visual Studio nos muestra que tenemos pruebas fallidas.
falla en la prueba de la unidad de estudio visual

Una vez que vea esa prueba fallida, puede profundizar en el método de prueba fallido y obtener algo de información al respecto. Aquí mismo hacemos clic en TestMethod1 para obtener la información de que Mensaje: Assert.AreEqual falló. Esperado: <1>. Real: <2> . Entonces, la prueba deja en claro lo que se esperaba y lo que realmente sucedió. También puede hacer doble clic en el método que falla en la ventana del explorador de pruebas y Visual Studio moverá automáticamente el cursor a la ubicación en el código de prueba donde ocurrió la falla.
doble clic para pasar al método

Hagamos que esa prueba pase ahora. Podemos afirmar que 1 es igual a 1. Esperamos que esto pase cuando ejecutemos todas las pruebas ahora.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace Stocks.Test
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            Assert.AreEqual(1, 1);
        }
    }
}

TestMethod1 Pasando

Prueba de la clase StockPortfolio

Ok, la información anterior nos puso en marcha sobre cómo crear una prueba en Visual Studio. Ahora sabemos cómo crear un nuevo proyecto en una solución con fines de prueba, cómo identificar pruebas con la sintaxis del atributo de prueba y cómo ejecutar las pruebas. Frio. Ahora hagamos algunas pruebas que determinen si la clase StockPortfolio en nuestro proyecto está funcionando correctamente. Podemos hacer eso haciendo clic derecho en el proyecto Stocks.Tests y eligiendo agregar una clase. Podemos llamarlo StockPortfolioTests.
nuevo archivo de prueba de clase

Esto creará un código de prueba repetitivo, pero aún tenemos que etiquetar la clase como una clase de prueba con el atributo [TestClass] y, para hacerlo, Visual Studio le indicará que importe el espacio de nombres Microsoft.VisualStudio.TestTools.UnitTesting.
Información sobre herramientas de acciones rápidas

Ahora nuestro código está listo para comenzar a agregar pruebas usando el espacio de nombres Microsoft.VisualStudio.TestTools.UnitTesting.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Stocks.Test
{
    [TestClass]
    public class StockPortfolioTests
    {
 
    }
}

Referencias y modificadores de acceso

Para probar la clase StockPortfolio, necesitamos usarla en nuestro proyecto Stocks.Test. Cuando intentamos usarlo, obtenemos este error: "El nombre 'StockPortfolio' no existe en el contexto actual".
El nombre cartera de valores no existe en el contexto actual

Ok entonces que paso? Aunque nuestros dos proyectos se encuentran en la misma solución, no podremos utilizar StockPortfolio hasta que se establezca una referencia del proyecto Stocks.Test a Stocks.
Podemos solucionar este problema haciendo clic con el botón derecho en Referencias-> Agregar referencia-> Proyectos y luego seleccionando Acciones. Esto nos permite hacer referencia al ensamblaje creado por el otro proyecto, el ensamblaje Stocks. Una vez hecho esto, vemos que el ensamblado de existencias se muestra en el Explorador de soluciones.
ensamblaje de referencia de diferente proyecto misma solución

Eso es genial, pero ahora recibimos un mensaje de error diferente de "StockPortfolio es inaccesible debido a su nivel de protección".
la cartera de valores es inaccesible debido a su nivel de protección

Para solucionar este problema, podemos cambiar el modificador de acceso de la clase StockPortfolio. Al crear una clase, si no especifica el nivel de acceso, su valor predeterminado se establecerá en internal. Una clase interna solo puede ser utilizada por código que esté dentro del mismo proyecto. Si quiero que StockPortfolio esté disponible en StockPortfolioTests, debe configurarlo como público .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Stocks
{
    public class StockPortfolio
    {
        public StockPortfolio()
        {
            stocks = new List<float>();
        }
 
        public StockStatistics ComputeStatistics()
        {
            StockStatistics stats = new StockStatistics();
 
 
            float sum = 0;
            foreach (float stock in stocks)
            {
                stats.HighestStock = Math.Max(stock, stats.HighestStock);
                stats.LowestStock = Math.Min(stock, stats.LowestStock);
                sum += stock;
            }
 
            stats.AverageStock = sum / stocks.Count;
            return stats;
        }
 
        public void AddStock(float stock)
        {
            stocks.Add(stock);
        }
 
        private List<float> stocks;
    }
}

Esto es genial, pero ahora estamos recibiendo un error en esta clase: “Accesibilidad inconsistente: el tipo de retorno 'StockStatistics' es menos accesible que el método 'StockPortfolio.ComputeStatistics ()'”.
accesibilidad inconsistente tipo de retorno estadísticas de stock es menos accesible que el método stockportfolio-computestatistics

¿Por qué es esto? Esto se debe a que la clase StockPortfolio aprovecha otra clase, StockStatistics, y su modificador de acceso también es interno. Podemos arreglar esto en la clase StockStatistics y hacerlo público así.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Stocks
{
    public class StockStatistics
    {
        public StockStatistics()
        {
            HighestStock = 0;
            LowestStock = float.MaxValue;
        }
 
        public float AverageStock;
        public float HighestStock;
        public float LowestStock;
    }
}

Esto debería arreglar todo lo que necesitamos para crear una prueba útil. Podemos crear una prueba para asegurarnos de que cuando proporcionemos al StockPortfolio una colección de precios de acciones, calculará correctamente y devolverá el precio de acción más bajo cuando lo solicitemos. Aquí está el código para hacer eso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Stocks.Test
{
    [TestClass]
    public class StockPortfolioTests
    {
        [TestMethod]
        public void ComputesLowestPrice()
        {
            StockPortfolio portfolio = new StockPortfolio();
 
            portfolio.AddStock(100);
            portfolio.AddStock(25);
 
            StockStatistics result = portfolio.ComputeStatistics();
 
            Assert.AreEqual(25, result.LowestStock);
        }
    }
}

Vamos a recorrerlo.

Se crea una instancia de un nuevo objeto StockPortfolio y se coloca en la portfoliovariable.
Usando esa variable, ahora llamamos al método AddStock () dos veces. Una vez para agregar un precio de 100 y otra para agregar un precio de 25.
Nuevamente, desde la variable de cartera, ahora llamamos al método ComputeStatistics () y almacenamos el resultado en la resultvariable.
Entonces podemos afirmar que 25 es igual a llamar a result.LowestStock.

¡Parece que la prueba está pasando!

Desde aquí podemos continuar agregando pruebas como queramos y según sea necesario para proporcionar la cantidad correcta de cobertura de código.

Cómo crear una prueba de unidad AC # en el resumen de Visual Studio

En este tutorial sobre pruebas en C #, primero revisamos cómo C # crea un ensamblado al crear una solución en Visual Studio. El ensamblado resultante comparte el nombre del proyecto y tiene una extensión .exe o .dll. El primero es un archivo ejecutable y el siguiente es una biblioteca de clases. Para verificar que su código se está desempeñando como es de esperar, puede crear y ejecutar pruebas unitarias en Visual Studio. La prueba unitaria es el proceso de dividir un programa en acciones aisladas que puede probar como unidades individuales. El Explorador de pruebas es donde podemos ver nuestras pruebas y ejecutarlas en Visual Studio. Para hacer uso de los métodos disponibles para las pruebas, usamos el espacio de nombres Microsoft.VisualStudio.TestTools.UnitTesting. Es aconsejable volver a ejecutar las pruebas unitarias siempre que se realicen cambios en el código de un programa. Esto asegurará que el nuevo código no afecte al código existente y que el programa continúe funcionando como se esperaba.

Header Ads Widget

Cómo crear una prueba de unidad AC # en Visual Studio

Proyecto de prueba unitaria (.NET Framework)

Ejecución de las pruebas

Estructura de una prueba unitaria

Presentamos Assert

Prueba de la clase StockPortfolio

Referencias y modificadores de acceso

Cómo crear una prueba de unidad AC # en el resumen de Visual Studio

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget