Sdílet prostřednictvím

Vytvoření testovací architektury

Tento článek vysvětluje, jak vytvořit vlastní testovací rozhraní pro Microsoft.Testing.Platform. Testovací architektura je jediné povinné rozšíření. Zjišťuje a spouští testy a hlásí výsledky zpět na platformu.

Úplný souhrn bodů rozšíření a koncepty in-process/out-of-process najdete v tématu Vytváření vlastních rozšíření.

Pokud migrujete existující testovací rámec založený na VSTest, doporučuje se nativní implementace rozhraní ITestFramework. Rozšíření VSTest Bridge je k dispozici jako přechodný krok, ale nativní implementace poskytuje nejlepší prostředí.

Rozšíření testovací architektury

Testovací architektura je primární rozšíření, které poskytuje testovací platformu s možností zjišťovat a spouštět testy. Testovací architektura zodpovídá za předávání výsledků testů zpět testovací platformě. Testovací rámec je jediné povinné rozšíření potřebné k provedení testovací relace.

Registrace testovací architektury

Tato část vysvětluje, jak zaregistrovat testovací architekturu s testovací platformou. Zaregistrujete pouze jednu testovací architekturu pro tvůrce testovacích aplikací pomocí TestApplication.RegisterTestFramework rozhraní API, jak je znázorněno v dokumentaci k architektuře Microsoft.Testing.Platform .

Registrační rozhraní API je definováno takto:

ITestApplicationBuilder RegisterTestFramework(
    Func<IServiceProvider, ITestFrameworkCapabilities> capabilitiesFactory,
    Func<ITestFrameworkCapabilities, IServiceProvider, ITestFramework> adapterFactory);

Rozhraní API RegisterTestFramework očekává dva výrobce:

  1. Func<IServiceProvider, ITestFrameworkCapabilities>: Toto je delegát, který přijímá objekt, který implementuje rozhraní IServiceProvider, a vrací objekt, který implementuje rozhraní ITestFrameworkCapabilities. IServiceProvider poskytuje přístup ke službám platformy, jako jsou konfigurace, protokolovací nástroje a argumenty příkazového řádku.

    Rozhraní ITestFrameworkCapabilities slouží k oznámení možností podporovaných testovací architekturou pro platformu a rozšíření. Umožňuje, aby platforma a rozšíření správně pracovaly implementací a podporou konkrétních chování. Pokud chcete lépe porozumět koncepci schopností, přečtěte si příslušnou část.

  2. Func<ITestFrameworkCapabilities, IServiceProvider, ITestFramework>: Jedná se o delegáta, který přebírá objekt ITestFrameworkCapabilities, což je instance vrácená Func<IServiceProvider, ITestFrameworkCapabilities>, a objekt IServiceProvider, aby znovu poskytoval přístup ke službám platformy. Očekávaný návratový objekt je ten, který implementuje ITestFramework rozhraní. ITestFramework slouží jako spouštěcí modul, který zjišťuje a spouští testy, a výsledky pak předává zpět testovací platformě.

Potřeba platformy oddělit tvorbu ITestFrameworkCapabilities a tvorbu ITestFramework představuje optimalizaci pro zabránění vzniku testovacího rámce, pokud podporované funkce nedostačují ke spuštění aktuální testovací relace.

Představte si následující příklad uživatelského kódu, který ukazuje registraci testovací architektury, která vrací prázdnou sadu funkcí:

internal class TestingFrameworkCapabilities : ITestFrameworkCapabilities
{
    public IReadOnlyCollection<ITestFrameworkCapability> Capabilities => [];
}

internal class TestingFramework : ITestFramework
{
   public TestingFramework(ITestFrameworkCapabilities capabilities, IServiceProvider serviceProvider)
   {
       // ...
   }
   // Omitted for brevity...
}

public static class TestingFrameworkExtensions
{
    public static void AddTestingFramework(this ITestApplicationBuilder builder)
    {
        builder.RegisterTestFramework(
            _ => new TestingFrameworkCapabilities(),
            (capabilities, serviceProvider) => new TestingFramework(capabilities, serviceProvider));
    }
}

// ...

Teď zvažte odpovídající vstupní bod tohoto příkladu s registračním kódem:

var testApplicationBuilder = await TestApplication.CreateBuilderAsync(args);
// Register the testing framework
testApplicationBuilder.AddTestingFramework();
using var testApplication = await testApplicationBuilder.BuildAsync();
return await testApplication.RunAsync();

Poznámka:

Vrácení prázdných hodnot pro ITestFrameworkCapabilities by nemělo bránit spuštění testovací relace. Všechny testovací architektury by měly být schopné zjišťovat a spouštět testy. Dopad by měl být omezen na rozšíření, která se mohou odhlásit, pokud testovací architektura nemá určitou funkci.

Vytvoření testovací architektury

Microsoft.Testing.Platform.Extensions.TestFramework.ITestFramework je realizováno rozšířeními, která poskytují testovací rámec.

public interface ITestFramework : IExtension
{
    Task<CreateTestSessionResult> CreateTestSessionAsync(CreateTestSessionContext context);
    Task ExecuteRequestAsync(ExecuteRequestContext context);
    Task<CloseTestSessionResult> CloseTestSessionAsync(CloseTestSessionContext context);
}

Rozhraní IExtension

Rozhraní ITestFramework dědí z IExtension rozhraní, což je rozhraní, ze kterého dědí všechny rozšiřující body. IExtension slouží k načtení názvu a popisu rozšíření. IExtension také poskytuje způsob dynamického povolení nebo zakázání rozšíření v nastavení prostřednictvím Task<bool> IsEnabledAsync(). Nemáte-li konkrétní požadavky na jeho zakázání, ujistěte se, že tato metoda vrací true.

Metoda CreateTestSessionAsync

Metoda CreateTestSessionAsync se volá na začátku testovací relace a slouží k inicializaci testovací architektury. Rozhraní API přijme objekt CreateTestSessionContext a vrátí CreateTestSessionResult.

public sealed class CreateTestSessionContext : TestSessionContext
{
    public CancellationToken CancellationToken { get; }
}

Vlastnost SessionUid je zděděna od TestSessionContext (viz část TestSessionContext). CancellationToken slouží k zastavení provádění CreateTestSessionAsync.

Návratový objekt je CreateTestSessionResult:

public sealed class CreateTestSessionResult
{
    public string? WarningMessage { get; set; }
    public string? ErrorMessage { get; set; }
    public bool IsSuccess { get; set; }
}

Vlastnost IsSuccess slouží k označení, zda bylo vytvoření relace úspěšné. Když se vrátí false, testovací spuštění se zastaví.

Metoda CloseTestSessionAsync

Metoda CloseTestSessionAsync je juxtaposedována na CreateTestSessionAsync ve funkcích, přičemž jediným rozdílem jsou názvy objektů. Další informace najdete v části CreateTestSessionAsync.

Metoda ExecuteRequestAsync

Metoda ExecuteRequestAsync přijímá objekt typu ExecuteRequestContext. Tento objekt, jak navrhuje jeho název, obsahuje podrobnosti o akci, kterou má testovací architektura provést. Definice ExecuteRequestContext je:

public sealed class ExecuteRequestContext
{
    public IRequest Request { get; }
    public IMessageBus MessageBus { get; }
    public CancellationToken CancellationToken { get; }
    public void Complete();
}

IRequest: Toto je základní rozhraní pro jakýkoli typ požadavku. O testovacím rozhraní byste měli uvažovat jako o stavovém serveru v procesu, kde je životní cyklus:

sekvenční diagram představující životní cyklus testovací architektury.

Předchozí diagram znázorňuje, že testovací platforma vydává tři požadavky po vytvoření instance testovací architektury. Testovací architektura tyto požadavky zpracuje a využívá službu IMessageBus, která je součástí samotného požadavku, k doručení výsledku pro každý konkrétní požadavek. Jakmile se zpracuje konkrétní požadavek, testovací architektura na něm vyvolá metodu Complete(), která označuje testovací platformu, že požadavek byl splněn. Testovací platforma monitoruje všechny odeslané požadavky. Jakmile budou splněny všechny požadavky, vyvolá CloseTestSessionAsync a odstraní instanci (pokud je implementovaná IDisposable/IAsyncDisposable). Je zřejmé, že požadavky a jejich dokončení se můžou překrývat, což umožňuje souběžné a asynchronní provádění požadavků.

Poznámka:

Testovací platforma v současné době neodesílá překrývající se požadavky a čeká na dokončení požadavku >> před odesláním další. Toto chování se ale může v budoucnu změnit. Podpora souběžných požadavků se určí prostřednictvím systému možností .

Implementace IRequest určuje přesnou žádost, kterou je potřeba splnit. Testovací architektura identifikuje typ požadavku a odpovídajícím způsobem ji zpracuje. Pokud typ požadavku není rozpoznán, měla by být vyvolána výjimka.

Podrobnosti o dostupných požadavcích najdete v části IRequest.

IMessageBus: Tato služba vázaná s požadavkem umožňuje testovacímu rozhraní asynchronně publikovat informace o probíhajícím požadavku na testovací platformu. Sběrnice zpráv slouží jako centrální centrum pro platformu, což usnadňuje asynchronní komunikaci mezi všemi komponentami a rozšířeními platformy. Úplný seznam informací, které lze publikovat na testovací platformě, najdete v části IMessageBus.

CancellationToken: Tento token se využívá k přerušení zpracování konkrétní žádosti.

Complete(): Jak je znázorněno v předchozí sekvenci, metoda Complete oznámí platformě, že žádost byla úspěšně zpracována a všechny relevantní informace byly předány IMessageBus.

Výstraha

Zanedbání vyvolání Complete() na požadavku způsobí, že testovací aplikace přestane reagovat.

Pokud chcete přizpůsobit testovací architekturu podle vašich požadavků nebo uživatelů, můžete použít individuální oddíl uvnitř konfiguračního souboru nebo s vlastními možnostmi příkazového řádku .

Zpracování žádostí

Následující část obsahuje podrobný popis různých požadavků, které může testovací architektura přijímat a zpracovávat.

Než budete pokračovat k další části, je důležité důkladně pochopit koncept IMessageBus, což je základní služba pro předávání informací o provádění testů testovací platformě.

TestSessionContext

TestSessionContext je sdílená vlastnost napříč všemi požadavky a poskytuje informace o probíhající testovací relaci:

public class TestSessionContext
{
    public SessionUid SessionUid { get; }
}

public readonly struct SessionUid(string value)
{
    public string Value { get; }
}

TestSessionContext se skládá z SessionUid, jedinečného identifikátoru pro probíhající testovací relaci, která pomáhá při protokolování a korelaci dat testovací relace.

DiscoverTestExecutionRequest

public class DiscoverTestExecutionRequest
{
    public TestSessionContext Session { get; }
    public ITestExecutionFilter Filter { get; }
}

DiscoverTestExecutionRequest dává pokyn testovacímu rámci , aby objevil testy a sdělit tyto informace IMessageBus.

Jak je uvedeno v předchozí části, vlastnost zjištěného testu je DiscoveredTestNodeStateProperty. Tady je obecný fragment kódu pro referenci:

var testNode = new TestNode
{
    Uid = GenerateUniqueStableId(),
    DisplayName = GetDisplayName(),
    Properties = new PropertyBag(
        DiscoveredTestNodeStateProperty.CachedInstance),
};

await context.MessageBus.PublishAsync(
    this,
    new TestNodeUpdateMessage(
        discoverTestExecutionRequest.Session.SessionUid,
        testNode));

// ...

VyžádatSpuštěníTestu

public class RunTestExecutionRequest
{
    public TestSessionContext Session { get; }
    public ITestExecutionFilter Filter { get; }
}

RunTestExecutionRequest dává pokyn testovacímu rozhraní ke spuštění testů a k předání těchto informací IMessageBus.

Tady je obecný fragment kódu pro referenci:

var skippedTestNode = new TestNode()
{
    Uid = GenerateUniqueStableId(),
    DisplayName = GetDisplayName(),
    Properties = new PropertyBag(
        SkippedTestNodeStateProperty.CachedInstance),
};

await context.MessageBus.PublishAsync(
    this,
    new TestNodeUpdateMessage(
        runTestExecutionRequest.Session.SessionUid,
        skippedTestNode));

// ...

var successfulTestNode = new TestNode()
{
    Uid = GenerateUniqueStableId(),
    DisplayName = GetDisplayName(),
    Properties = new PropertyBag(
        PassedTestNodeStateProperty.CachedInstance),
};

await context.MessageBus.PublishAsync(
    this,
    new TestNodeUpdateMessage(
        runTestExecutionRequest.Session.SessionUid,
        successfulTestNode));

// ...

var assertionFailedTestNode = new TestNode()
{
    Uid = GenerateUniqueStableId(),
    DisplayName = GetDisplayName(),
    Properties = new PropertyBag(
        new FailedTestNodeStateProperty(assertionException)),
};

await context.MessageBus.PublishAsync(
    this,
    new TestNodeUpdateMessage(
        runTestExecutionRequest.Session.SessionUid,
        assertionFailedTestNode));

// ...

var failedTestNode = new TestNode()
{
    Uid = GenerateUniqueStableId(),
    DisplayName = GetDisplayName(),
    Properties = new PropertyBag(
        new ErrorTestNodeStateProperty(ex.InnerException!)),
};

await context.MessageBus.PublishAsync(
    this,
    new TestNodeUpdateMessage(
        runTestExecutionRequest.Session.SessionUid,
        failedTestNode));

Data TestNodeUpdateMessage

Jak je uvedeno v části IMessageBus, před použitím sběrnice zpráv musíte zadat typ dat, která chcete poskytnout. Testovací platforma definovala dobře známý typ TestNodeUpdateMessage, který představuje koncept informací o aktualizaci testů.

Tato část dokumentu vysvětluje, jak využívat datový obsah. Pojďme se podívat na povrch:

public sealed class TestNodeUpdateMessage(
    SessionUid sessionUid,
    TestNode testNode,
    TestNodeUid? parentTestNodeUid = null)
{
    public TestNode TestNode { get; }
    public TestNodeUid? ParentTestNodeUid { get; }
}

public class TestNode
{
    public required TestNodeUid Uid { get; init; }
    public required string DisplayName { get; init; }
    public PropertyBag Properties { get; init; } = new();
}

public sealed class TestNodeUid(string value);

public sealed partial class PropertyBag
{
    public PropertyBag();
    public PropertyBag(params IProperty[] properties);
    public PropertyBag(IEnumerable<IProperty> properties);
    public int Count { get; }
    public void Add(IProperty property);
    public bool Any<TProperty>();
    public TProperty? SingleOrDefault<TProperty>();
    public TProperty Single<TProperty>();
    public TProperty[] OfType<TProperty>();
    public IEnumerable<IProperty> AsEnumerable();
    public IEnumerator<IProperty> GetEnumerator();
    ...
}

public interface IProperty
{
}

  • TestNodeUpdateMessage: TestNodeUpdateMessage se skládá ze dvou vlastností: TestNode a ParentTestNodeUid. ParentTestNodeUid označuje, že test může mít nadřazený test, což představuje koncept stromu, kde lze TestNodeuspořádat ve vztahu k sobě navzájem. Tato struktura umožňuje budoucí vylepšení a funkce založené na stromu vztah mezi uzly. Pokud váš testovací rámec nevyžaduje strukturu stromu testů, můžete se rozhodnout ji nepoužívat a jednoduše ji nastavit na hodnotu null, což vede k jednoduchému plošnému seznamu TestNode.

  • TestNode: TestNode se skládá ze tří vlastností, z nichž jeden je Uid typu TestNodeUid. Tento Uid slouží jako JEDINEČNÉ STABILNÍ ID uzlu. Pojem JEDINEČNÉ STABILNÍ ID znamená, že stejný TestNode by měl zachovávat IDENTICKÉUid napříč různými spouštěními a operačními systémy. TestNodeUid je libovolný neprůhledný řetězec, který testovací platforma přijímá tak, jak je.

Důležité

Stabilita a jedinečnost ID jsou v testovací doméně zásadní. Umožňují přesné cílení jednoho testu pro spuštění a umožňují ID sloužit jako trvalý identifikátor testu, což usnadňuje výkonné rozšíření a funkce.

Druhá vlastnost je DisplayName, což je uživatelsky přívětivý název testu. Tento název se například zobrazí při spuštění --list-tests příkazového řádku.

Třetí atribut je Properties, což je typ PropertyBag. Jak je znázorněno v kódu, jedná se o specializovanou sadu vlastností, která obsahuje obecné vlastnosti o TestNodeUpdateMessage. To znamená, že můžete připojit libovolnou vlastnost k uzlu, který implementuje zástupné rozhraní IProperty.

Testovací platforma identifikuje konkrétní vlastnosti přidané do TestNode.Properties k určení, jestli test prošel, selhal nebo byl vynechán.

Aktuální seznam dostupných vlastností s relativním popisem najdete v části TestNodeUpdateMessage.TestNode.

Typ PropertyBag je obvykle přístupný v každém IData a využívá se k ukládání různých vlastností, které je možné dotazovat platformou a rozšířeními. Tento mechanismus nám umožňuje vylepšit platformu novými informacemi bez zavedení zásadních změn. Pokud komponenta rozpozná vlastnost, může se na ni dotazovat; jinak ho ignoruje.

Tato část nakonec objasňuje, že vaše implementace testovacího frameworku potřebuje implementovat IDataProducer, která produkuje TestNodeUpdateMessagejako v ukázce níže:

internal sealed class TestingFramework
    : ITestFramework, IDataProducer
{
   // ...

   public Type[] DataTypesProduced =>
   [
       typeof(TestNodeUpdateMessage)
   ];

   // ...
}

Pokud váš testovací adaptér vyžaduje publikaci souborů během provádění, můžete v tomto zdrojovém souboru najít rozpoznané vlastnosti: https://github.com/microsoft/testfx/blob/main/src/Platform/Microsoft.Testing.Platform/Messages/FileArtifacts.cs. Jak vidíte, můžete soubory poskytnout obecně nebo je přidružit ke konkrétnímu TestNode. Nezapomeňte, že pokud máte v úmyslu zadat SessionFileArtifact, musíte jej předem oznámit na platformě, jak je znázorněno níže:

internal sealed class TestingFramework
    : ITestFramework, IDataProducer
{
   // ...

   public Type[] DataTypesProduced =>
   [
       typeof(TestNodeUpdateMessage),
       typeof(SessionFileArtifact)
   ];

   // ...
}

Známé vlastnosti

Jak je podrobně popsáno v části požadavků, testovací platforma identifikuje konkrétní vlastnosti přidané k TestNodeUpdateMessage, pro určení stavu TestNode (například úspěšné, neúspěšné, přeskočené atd.). To umožňuje modulu runtime přesně zobrazit seznam neúspěšných testů s odpovídajícími informacemi v konzole a nastavit odpovídající ukončovací kód pro proces testu.

V tomto segmentu zjistíme různé dobře známé IProperty možnosti a jejich příslušné důsledky.

Úplný seznam známých vlastností najdete v tématu TestNodeProperties.cs. Pokud si všimnete, že chybí popis vlastnosti, nahlaste problém.

Tyto vlastnosti lze rozdělit do následujících kategorií:

  1. obecné informace: Vlastnosti, které lze zahrnout do jakéhokoli druhu požadavku.
  2. informace o zjišťování: Vlastnosti zadané během požadavku na zjišťování DiscoverTestExecutionRequest.
  3. informace o spuštění: Vlastnosti zadané během požadavku na provedení testu RunTestExecutionRequest.

Některé vlastnosti jsou povinné, zatímco jiné jsou volitelné. Povinné vlastnosti jsou vyžadovány k poskytování základních testovacích funkcí, jako je hlášení neúspěšných testů a indikující, zda byla celá testovací relace úspěšná nebo ne.

Volitelné vlastnosti na druhou stranu vylepšují možnosti testování tím, že poskytují další informace. Jsou zvlášť užitečné ve scénářích integrovaného vývojového prostředí (například VS, VSCode atd.), spuštění konzoly nebo při podpoře konkrétních rozšíření, která vyžadují správné fungování podrobnějších informací. Tyto volitelné vlastnosti však nemají vliv na provádění testů.

Poznámka:

Rozšíření mají za úkol upozorňovat a spravovat výjimky, pokud vyžadují správné fungování konkrétních informací. Pokud rozšíření neobsahuje potřebné informace, nemělo by způsobit selhání spuštění testu, ale mělo by se jednoduše odhlásit.

Obecné informace
public record KeyValuePairStringProperty(
    string Key,
    string Value)
        : IProperty;

KeyValuePairStringProperty znamená obecná data ve formě páru klíč/hodnota.

public record struct LinePosition(
    int Line,
    int Column);

public record struct LinePositionSpan(
    LinePosition Start,
    LinePosition End);

public abstract record FileLocationProperty(
    string FilePath,
    LinePositionSpan LineSpan)
        : IProperty;

public sealed record TestFileLocationProperty(
    string FilePath,
    LinePositionSpan LineSpan)
        : FileLocationProperty(FilePath, LineSpan);

TestFileLocationProperty slouží k určení umístění testu ve zdrojovém souboru. To je užitečné zejména v případě, že iniciátor je integrované vývojové prostředí (IDE), jako je Visual Studio nebo Visual Studio Code.

public sealed record TestMethodIdentifierProperty(
    string AssemblyFullName,
    string Namespace,
    string TypeName,
    string MethodName,
    string[] ParameterTypeFullNames,
    string ReturnTypeFullName)

TestMethodIdentifierProperty je jedinečný identifikátor testovací metody.

public sealed record TestMetadataProperty(
    string Key,
    string Value)

TestMetadataProperty se používá k vyjádření charakteristik nebo vlastností TestNode.

Informace o objevení
public sealed record DiscoveredTestNodeStateProperty(
    string? Explanation = null)
{
    public static DiscoveredTestNodeStateProperty CachedInstance { get; }
}

DiscoveredTestNodeStateProperty označuje, že se zjistil tento testovací uzel. Používá se při odeslání DiscoverTestExecutionRequest do testovací architektury. Poznamenejte si praktickou hodnotu uloženou v mezipaměti, kterou nabízí vlastnost CachedInstance. Tato vlastnost je požadovaná.

Informace o spuštění
public sealed record InProgressTestNodeStateProperty(
    string? Explanation = null)
{
    public static InProgressTestNodeStateProperty CachedInstance { get; }
}

InProgressTestNodeStateProperty informuje testovací platformu, že TestNode bylo naplánováno ke spuštění a je právě v procesu. Poznamenejte si praktickou hodnotu uloženou v mezipaměti, kterou nabízí vlastnost CachedInstance.

public readonly record struct TimingInfo(
    DateTimeOffset StartTime,
    DateTimeOffset EndTime,
    TimeSpan Duration);

public sealed record StepTimingInfo(
    string Id,
    string Description,
    TimingInfo Timing);

public sealed record TimingProperty : IProperty
{
    public TimingProperty(TimingInfo globalTiming)
        : this(globalTiming, [])
    {
    }

    public TimingProperty(
        TimingInfo globalTiming,
        StepTimingInfo[] stepTimings)
    {
        GlobalTiming = globalTiming;
        StepTimings = stepTimings;
    }

    public TimingInfo GlobalTiming { get; }

    public StepTimingInfo[] StepTimings { get; }
}

K předávání detailů o časování pro spuštění TimingProperty se využívá TestNode. Umožňuje také načasování jednotlivých kroků provádění prostřednictvím StepTimingInfo. To je užitečné zejména v případě, že je koncept testu rozdělený do několika fází, jako je inicializace, provádění a vyčištění.

jeden a pouze jeden následujících vlastností je požadované na TestNode a sdělí výsledek TestNode testovací platformě.

public sealed record PassedTestNodeStateProperty(
    string? Explanation = null)
        : TestNodeStateProperty(Explanation)
{
    public static PassedTestNodeStateProperty CachedInstance
        { get; } = new PassedTestNodeStateProperty();
}

PassedTestNodeStateProperty informuje testovací platformu, že tento TestNode je úspěšný. Poznamenejte si praktickou hodnotu uloženou v mezipaměti, kterou nabízí vlastnost CachedInstance.

public sealed record SkippedTestNodeStateProperty(
    string? Explanation = null)
        : TestNodeStateProperty(Explanation)
{
    public static SkippedTestNodeStateProperty CachedInstance
        { get; } =  new SkippedTestNodeStateProperty();
}

SkippedTestNodeStateProperty informuje testovací platformu, že tento TestNode byl přeskočen. Poznamenejte si praktickou hodnotu uloženou v mezipaměti, kterou nabízí vlastnost CachedInstance.

public sealed record FailedTestNodeStateProperty : TestNodeStateProperty
{
    public FailedTestNodeStateProperty()
        : base(default(string))
    {
    }

    public FailedTestNodeStateProperty(string explanation)
        : base(explanation)
    {
    }

    public FailedTestNodeStateProperty(
        Exception exception,
        string? explanation = null)
        : base(explanation ?? exception.Message)
    {
        Exception = exception;
    }

    public Exception? Exception { get; }
}

FailedTestNodeStateProperty informuje testovací platformu, že tato TestNode byla po asercí selhána.

public sealed record ErrorTestNodeStateProperty : TestNodeStateProperty
{
    public ErrorTestNodeStateProperty()
        : base(default(string))
    {
    }

    public ErrorTestNodeStateProperty(string explanation)
        : base(explanation)
    {
    }

    public ErrorTestNodeStateProperty(
        Exception exception,
        string? explanation = null)
            : base(explanation ?? exception.Message)
    {
        Exception = exception;
    }

    public Exception? Exception { get; }
}

ErrorTestNodeStateProperty informuje testovací platformu, že tento TestNode selhal. Tento typ selhání se liší od typu FailedTestNodeStateProperty, který se používá pro selhání při kontrolách výroků. Můžete například hlásit problémy, jako jsou chyby inicializace testů s ErrorTestNodeStateProperty.

public sealed record TimeoutTestNodeStateProperty : TestNodeStateProperty
{
    public TimeoutTestNodeStateProperty()
        : base(default(string))
    {
    }

    public TimeoutTestNodeStateProperty(string explanation)
        : base(explanation)
    {
    }

    public TimeoutTestNodeStateProperty(
        Exception exception,
        string? explanation = null)
            : base(explanation ?? exception.Message)
    {
        Exception = exception;
    }

    public Exception? Exception { get; }

    public TimeSpan? Timeout { get; init; }
}

TimeoutTestNodeStateProperty informuje testovací platformu, že tento TestNode kvůli vypršení časového limitu selhal. Časový limit můžete nahlásit pomocí vlastnosti Timeout.

public sealed record CancelledTestNodeStateProperty : TestNodeStateProperty
{
    public CancelledTestNodeStateProperty()
        : base(default(string))
    {
    }

    public CancelledTestNodeStateProperty(string explanation)
        : base(explanation)
    {
    }

    public CancelledTestNodeStateProperty(
        Exception exception,
        string? explanation = null)
        : base(explanation ?? exception.Message)
    {
        Exception = exception;
    }

    public Exception? Exception { get; }
}

CancelledTestNodeStateProperty informuje testovací platformu, že tento TestNode selhal kvůli zrušení.

  • Last updated on