Usar el marco de trabajo MSTest en pruebas unitarias

  • Artículo

El marco de trabajo MSTest admite pruebas unitarias en Visual Studio. Utilice las clases y los miembros en el espacio de nombres Microsoft.VisualStudio.TestTools.UnitTesting cuando se estén codificando pruebas unitarias. También puede utilizarlos si está perfeccionando una prueba unitaria que se generó a partir de código.

Miembros del marco de trabajo

Con el fin de proporcionar una visión general más clara del marco de pruebas unitarias, esta sección organiza los miembros del espacio de nombres Microsoft.VisualStudio.TestTools.UnitTesting en grupos de funcionalidad relacionada.

Nota

Los elementos de atributo, cuyos nombres terminan con "Attribute", se pueden usar con o sin "Attribute" al final y para constructores sin parámetros con o sin paréntesis. Por ejemplo, los dos siguientes ejemplos de código funcionan de forma idéntica:

[TestClass()]

[TestClassAttribute()]

[TestClass]

[TestClassAttribute]

Atributos utilizados para identificar clases y métodos de prueba

Cada clase de prueba debe tener el atributo TestClass y todos los métodos de prueba deben tener el atributo TestMethod. Para obtener más información, vea Estructura de una prueba unitaria.

TestClassAttribute

El atributo TestClass marca una clase que contiene pruebas y, opcionalmente, inicializa o limpia métodos.

Este atributo se puede extender para actualizar o ampliar el comportamiento.

Ejemplo:

[TestClass]
public class MyTestClass
{    
}

TestMethodAttribute

El atributo TestMethod se usa dentro de TestClass para definir el método de prueba real que se va a ejecutar.

El método debe ser un método de instancia definido como public void o public Task (opcionalmente async) y no tener parámetros.

Ejemplo

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void TestMethod()
    {
    }
}

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public async Task TestMethod()
    {
    }
}

Atributos usados para pruebas controladas por datos

Utilice los siguientes elementos para configurar pruebas unitarias controladas por datos. Para obtener más información, vea Cómo: Crear una prueba unitaria controlada por datos y Tutorial: Utilizar un archivo de configuración para definir un origen de datos.

DataRow

DataRowAttribute permite proporcionar datos insertados que se usan al invocar el método de prueba. Puede aparecer una o varias veces en un método de prueba. Debe combinarse con TestMethodAttribute o DataTestMethodAttribute.

El número y los tipos de argumentos deben coincidir exactamente con la signatura del método de prueba.

Ejemplos de llamadas válidas:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, "message", true, 2.0)]
    public void TestMethod1(int i, string s, bool b, float f) {}
    
    [TestMethod]
    [DataRow(new string[] { "line1", "line2" })]
    public void TestMethod2(string[] lines) {}

    [TestMethod]
    [DataRow(null)]
    public void TestMethod3(object o) {}

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" }, new string[] { "line1.", "line2." })]
    public void TestMethod4(string[] input, string[] expectedOutput) {}
}

Tenga en cuenta que también puede usar la característica params para capturar varias entradas de DataRow.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, 3, 4)]
    public void TestMethod(params int[] values) {}
}

Ejemplos de combinaciones no válidas:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2)] // Not valid, we are passing 2 inline data but signature expects 1
    public void TestMethod1(int i) {}

    [TestMethod]
    [DataRow(1)] // Not valid, we are passing 1 inline data but signature expects 2
    public void TestMethod2(int i, int j) {}

    [TestMethod]
    [DataRow(1)] // Not valid, count matches but types do not match
    public void TestMethod3(string s) {}
}

Nota:

A partir de MSTest v3, cuando quiera pasar exactamente dos matrices, ya no es necesario encapsular la segunda en una matriz de objetos. Antes: [DataRow(new string[] { "a" }, new object[] { new string[] { "b" } })] A partir de v3: [DataRow(new string[] { "a" }, new string[] { "b" })]

Puede modificar el nombre para mostrar que se usa en Visual Studio y los registradores para cada instancia de DataRowAttribute mediante el establecimiento de la propiedad DisplayName.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, DisplayName= "Functional Case FC100.1")]
    public void TestMethod(int i, int j) {}
}

También puede crear su propio atributo de fila de datos especializado mediante la herencia de DataRowAttribute.

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class MyCustomDataRowAttribute : DataRowAttribute
{
}

[TestClass]
public class TestClass
{
    [TestMethod]
    [MyCustomDataRow(1)]
    public void TestMethod(int i) {}
}

Atributos usados para proporcionar inicialización y limpiezas

Se llama a un método representativo con uno de los siguientes atributos en el momento que especifique. Para obtener más información, vea Estructura de una prueba unitaria.

Assembly

Se llama a AssemblyInitialize justo después de cargar el ensamblado y se llama a AssemblyCleanup justo antes de descargarlo.

Los métodos marcados con estos atributos deben definirse como static void o static Task, en TestClass, y solo aparecen una vez. La parte initialize requiere un argumento de tipo TestContext y la limpieza sin argumentos.

[TestClass]
public class MyTestClass
{
    [AssemblyInitialize]
    public static void AssemblyInitialize(TestContext testContext)
    {
    }

    [AssemblyCleanup]
    public static void AssemblyCleanup()
    {
    }
}

[TestClass]
public class MyOtherTestClass
{
    [AssemblyInitialize]
    public static async Task AssemblyInitialize(TestContext testContext)
    {
    }

    [AssemblyCleanup]
    public static async Task AssemblyCleanup()
    {
    }
}

Clase

Se llama a ClassInitialize justo antes de cargar la clase (pero después del constructor estático) y se llama a ClassCleanup justo después de descargarla.

Es posible controlar el comportamiento de herencia: solo para la clase actual mediante InheritanceBehavior.None o para todas las clases derivadas mediante InheritanceBehavior.BeforeEachDerivedClass.

También es posible configurar si la limpieza de clase debe ejecutarse al final de la clase o al final del ensamblado (ya no se admite a partir de MSTest v4, ya que EndOfClass es el comportamiento de limpieza de clase predeterminado, aparte del único).

Los métodos marcados con estos atributos deben definirse como static void o static Task, en TestClass, y solo aparecen una vez. La parte initialize requiere un argumento de tipo TestContext y la limpieza sin argumentos.

[TestClass]
public class MyTestClass
{
    [ClassInitialize]
    public static void ClassInitialize(TestContext testContext)
    {
    }

    [ClassCleanup]
    public static void ClassCleanup()
    {
    }
}

[TestClass]
public class MyOtherTestClass
{
    [ClassInitialize]
    public static async Task ClassInitialize(TestContext testContext)
    {
    }

    [ClassCleanup]
    public static async Task ClassCleanup()
    {
    }
}

Prueba

Se llama a TestInitialize justo antes de iniciar la prueba y se llama a TestCleanup justo después de finalizarla.

TestInitialize es similar al constructor de clase, pero normalmente es más adecuado para inicializaciones largas o asincrónicas. Siempre se llama a TestInitialize después del constructor y para cada prueba (incluida cada fila de datos de pruebas controladas por datos).

TestCleanup es similar a la clase Dispose (o DisposeAsync), pero normalmente es más adecuado para las limpiezas largas o asincrónicas. Siempre se llama a TestCleanup justo antes de DisposeAsync/Dispose y para cada prueba (incluida cada fila de datos de pruebas controladas por datos).

Los métodos marcados con estos atributos deben definirse como void o Task, en TestClass, no tener parámetros y aparecer una o varias veces.

[TestClass]
public class MyTestClass
{
    [TestInitialize]
    public void TestInitialize()
    {
    }

    [TestCleanup]
    public void TestCleanup()
    {
    }
}

[TestClass]
public class MyOtherTestClass
{
    [TestInitialize]
    public async Task TestInitialize()
    {
    }

    [TestCleanup]
    public async Task TestCleanup()
    {
    }
}

Las pruebas unitarias pueden comprobar el comportamiento de aplicaciones concretas por su uso de varias clases de aserciones, excepciones y atributos. Para obtener más información, vea Usar las clases Assert.

La clase TestContext

Los siguientes atributos y los valores asignados a ellos aparecen en la ventana Propiedades de Visual Studio para un método de prueba determinado. Estos atributos no están diseñados para tener acceso a través del código de la prueba unitaria. En su lugar, afectan a las formas en que se usa o ejecuta la prueba unitaria, ya sea a través del IDE de Visual Studio, o por el motor de pruebas de Visual Studio. Por ejemplo, algunos de estos atributos aparecen como columnas en las ventanas Administrador de pruebas y Resultados de pruebas, lo que significa que puede usarlas para agrupar y ordenar las pruebas y resultados de pruebas. Uno de estos atributos es TestPropertyAttribute, que se utiliza para agregar metadatos arbitrarios a las pruebas unitarias. Por ejemplo, se puede utilizar para almacenar el nombre de una "prueba superada" que cubre esta prueba, marcando la prueba unitaria con [TestProperty("TestPass", "Accessibility")]. O se puede utilizar para almacenar un indicador del tipo de prueba que es con [TestProperty("TestKind", "Localization")]. La propiedad que se crea mediante este atributo y el valor de propiedad que se asigna se muestran en la ventana Propiedades de Visual Studio bajo el encabezado Específico de prueba.

DeploymentItemAttribute

El marco MSTest V2 introdujo DeploymentItemAttribute para copiar archivos o carpetas especificados como elementos de implementación en el directorio de implementación (sin agregar una ruta de acceso de salida personalizada, los archivos copiados estarán en la carpeta TestResults dentro de la carpeta del proyecto). El directorio de implementación es donde están presentes todos los elementos de implementación junto con el archivo DLL del proyecto de prueba.

Se puede usar en clases de prueba (clases marcadas con el atributo TestClass) o en métodos de prueba (métodos marcados con el atributo TestMethod).

Los usuarios pueden tener varias instancias del atributo para especificar más de un elemento.

Y aquí puede ver sus constructores.

Ejemplo

[TestClass] 
[DeploymentItem(@"C:\classLevelDepItem.xml")]   // Copy file using some absolute path
public class UnitTest1
{
    [TestMethod]
    [DeploymentItem(@"..\..\methodLevelDepItem1.xml")]   // Copy file using a relative path from the dll output location
    [DeploymentItem(@"C:\DataFiles\methodLevelDepItem2.xml", "SampleDataFiles")]   // File will be added under a SampleDataFiles in the deployment directory
    public void TestMethod1()
    {
        string textFromFile = File.ReadAllText("classLevelDepItem.xml");
    }
}

Clases de configuración de prueba

Atributos que se utilizan para generar informes

Los atributos de esta sección relacionan el método de prueba que decoran con entidades de la jerarquía del proyecto de un proyecto de equipo de Team Foundation Server.

Clases utilizadas con descriptores de acceso privados

Puede generar una prueba unitaria para un método privado. Esta generación crea una clase de descriptor de acceso privado, que crea una instancia de un objeto de la clase PrivateObject. La clase PrivateObject es una clase contenedora que utiliza la reflexión como parte del proceso de descriptor de acceso privado. La clase PrivateType es similar, pero se utiliza para llamar a métodos estáticos privados en lugar de llamar a métodos de instancia privados.

Vea también