Compartir a través de

Atributos de MSTest

  • Artículo

MSTest usa atributos personalizados para identificar y personalizar pruebas.

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

Nota:

Los atributos, cuyos nombres terminan con "Attribute", se pueden utilizar con o sin "Attribute" al final. Los atributos que tienen constructor sin parámetros se pueden escribir con o sin paréntesis. Los ejemplos de código siguientes 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.

TestClassAttribute

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

Este atributo se puede extender para cambiar o ampliar el comportamiento predeterminado.

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 public definido como void, Task o ValueTask (a partir de MSTest v3.3). Opcionalmente, puede ser async, pero no debe ser async void.

El método debe tener cero parámetros, a menos que se use con [DataRow], [DynamicData] o un atributo similar que proporcione datos de casos de prueba al método de prueba.

Considere la siguiente clase de prueba de ejemplo:

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

Atributos usados para pruebas controladas por datos

Use los siguientes elementos para configurar pruebas 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.

DataRowAttribute

El DataRowAttribute permite ejecutar el mismo método de prueba con varias entradas diferentes. Puede aparecer una o varias veces en un método de prueba. Debe combinarse con TestMethodAttribute.

El número y los tipos de argumentos deben coincidir exactamente con la signatura del método de prueba. Considere el siguiente ejemplo de una clase de prueba válida que muestra el uso de atributos DataRow con argumentos insertados que se alinean con los parámetros del método de prueba:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, "message", true, 2.0)]
    public void TestMethod1(int i, string s, bool b, float f)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" })]
    public void TestMethod2(string[] lines)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(null)]
    public void TestMethod3(object o)
    {
        // Omitted for brevity.
    }

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

Nota:

También puede usar la característica params para capturar varias entradas del 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

La configuración y la limpieza que son comunes a varias pruebas se pueden extraer en un método independiente y marcarse con uno de los atributos que se enumeran a continuación, para ejecutarlo en el momento adecuado, por ejemplo, antes de cada prueba. Para obtener más información, vea Estructura de una prueba unitaria.

Nivel de ensamblado

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, static Task o static ValueTask (a partir de MSTest v3.3), en un TestClass y solo aparecen una vez. La parte de inicialización requiere un parámetro de tipo TestContext, y la limpieza puede no tener parámetros, o a partir de MSTest 3.8, puede tener un parámetro de tipo TestContext.

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

    [AssemblyCleanup]
    public static void AssemblyCleanup() // Starting with MSTest 3.8, it can be AssemblyCleanup(TestContext testContext)
    {
    }
}

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

    [AssemblyCleanup]
    public static async Task AssemblyCleanup() // Starting with MSTest 3.8, it can be AssemblyCleanup(TestContext testContext)
    {
    }
}

Nivel de 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 clases debe ejecutarse al final de la clase o al final del ensamblado.

Los métodos marcados con estos atributos deben definirse como static void, static Task o static ValueTask (a partir de MSTest v3.3), en un TestClass y solo aparecen una vez. La parte de inicialización requiere un parámetro de tipo TestContext, y la limpieza puede no tener parámetros, o a partir de MSTest 3.8, puede tener un parámetro de tipo TestContext.

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

    [ClassCleanup]
    public static void ClassCleanup() // Starting with MSTest 3.8, it can be ClassCleanup(TestContext testContext)
    {
    }
}

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

    [ClassCleanup]
    public static async Task ClassCleanup() // Starting with MSTest 3.8, it can be ClassCleanup(TestContext testContext)
    {
    }
}

Nivel de 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, Task o ValueTask (a partir de MSTest v3.3), en un TestClass, sin parámetros y aparecen 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()
    {
    }
}

Atributos usados para controlar la ejecución de pruebas

Los siguientes atributos se pueden usar para modificar la forma en que se ejecutan las pruebas.

TimeoutAttribute

El atributo Timeout se puede usar para especificar el tiempo máximo en milisegundos que se permite ejecutar un método de prueba. Si el método de prueba se ejecuta durante más tiempo del especificado, la prueba se cancelará y se marcará como fallida.

Este atributo se puede aplicar a cualquier método de prueba o a cualquier método de accesorio (métodos de inicialización y limpieza). También es posible especificar el tiempo de espera global para todos los métodos de prueba o todos los métodos de accesorio de prueba mediante las propiedades de tiempo de espera del archivo runsettings.

Nota:

No se garantiza que el tiempo de espera sea preciso. La prueba se anulará después de que haya transcurrido el tiempo especificado, pero puede tardar unos milisegundos más.

Al usar la característica de tiempo de expiración, se crea un subproceso o tarea independiente para ejecutar el método de prueba. El subproceso o tarea principal es responsable de supervisar el tiempo de expiración y desobservar el subproceso o tarea del método si se alcanza el tiempo de expiración.

A partir de MSTest 3.6, es posible especificar la propiedad CooperativeCancellation en el atributo (o globalmente a través de runsettings) para habilitar la cancelación cooperativa. En este modo, el método es responsable de comprobar el token de cancelación y anular la prueba si se señala como lo haría en un método async típico. Este modo es más eficaz y permite un control más preciso sobre el proceso de cancelación. Este modo se puede aplicar a métodos asincrónicos y sincrónicos.

STATestClassAttribute

Cuando se aplica a una clase de prueba, el atributo [STATestClass] indica que todos los métodos de prueba (y los métodos [ClassInitialize] y [ClassCleanup] ) de la clase deben ejecutarse en un apartamento de un solo subproceso (STA). Este atributo es útil cuando los métodos de prueba interactúan con objetos COM que requieren STA.

Nota:

Esto solo es compatible con Windows y en la versión 3.6 y posteriores.

STATestMethodAttribute

Cuando se aplica a un método de prueba, el atributo [STATestMethod] indica que el método de prueba debe ejecutarse en un apartamento de un solo subproceso (STA). Este atributo es útil cuando el método de prueba interactúa con objetos COM que requieren STA.

Nota:

Esto solo es compatible con Windows y en la versión 3.6 y posteriores.

ParallelizeAttribute

De forma predeterminada, MSTest ejecuta pruebas en un orden secuencial. El atributo Parallelize se puede usar para ejecutar pruebas en paralelo. Se trata de un atributo de nivel de ensamblado. Puede especificar si el paralelismo debe estar a nivel de clase (se pueden ejecutar varias clases en paralelo, pero las pruebas de una clase determinada se ejecutan secuencialmente) o a nivel de método.

También es posible especificar el número máximo de subprocesos que se usarán para la ejecución en paralelo. Un valor de 0 (valor predeterminado) significa que el número de subprocesos es igual al número de procesadores lógicos en la máquina.

También es posible especificar el paralelismo a través de las propiedades de paralelización del archivo runsettings.

DoNotParallelizeAttribute

El atributo DoNotParallelize se puede usar para evitar la ejecución paralela de pruebas en un ensamblado determinado. Este atributo se puede aplicar a nivel de ensamblado, a nivel de clase o a nivel de método.

Nota:

De forma predeterminada, MSTest ejecuta pruebas en orden secuencial, por lo que solo debe usar este atributo si ha aplicado el atributo [Parallelize] a nivel de ensamblado.

RetryAttribute

El RetryAttribute se introdujo en MSTest 3.8. Este atributo hace que el método de prueba se vuelva a intentar cuando se produzca un error o se supere el tiempo de espera. Permite especificar el número máximo de intentos de repetición, el intervalo de tiempo entre intentos y un tipo de aumento del retraso, que puede ser constante o exponencial.

Solo se espera que haya una RetryAttribute presente en un método de prueba y RetryAttribute no se puede usar en métodos que no estén marcados con TestMethodAttribute.

Nota:

RetryAttribute deriva de un RetryBaseAttributeabstracto. También puede crear sus propias implementaciones de reintento si el RetryAttribute incorporado no se ajusta a sus necesidades.

Atributos de utilidades

DeploymentItemAttribute

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

Advertencia

No se recomienda el uso de este atributo para copiar archivos en el directorio de implementación.

ExpectedExceptionAttribute

El marco MSTest introdujo ExpectedExceptionAttribute para marcar un método de prueba para esperar una excepción de un tipo específico. La prueba pasará si se produce la excepción esperada y el mensaje de excepción coincide con el mensaje esperado.

Advertencia

Este atributo existe para la compatibilidad con versiones anteriores y no se recomienda para las nuevas pruebas. En su lugar, use el método Assert.ThrowsException (o Assert.ThrowsExactly si usa MSTest 3.8 y versiones posteriores).

Atributos de metadatos

Los siguientes atributos y los valores asignados a ellos aparecen en la ventana Visual Studio de 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. En su lugar, afectan a las formas en que se usa o ejecuta la prueba, 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.

Por ejemplo, se puede utilizar para almacenar el nombre de una prueba superada que cubre esta prueba, marcando la prueba con [TestProperty("Feature", "Accessibility")]. O se puede utilizar para almacenar un indicador del tipo de prueba que es con [TestProperty("ProductMilestone", "42")]. 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.

Los siguientes atributos 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: