Testen von Organisation und Metadaten in MSTest

MSTest stellt Attribute zum Organisieren von Tests, zum Hinzufügen von Metadaten und zum Verknüpfen von Tests mit Arbeitsverfolgungssystemen bereit. Diese Attribute helfen Ihnen, Tests effektiv in großen Testsammlungen zu filtern, zu sortieren und zu verwalten.

Überblick

Metadatenattribute werden im Visual Studio-Eigenschaftenfenster für Testmethoden angezeigt. Sie helfen Ihnen bei:

• Organisieren von Tests: Gruppieren Sie Tests nach Kategorie, Priorität oder Besitzer.
• Filtertestausführung: Ausführen bestimmter Teilmengen von Tests basierend auf Metadaten.
• Nachverfolgen der Testabdeckung: Verknüpfen von Tests mit Arbeitsaufgaben und Anforderungen.
• Berichte generieren: Fügen Sie Metadaten in Testberichte und Dashboards ein.

Testkategorisierung

TestCategoryAttribute

Die TestCategoryAttribute gruppiert Tests in Kategorien für die Filterung und Organisation. Sie können dieses Attribut auf Methoden-, Klassen- oder Assemblyebene anwenden, und Kategorien werden kombiniert, wenn sie auf mehreren Ebenen angewendet werden.

Kategorien auf Methodenebene

Wenden Sie Kategorien direkt auf Testmethoden für feinkörnige Kontrolle an:

[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
    }
}

Kategorien auf Klassenebene

Wenden Sie eine Kategorie auf eine Testklasse an, um diese Kategorie allen Testmethoden innerhalb der Klasse zuzuweisen:

[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
    }
}

Kategorien auf Assemblyebene

Wenden Sie eine Kategorie auf Assemblyebene an, um alle Tests in der gesamten Testassembly zu kategorisieren. Dieser Ansatz eignet sich für die Unterscheidung von Testtypen in verschiedenen Projekten:

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

[assembly: TestCategory("E2E")]

Verwenden Sie Kategorien auf Assemblyebene, um Ihre Testprojekte nach Testtyp zu organisieren:

Projekt	Baugruppenkategorie	Zweck
MyApp.UnitTests	Unit	Schnelle, isolierte Komponententests
MyApp.IntegrationTests	Integration	Tests mit externen Abhängigkeiten
MyApp.E2ETests	E2E	End-to-End-Szenariotests

Filtern von Tests nach Kategorie

Ausführen von Tests nach Kategorie mithilfe des dotnet test Befehls:

# 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

Verwenden Sie im Test-Explorer von Visual Studio das Suchfeld mit Trait: dem Präfix:

• Trait:"TestCategory=Integration" - zeigt Integrationstests an
• -Trait:"TestCategory=Slow" - schließt langsame Tests aus

TestPropertyAttribute

Der TestPropertyAttribute fügt benutzerdefinierte Schlüssel-Werte-Metadaten zu Tests hinzu. Verwenden Sie dieses Attribut, wenn integrierte Attribute nicht Ihren Anforderungen entsprechen.

[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
    }
}

Eigenschaften werden im Visual Studio-Eigenschaftenfenster unter "Testspezifisch" angezeigt.

Filtern nach benutzerdefinierten Eigenschaften

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

Testbesitz und Priorität

OwnerAttribute

OwnerAttribute identifiziert, wer für einen Test verantwortlich ist.

[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
    }
}

Filtertests nach Besitzer:

dotnet test --filter Owner=jsmith

PriorityAttribute

Dies PriorityAttribute gibt die relative Test-Wichtigkeit an. Niedrigere Werte weisen auf eine höhere Priorität hin.

[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
    }
}

Filtertests nach Priorität:

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

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

DescriptionAttribute

Der DescriptionAttribute bietet eine für Menschen lesbare Beschreibung dessen, was der Test überprüft.

Warnung

Verwenden Sie Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute, nicht System.ComponentModel.DescriptionAttribute. Der MSTEST0031 Analyzer erkennt falsche Verwendung.

[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
    }
}

Arbeitselementverfolgung

WorkItemAttribute

Die WorkItemAttribute verknüpfen Tests mit Arbeitselementen in Ihrem Tracking-System (z. B. 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

Die GitHubWorkItemAttribute verknüpft Tests mit GitHub-Issues.

[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
    }
}

Arbeitsaufgabenattribute sind besonders nützlich, wenn sie mit Ignore:

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

Kombinieren von Attributen

Kombinieren mehrerer Metadatenattribute für umfassende Testorganisation:

[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
    }
}

Bewährte Methoden

1. Verwenden Sie konsistente Kategorien: Legen Sie Benennungskonventionen für Testkategorien in Ihrem Projekt fest.

2. Legen Sie strategische Prioritäten fest: Reservieren Sie Priority(0) für kritische Pfadtests, die bestanden werden müssen, damit ein funktionsfähiger Build erreicht wird.

3. Verknüpfung mit Arbeitsaufgaben: Verknüpfen Sie Immer Tests mit verwandten Arbeitselementen zur Rückverfolgbarkeit, insbesondere Fehlerregressionstests.

4. Dokumenttestzweck: Wird für komplexe Tests verwendet Description , bei denen der Methodenname die Absicht nicht vollständig erklärt.

5. Halten Sie Metadaten aktuell: Aktualisieren Sie Metadaten, wenn sich der Testbereich oder der Besitz ändert.

6. Verwenden Sie Kategorien zum Filtern: Designkategorien zur Unterstützung Ihrer CI/CD-Pipelineanforderungen (z. B. "Smoke", "Nightly", "Integration").

Filtertests

Befehlszeilenfilterung

# 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"

Visual Studio Test Explorer

Verwenden Sie das Suchfeld im Test-Explorer:

• Trait:"TestCategory=Integration" - nach Kategorie filtern
• Trait:"Owner=jsmith" - nach Besitzer filtern
• Trait:"Priority=0" - nach Priorität filtern

Weitere Informationen zur Testfilterung finden Sie unter Ausführen von selektiven Komponententests.

Siehe auch

• Ausführen von selektiven Komponententests
• Schreiben von Tests in MSTest
• Testen der Ausführung und Kontrolle
• MSTEST0015: Testmethode sollte nicht ignoriert werden
• MSTEST0031: Verwenden Sie "System.ComponentModel.DescriptionAttribute" nicht.