Testa organisation och metadata i MSTest

MSTest tillhandahåller attribut för att organisera tester, lägga till metadata och länka tester till arbetsspårningssystem. De här attributen hjälper dig att filtrera, sortera och hantera tester effektivt i stora testsviter.

Översikt

Metadataattribut visas i fönstret Egenskaper för Visual Studio för testmetoder. De hjälper dig:

Organisera tester: Gruppera tester efter kategori, prioritet eller ägare.
Filtertestkörningar: Kör specifika delmängder av tester baserat på metadata.
Spåra testtäckning: Länka tester till arbetsobjekt och krav.
Generera rapporter: Inkludera metadata i testrapporter och instrumentpaneler.

Testkategorisering

`TestCategoryAttribute`

Grupperna TestCategoryAttribute testar i kategorier för filtrering och organisation. Du kan använda det här attributet på metod-, klass- eller sammansättningsnivå och kategorier kombineras när det tillämpas på flera nivåer.

Kategorier på metodnivå

Tillämpa kategorier direkt på testmetoder för detaljerad kontroll:

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

Kategorier på klassnivå

Tillämpa en kategori på en testklass för att tilldela den kategorin till alla testmetoder i klassen:

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

Kategorier på sammansättningsnivå

Använd en kategori på sammansättningsnivå för att kategorisera alla tester i hela testsammansättningen. Den här metoden är användbar för att särskilja testtyper mellan projekt:

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

[assembly: TestCategory("E2E")]

Använd kategorier på sammansättningsnivå för att organisera dina testprojekt efter testtyp:

Projekt	Sammansättningskategori	Avsikt
`MyApp.UnitTests`	`Unit`	Snabba, isolerade enhetstester
`MyApp.IntegrationTests`	`Integration`	Tester med externa beroenden
`MyApp.E2ETests`	`E2E`	Test av ända-till-ända scenarier

Filtrera tester efter kategori

Kör tester efter kategori med kommandot dotnet test :

# 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

I Visual Studio Test Explorer använder du sökrutan med Trait: prefixet:

Trait:"TestCategory=Integration" – visar integreringstester
-Trait:"TestCategory=Slow" – exkluderar långsamma tester

`TestPropertyAttribute`

TestPropertyAttribute Lägger till anpassade nyckel/värde-metadata i tester. Använd det här attributet när inbyggda attribut inte uppfyller dina behov.

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

Egenskaper visas i fönstret Egenskaper för Visual Studio under Testspecifikt.

Filtrera efter anpassade egenskaper

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

Testa ägarskap och prioritet

`OwnerAttribute`

Identifierar OwnerAttribute vem som är ansvarig för ett test.

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

Filtrera tester efter ägare:

dotnet test --filter Owner=jsmith

`PriorityAttribute`

PriorityAttribute Indikerar relativ testviktighet. Lägre värden anger högre prioritet.

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

Filtrera tester efter prioritet:

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

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

`DescriptionAttribute`

DescriptionAttribute ger en mänskligt läsbar beskrivning av vad testet verifierar.

Varning

Använd Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute, inte System.ComponentModel.DescriptionAttribute. MSTEST0031 analyseraren identifierar felaktig användning.

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

Spårning av arbetsobjekt

`WorkItemAttribute`

WorkItemAttribute länkar tester till arbetsobjekt i ditt spårningssystem (till exempel 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`

GitHubWorkItemAttribute länkar tester till GitHub-ärenden.

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

Attribut för arbetsobjekt är särskilt värdefulla när de kombineras med Ignore:

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

Kombinera attribut

Kombinera flera metadataattribut för omfattande 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
    }
}

Metodtips

Använd konsekventa kategorier: Upprätta namngivningskonventioner för testkategorier i projektet.
Ange prioriteringar strategiskt: Reservera Priority(0) för kritiska sökvägstester som måste godkännas för en fungerande version.
Länk till arbetsobjekt: Länka alltid tester till relaterade arbetsobjekt för spårning, särskilt felregressionstester.
Dokumenttestsyfte: Använd Description för komplexa tester där metodnamnet inte helt förklarar avsikten.
Håll metadata aktuella: Uppdatera metadata när testomfånget eller ägarskapet ändras.
Använd kategorier för filtrering: Designkategorier för att stödja dina CI/CD-pipelinebehov (till exempel "Smoke", "Nightly", "Integration").

Filtreringstester

Kommandoradsfiltrering

# 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

Använd sökrutan i Test Explorer:

Trait:"TestCategory=Integration" – filtrera efter kategori
Trait:"Owner=jsmith" – filtrera efter ägare
Trait:"Priority=0" – filtrera efter prioritet

Mer information om testfiltrering finns i Köra selektiva enhetstester.

Se även

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-02-09