Prueba de la organización y los metadatos en MSTest

MSTest proporciona atributos para organizar pruebas, agregar metadatos y vincular pruebas a sistemas de seguimiento de trabajo. Estos atributos le ayudan a filtrar, ordenar y administrar pruebas de forma eficaz en conjuntos de pruebas de gran tamaño.

Información general

Los atributos de metadatos aparecen en la ventana Propiedades de Visual Studio para los métodos de prueba. Te ayudan a:

• Organizar pruebas: agrupa las pruebas por categoría, prioridad o propietario.
• Filtrar ejecuciones de pruebas: ejecute subconjuntos específicos de pruebas en función de los metadatos.
• Seguimiento de la cobertura de pruebas: vincule las pruebas a los elementos de trabajo y los requisitos.
• Generar informes: incluya metadatos en informes y paneles de prueba.

Categorización de pruebas

TestCategoryAttribute

Agrupa TestCategoryAttribute las pruebas en categorías para el filtrado y la organización. Puede aplicar este atributo en el nivel de método, clase o ensamblado, y las categorías se combinan cuando se aplican en varios niveles.

Categorías a nivel de método

Aplique categorías directamente a los métodos de prueba para el control específico:

[TestClass]
public class OrderTests
{
    [TestMethod]
    [TestCategory("Integration")]
    public void CreateOrder_SavesOrderToDatabase()
    {
        // Integration test
    }

    [TestMethod]
    [TestCategory("Unit")]
    public void CalculateTotal_ReturnsSumOfItems()
    {
        // Unit test
    }

    [TestMethod]
    [TestCategory("Integration")]
    [TestCategory("Slow")]
    public void ProcessLargeOrder_CompletesSuccessfully()
    {
        // Multiple categories allowed
    }
}

Categorías de nivel de clase

Aplique una categoría a una clase de prueba para asignar esa categoría a todos los métodos de prueba dentro de la clase :

[TestClass]
[TestCategory("Payments")]
public class PaymentServiceTests
{
    [TestMethod]
    public void ProcessPayment_ValidCard_Succeeds()
    {
        // Inherits "Payments" category from class
    }

    [TestMethod]
    [TestCategory("Slow")]
    public void ProcessBatchPayments_LargeVolume_CompletesSuccessfully()
    {
        // Has both "Payments" (from class) and "Slow" (from method) categories
    }
}

Categorías de nivel de ensamblaje

Aplique una categoría en el nivel de ensamblado para clasificar todas las pruebas en todo el ensamblado de prueba. Este enfoque es útil para distinguir los tipos de prueba entre proyectos:

// In AssemblyInfo.cs or any file in your test project
using Microsoft.VisualStudio.TestTools.UnitTesting;

[assembly: TestCategory("E2E")]

Use categorías de nivel de ensamblado para organizar los proyectos de prueba por tipo de prueba:

Proyecto	Categoría de ensamblado	Propósito
MyApp.UnitTests	Unit	Pruebas unitarias rápidas y aisladas
MyApp.IntegrationTests	Integration	Pruebas con dependencias externas
MyApp.E2ETests	E2E	Pruebas de escenario de extremo a extremo

Filtrar pruebas por categoría

Ejecute pruebas por categoría mediante el dotnet test comando :

# Run only integration tests
dotnet test --filter TestCategory=Integration

# Run tests in multiple categories
dotnet test --filter "TestCategory=Integration|TestCategory=Unit"

# Exclude slow tests
dotnet test --filter TestCategory!=Slow

En el Explorador de pruebas de Visual Studio, use el cuadro de búsqueda con Trait: prefijo:

• Trait:"TestCategory=Integration" : muestra las pruebas de integración.
• -Trait:"TestCategory=Slow" : excluye las pruebas lentas.

TestPropertyAttribute

TestPropertyAttribute agrega metadatos de clave-valor personalizados a las pruebas. Use este atributo cuando los atributos integrados no satisfagan sus necesidades.

[TestClass]
public class CustomMetadataTests
{
    [TestMethod]
    [TestProperty("Feature", "Authentication")]
    [TestProperty("Sprint", "23")]
    [TestProperty("RiskLevel", "High")]
    public void Login_WithValidCredentials_Succeeds()
    {
        // Test with custom properties
    }

    [TestMethod]
    [TestProperty("Feature", "Authorization")]
    [TestProperty("RequirementId", "REQ-AUTH-001")]
    public void AccessAdminPage_RequiresAdminRole()
    {
        // Link to requirements
    }
}

Las propiedades aparecen en la ventana Propiedades de Visual Studio en Prueba específica.

Filtrar por propiedades personalizadas

# Filter by custom property
dotnet test --filter "Feature=Authentication"

Propiedad y prioridad del test

OwnerAttribute

OwnerAttribute identifica quién es responsable de una prueba.

[TestClass]
public class PaymentTests
{
    [TestMethod]
    [Owner("jsmith")]
    public void ProcessPayment_ChargesCorrectAmount()
    {
        // John Smith owns this test
    }

    [TestMethod]
    [Owner("team-payments")]
    public void RefundPayment_CreditsCustomerAccount()
    {
        // Team responsibility
    }
}

Filtre las pruebas por propietario:

dotnet test --filter Owner=jsmith

PriorityAttribute

PriorityAttribute indica la importancia de la prueba relativa. Los valores más bajos indican una mayor prioridad.

[TestClass]
public class CriticalPathTests
{
    [TestMethod]
    [Priority(0)]
    public void Login_IsAlwaysAvailable()
    {
        // Highest priority - core functionality
    }

    [TestMethod]
    [Priority(1)]
    public void CreateAccount_WorksCorrectly()
    {
        // High priority
    }

    [TestMethod]
    [Priority(2)]
    public void CustomizeProfile_SavesPreferences()
    {
        // Medium priority
    }
}

Filtre las pruebas por prioridad:

# Run only highest priority tests
dotnet test --filter Priority=0

# Run high priority or higher
dotnet test --filter "Priority=0|Priority=1"

DescriptionAttribute

DescriptionAttribute proporciona una descripción legible de lo que comprueba la prueba.

Advertencia

Use Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute, no System.ComponentModel.DescriptionAttribute. El analizador de MSTEST0031 detecta un uso incorrecto.

[TestClass]
public class DocumentedTests
{
    [TestMethod]
    [Description("Verifies that orders over $100 receive a 10% discount")]
    public void ApplyDiscount_LargeOrder_Gets10PercentOff()
    {
        // Test implementation
    }

    [TestMethod]
    [Description("Ensures email validation rejects malformed addresses")]
    public void ValidateEmail_InvalidFormat_ReturnsFalse()
    {
        // Test implementation
    }
}

Seguimiento de elementos de trabajo

WorkItemAttribute

Vincula WorkItemAttribute las pruebas a los elementos de trabajo del sistema de seguimiento (como Azure DevOps).

[TestClass]
public class BugFixTests
{
    [TestMethod]
    [WorkItem(12345)]
    [Description("Regression test for bug #12345")]
    public void DatePicker_LeapYear_HandlesFebruary29()
    {
        // Test that verifies the bug fix
    }

    [TestMethod]
    [WorkItem(67890)]
    [WorkItem(67891)]  // Can link multiple work items
    public void Export_LargeDataset_CompletesWithinTimeout()
    {
        // Test related to multiple work items
    }
}

GitHubWorkItemAttribute

Vincula GitHubWorkItemAttribute las pruebas a problemas de GitHub.

[TestClass]
public class GitHubLinkedTests
{
    [TestMethod]
    [GitHubWorkItem("https://github.com/myorg/myrepo/issues/42")]
    public void FeatureX_WorksAsExpected()
    {
        // Test linked to GitHub issue #42
    }

    [TestMethod]
    [GitHubWorkItem("https://github.com/myorg/myrepo/issues/100")]
    [Ignore("Waiting for upstream fix")]
    public void DependentFeature_RequiresUpdate()
    {
        // Ignored test linked to tracking issue
    }
}

Los atributos del elemento de trabajo son especialmente valiosos cuando se combinan con Ignore:

[TestMethod]
[Ignore("Known issue, tracked in work item")]
[WorkItem(99999)]
public void KnownIssue_AwaitingFix()
{
    // Provides traceability for why the test is ignored
}

Combinación de atributos

Combine varios atributos de metadatos para una organización de prueba completa:

[TestClass]
public class FullyDocumentedTests
{
    [TestMethod]
    [TestCategory("Integration")]
    [TestCategory("API")]
    [Owner("payment-team")]
    [Priority(1)]
    [Description("Verifies that the payment API returns correct error codes for invalid requests")]
    [WorkItem(54321)]
    [TestProperty("Sprint", "24")]
    [TestProperty("Feature", "ErrorHandling")]
    public void PaymentAPI_InvalidRequest_ReturnsAppropriateErrorCode()
    {
        // Well-documented test with full traceability
    }
}

procedimientos recomendados

1. Usar categorías coherentes: establezca convenciones de nomenclatura para categorías de prueba en el proyecto.

2. Establecer prioridades estratégicamente: reserve Priority(0) para pruebas críticas de ruta de acceso que deben superarse para una compilación viable.

3. Vínculo a elementos de trabajo: vincule siempre las pruebas a los elementos de trabajo relacionados para la rastreabilidad, especialmente las pruebas de regresión de errores.

4. Propósito de la prueba del documento: se usa Description para pruebas complejas en las que el nombre del método no explica completamente la intención.

5. Mantener actualizados los metadatos: actualice los metadatos cuando cambie el ámbito de prueba o la propiedad.

6. Usar categorías para filtrar: Diseña categorías para satisfacer las necesidades de la canalización de CI/CD (por ejemplo, "Smoke", "Nightly", "Integration").

Filtrado de pruebas

Filtrado de línea de comandos

# Filter by category
dotnet test --filter TestCategory=Unit

# Filter by owner
dotnet test --filter Owner=jsmith

# Filter by priority
dotnet test --filter Priority=0

# Combine filters (AND)
dotnet test --filter "TestCategory=Integration&Priority=0"

# Combine filters (OR)
dotnet test --filter "TestCategory=Smoke|TestCategory=Critical"

# Exclude by filter
dotnet test --filter TestCategory!=Slow

# Filter by custom property
dotnet test --filter "Feature=Payments"

Explorador de pruebas de Visual Studio

Use el cuadro de búsqueda en el Explorador de pruebas:

• Trait:"TestCategory=Integration" - filtrar por categoría
• Trait:"Owner=jsmith" - filtrar por propietario
• Trait:"Priority=0" - filtrar por prioridad

Para obtener más información sobre el filtrado de pruebas, consulte Ejecución de pruebas unitarias selectivas.

Consulte también

• Ejecución de pruebas unitarias selectivas
• Escritura de pruebas en MSTest
• Ejecución y control de pruebas
• MSTEST0015: No se debe omitir el método de prueba
• MSTEST0031: No usar System.ComponentModel.DescriptionAttribute