Condividi tramite

Creare un framework di test

Questo articolo illustra come creare un framework di test personalizzato per Microsoft.Testing.Platform. Il framework di test è l'unica estensione obbligatoria. Individua ed esegue test e restituisce i risultati alla piattaforma.

Per il riepilogo completo del punto di estensione e i concetti in-process/out-of-process, vedere Creare estensioni personalizzate.

Se si esegue la migrazione di un framework di test esistente basato su VSTest, l'implementazione dell'interfaccia ITestFramework in modo nativo è l'approccio consigliato. L'estensione VSTest Bridge è disponibile come passaggio transitorio, ma un'implementazione nativa offre la migliore esperienza.

Estensione del framework di test

Il framework di test è l'estensione principale che fornisce alla piattaforma di test la possibilità di individuare ed eseguire test. Il framework di test è responsabile della comunicazione dei risultati dei test alla piattaforma di test. Il framework di test è l'unica estensione obbligatoria necessaria per eseguire una sessione di test.

Registrare un framework di test

Questa sezione illustra come registrare il framework di test con la piattaforma di test. È possibile registrare un solo framework di test per ogni generatore di applicazioni di test usando l'API TestApplication.RegisterTestFramework , come illustrato nella documentazione sull'architettura di Microsoft.Testing.Platform .

L'API di registrazione viene definita come segue:

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

L'API RegisterTestFramework richiede due classi factory:

  1. Func<IServiceProvider, ITestFrameworkCapabilities>: delegato che accetta un oggetto che implementa l'interfaccia IServiceProvider e restituisce un oggetto che implementa l'interfaccia ITestFrameworkCapabilities . IServiceProvider fornisce l'accesso ai servizi della piattaforma, ad esempio configurazioni, logger e argomenti della riga di comando.

    L'interfaccia ITestFrameworkCapabilities viene usata per annunciare le funzionalità supportate dal framework di test per la piattaforma e le estensioni. Consente alla piattaforma e alle estensioni di interagire correttamente implementando e supportando comportamenti specifici. Per una migliore comprensione del concetto di funzionalità, vedere la rispettiva sezione.

  2. Func<ITestFrameworkCapabilities, IServiceProvider, ITestFramework>: si tratta di un delegato che accetta un oggetto ITestFrameworkCapabilities, ovvero l'istanza restituita da Func<IServiceProvider, ITestFrameworkCapabilities> e un IServiceProvider per fornire nuovamente l'accesso ai servizi della piattaforma. L'oggetto restituito previsto è uno che implementa l'interfaccia ITestFramework . funge ITestFramework da motore di esecuzione che individua ed esegue i test e quindi comunica i risultati alla piattaforma di test.

La necessità della piattaforma di separare la creazione di ITestFrameworkCapabilities e la creazione di ITestFramework è un'ottimizzazione per evitare di creare il framework di test se le funzionalità supportate non sono sufficienti per eseguire la sessione di test corrente.

Si consideri l'esempio di codice utente seguente, che illustra una registrazione del framework di test che restituisce un set di funzionalità vuoto:

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));
    }
}

// ...

Si consideri ora il punto di ingresso corrispondente di questo esempio con il codice di registrazione:

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

Annotazioni

La restituzione di ITestFrameworkCapabilities vuota non dovrebbe impedire l'esecuzione della sessione di test. Tutti i framework di test devono essere in grado di individuare ed eseguire test. L'impatto deve essere limitato alle estensioni che possono rifiutare esplicitamente se il framework di test non dispone di una determinata funzionalità.

Creare un framework di test

L'Microsoft.Testing.Platform.Extensions.TestFramework.ITestFramework viene implementato dalle estensioni che forniscono un framework di test.

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

Interfaccia IExtension

L'interfaccia ITestFramework eredita dall'interfaccia IExtension , ovvero un'interfaccia da cui ereditano tutti i punti di estensione. IExtension viene usato per recuperare il nome e la descrizione dell'estensione. Inoltre, IExtension fornisce un modo per abilitare o disabilitare dinamicamente l'estensione nella configurazione, tramite Task<bool> IsEnabledAsync(). Assicurati di restituire true da questo metodo se non hai requisiti specifici per disabilitarlo.

Metodo CreateTestSessionAsync

Il metodo CreateTestSessionAsync viene chiamato all'inizio della sessione di test e viene usato per inizializzare il framework di test. L'API accetta un oggetto CreateTestSessionContext e restituisce un oggetto CreateTestSessionResult.

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

La SessionUid proprietà viene ereditata da TestSessionContext (vedere la sezione TestSessionContext). CancellationToken viene utilizzato per interrompere l'esecuzione di CreateTestSessionAsync.

L'oggetto restituito è un CreateTestSessionResult:

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

La proprietà IsSuccess viene utilizzata per indicare se la creazione della sessione ha avuto esito positivo. Quando restituisce false, l'esecuzione del test viene interrotta.

Metodo CloseTestSessionAsync

Il metodo CloseTestSessionAsync è giustapposto a CreateTestSessionAsync in termini di funzionalità, con l'unica differenza nei nomi degli oggetti. Per altre informazioni, vedere la sezione CreateTestSessionAsync.

Metodo ExecuteRequestAsync

Il metodo ExecuteRequestAsync accetta un oggetto di tipo ExecuteRequestContext. Questo oggetto, come suggerito dal nome, contiene le specifiche sull'azione che il framework di test deve eseguire. La definizione di ExecuteRequestContext è:

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

IRequest: interfaccia di base per qualsiasi tipo di richiesta. È consigliabile considerare il framework di test come un server con stato in-process in cui il ciclo di vita è:

Diagramma di sequenza che rappresenta il ciclo di vita del framework di test.

Il diagramma precedente illustra che la piattaforma di test emette tre richieste dopo la creazione dell'istanza del framework di test. Il framework di test elabora queste richieste e usa il servizio IMessageBus, incluso nella richiesta stessa, per recapitare il risultato per ogni richiesta specifica. Dopo aver gestito una determinata richiesta, il framework di test richiama il metodo Complete() su di esso, a indicare alla piattaforma di test che la richiesta è stata soddisfatta. La piattaforma di test monitora tutte le richieste inviate. Dopo che tutte le richieste sono state soddisfatte, richiama CloseTestSessionAsync ed elimina l'istanza (se IDisposable/IAsyncDisposable viene implementato). È evidente che le richieste e i relativi completamenti possono sovrapporsi, abilitando l'esecuzione simultanea e asincrona delle richieste.

Annotazioni

Attualmente, la piattaforma di test non invia richieste sovrapposte e attende il completamento di una richiesta >> prima di inviare quella successiva. Tuttavia, questo comportamento può cambiare in futuro. Il supporto per le richieste simultanee verrà determinato tramite il sistema di funzionalità.

L'implementazione di IRequest specifica la richiesta precisa che deve essere soddisfatta. Il framework di test identifica il tipo di richiesta e lo gestisce di conseguenza. Se il tipo di richiesta non è riconosciuto, deve essere generata un'eccezione.

Per informazioni dettagliate sulle richieste disponibili, consultare la sezione IRequest.

IMessageBus: questo servizio, collegato alla richiesta, consente al framework di test di pubblicare in modo asincrono le informazioni sulla richiesta in corso alla piattaforma di test. Il bus di messaggi funge da hub centrale per la piattaforma, semplificando la comunicazione asincrona tra tutti i componenti e le estensioni della piattaforma. Per un elenco completo delle informazioni che è possibile pubblicare nella piattaforma di test, consultare la sezione IMessageBus.

CancellationToken: questo token viene utilizzato per interrompere l'elaborazione di una determinata richiesta.

Complete(): come illustrato nella sequenza precedente, il Complete metodo notifica alla piattaforma che la richiesta è stata elaborata correttamente e tutte le informazioni pertinenti sono state trasmesse a IMessageBus.

Avviso

L'abbandono della chiamata Complete() alla richiesta comporterà la mancata risposta dell'applicazione di test.

Per personalizzare il framework di test in base ai requisiti o a quelli degli utenti, è possibile usare una sezione personalizzata all'interno del file di configurazione o con opzioni della riga di comando personalizzate.

Gestione delle richieste

La sezione successiva fornisce una descrizione dettagliata delle varie richieste che un framework di test può ricevere ed elaborare.

Prima di procedere alla sezione successiva, è fondamentale comprendere accuratamente il concetto di IMessageBus, che è il servizio essenziale per trasmettere informazioni sull'esecuzione dei test alla piattaforma di test.

TestSessionContext

TestSessionContext è una proprietà condivisa in tutte le richieste, fornendo informazioni sulla sessione di test in corso:

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

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

TestSessionContext è costituito da SessionUid, un identificatore univoco per la sessione di test in corso che consente di registrare e correlare i dati della sessione di test.

DiscoverTestExecutionRequest

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

DiscoverTestExecutionRequest indica al framework di test di identificare i test e di comunicare queste informazioni al IMessageBus.

Come descritto nella sezione precedente, la proprietà per un test individuato è DiscoveredTestNodeStateProperty. Ecco un frammento di codice generico per riferimento:

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

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

// ...

RichiestaEsecuzioneDiTest

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

RunTestExecutionRequest Indica al framework di test di eseguire i test e comunicare queste informazioni pensate a IMessageBus.

Ecco un frammento di codice generico per riferimento:

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));

I dati TestNodeUpdateMessage

Come indicato nella sezione IMessageBus, prima di utilizzare il bus di messaggi, è necessario specificare il tipo di dati che si intende fornire. La piattaforma di test ha definito un tipo noto, , per rappresentare il concetto di aggiornamento delle informazioni di test .

Questa parte del documento illustra come utilizzare questi dati di payload. Esaminiamo la superficie:

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: è costituito da due proprietà: TestNode e ParentTestNodeUid. Il ParentTestNodeUid indica che un test può avere un test padre, introducendo il concetto di un albero di test in cui i TestNode possono essere disposti l'uno rispetto all'altro. Questa struttura consente miglioramenti e funzionalità futuri in base alla relazione di albero tra i nodi. Se il framework di test non richiede una struttura ad albero di test, è possibile scegliere di non usarlo e impostarlo semplicemente su Null, ottenendo un semplice elenco semplice di TestNode.

  • TestNode: Il TestNode è composto da tre proprietà, una delle quali è il Uid di tipo TestNodeUid. Viene usato Uid come ID STABILE UNIVOCO per il nodo. Il termine ID STABILE UNIVOCO implica che lo stesso TestNode deve mantenere un IDENTICOUid nelle diverse esecuzioni e sistemi operativi. TestNodeUid è una stringa opaca arbitraria che la piattaforma di test accetta così come è.

Importante

La stabilità e l'univocità dell'ID sono fondamentali nel dominio di test. Abilitano la destinazione precisa di un singolo test per l'esecuzione e consentono all'ID di fungere da identificatore permanente per un test, semplificando estensioni e funzionalità avanzate.

La seconda proprietà è DisplayName, ovvero il nome di facile comprensione per il test. Ad esempio, questo nome viene visualizzato quando si esegue la riga di comando --list-tests.

Il terzo attributo è Properties, ovvero un tipo PropertyBag. Come illustrato nel codice, si tratta di un contenitore di proprietà specializzato che contiene proprietà generiche relative a TestNodeUpdateMessage. Ciò implica che è possibile aggiungere qualsiasi proprietà al nodo che implementa l'interfaccia segnaposto IProperty.

La piattaforma di test identifica proprietà specifiche aggiunte a un TestNode.Properties oggetto per determinare se un test è stato superato, non riuscito o ignorato.

È possibile trovare l'elenco corrente delle proprietà disponibili con la descrizione relativa nella sezione TestNodeUpdateMessage.TestNode.

Il PropertyBag tipo è in genere accessibile in ogni IData e viene utilizzato per archiviare proprietà varie che possono essere sottoposte a query dalla piattaforma e dalle estensioni. Questo meccanismo consente di migliorare la piattaforma con nuove informazioni senza introdurre modifiche di rilievo. Se un componente riconosce la proprietà, può interrogarla; in caso contrario, la ignorerà.

Infine, questa sezione chiarisce che l'implementazione del framework di test deve includere l'oggetto IDataProducer che produce TestNodeUpdateMessage come nell'esempio seguente:

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

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

   // ...
}

Se l'adattatore di test richiede la pubblicazione di file durante l'esecuzione, è possibile trovare le proprietà riconosciute in questo file di origine: https://github.com/microsoft/testfx/blob/main/src/Platform/Microsoft.Testing.Platform/Messages/FileArtifacts.cs. Come si può notare, è possibile fornire asset di file in modo generale o associarli a un oggetto specifico TestNode. Tenere presente che, se si intende eseguire il push di un SessionFileArtifact, è necessario dichiararlo in anticipo alla piattaforma, come illustrato di seguito:

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

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

   // ...
}

Proprietà note

Come descritto in dettaglio nella sezione delle richieste, la piattaforma di test identifica proprietà specifiche aggiunte a TestNodeUpdateMessage per determinare lo stato di un TestNode (ad esempio, esito positivo, non riuscito, ignorato e così via). Ciò consente al runtime di visualizzare in modo accurato un elenco di test non riusciti con le informazioni corrispondenti nella console e di impostare il codice di uscita appropriato per il processo di test.

In questo segmento verranno chiarite le varie opzioni note IProperty e le rispettive implicazioni.

Per un elenco completo delle proprietà note, vedere TestNodeProperties.cs. Se si nota che manca una descrizione della proprietà, segnalare un problema.

Queste proprietà possono essere suddivise nelle categorie seguenti:

  1. Informazioni generiche: proprietà che possono essere incluse in qualsiasi tipo di richiesta.
  2. Informazioni sull'individuazione: proprietà fornite durante una DiscoverTestExecutionRequest richiesta di individuazione.
  3. Informazioni sull'esecuzione : proprietà fornite durante una richiesta RunTestExecutionRequestdi esecuzione del test .

Alcune proprietà sono obbligatorie, mentre altre sono facoltative. Le proprietà obbligatorie sono necessarie per fornire funzionalità di test di base, ad esempio per segnalare i test non riusciti e indicare se l'intera sessione di test ha avuto esito positivo o negativo.

Le proprietà facoltative, d'altra parte, migliorano l'esperienza di test fornendo informazioni aggiuntive. Sono particolarmente utili negli scenari IDE (ad esempio VS, VSCode e così via), esecuzioni della console o quando supportano estensioni specifiche che richiedono informazioni più dettagliate per funzionare correttamente. Tuttavia, queste proprietà facoltative non influiscono sull'esecuzione dei test.

Annotazioni

Le estensioni vengono gestite con avvisi e gestione delle eccezioni quando richiedono informazioni specifiche per funzionare correttamente. Se un'estensione non dispone delle informazioni necessarie, non dovrebbe causare l'esito negativo dell'esecuzione del test, ma dovrebbe semplicemente rifiutare esplicitamente.

Informazioni generiche
public record KeyValuePairStringProperty(
    string Key,
    string Value)
        : IProperty;

KeyValuePairStringPropertyindica i dati di coppia chiave/valore generali.

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 viene usato per individuare il percorso del test all'interno del file di origine. Ciò è particolarmente utile quando l'iniziatore è un IDE come Visual Studio o Visual Studio Code.

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

TestMethodIdentifierProperty è un identificatore univoco per un metodo di test.

public sealed record TestMetadataProperty(
    string Key,
    string Value)

TestMetadataProperty viene utilizzato per trasmettere le caratteristiche o i tratti di un oggetto TestNode.

Informazioni di individuazione
public sealed record DiscoveredTestNodeStateProperty(
    string? Explanation = null)
{
    public static DiscoveredTestNodeStateProperty CachedInstance { get; }
}

DiscoveredTestNodeStateProperty indica che il nodo TestNode è stato individuato. Viene utilizzato quando DiscoverTestExecutionRequest viene inviato al framework di test. Prendere nota del pratico valore memorizzato nella cache offerto dalla proprietà CachedInstance. Questa proprietà è obbligatoria.

Informazioni sull'esecuzione
public sealed record InProgressTestNodeStateProperty(
    string? Explanation = null)
{
    public static InProgressTestNodeStateProperty CachedInstance { get; }
}

InProgressTestNodeStateProperty comunica alla piattaforma di test che TestNode è stato pianificato per l'esecuzione ed è attualmente in corso. Prendere nota del pratico valore memorizzato nella cache offerto dalla proprietà 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; }
}

TimingProperty viene utilizzato per trasmettere i dettagli di temporizzazione relativi all'esecuzione TestNode. Consente inoltre la tempistica dei singoli passaggi di esecuzione tramite StepTimingInfo. Ciò è particolarmente utile quando il concetto di test è suddiviso in più fasi, ad esempio l'inizializzazione, l'esecuzione e la pulizia.

Una e una sola delle proprietà seguenti è necessaria per TestNode e comunica il risultato di TestNode alla piattaforma di test.

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

PassedTestNodeStateProperty informa la piattaforma di test che TestNode è stata superata. Prendere nota del pratico valore memorizzato nella cache offerto dalla proprietà CachedInstance.

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

SkippedTestNodeStateProperty informa la piattaforma di test che TestNode è stata ignorata. Prendere nota del pratico valore memorizzato nella cache offerto dalla proprietà 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 informa la piattaforma di test che l'operazione TestNode è fallita dopo un'asserzione.

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 informa la piattaforma di test che l'operazione TestNode non è riuscita. Questo tipo di errore è diverso da FailedTestNodeStateProperty, usato per gli errori di asserzione. Ad esempio, è possibile segnalare problemi come gli errori di inizializzazione dei test con 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 informa la piattaforma di test che TestNode è fallito per un problema di timeout. È possibile segnalare il timeout usando la proprietà 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 informa la piattaforma di test che TestNode è fallito a causa di annullamento.

  • Last updated on