Bővítmények létrehozása a Microsoft.Testing.Platformhoz

Ez a cikk a Microsoft.Testing.Platform bővíthetőségi pontjait ismerteti a tesztelési keretrendszeren túl. A tesztelési keretrendszer létrehozásához tekintse meg a tesztelési keretrendszer létrehozását ismertető témakört.

A bővítménypont teljes összefoglalását és a folyamaton belüli/folyamaton kívüli fogalmakat az egyéni bővítmények létrehozása című témakörben talál.

Bővíthetőségi pontok

A tesztelési platform további bővíthetőségi pontokat biztosít, amelyek lehetővé teszik a platform és a tesztelési keretrendszer viselkedésének testreszabását. Ezek a bővíthetőségi pontok nem kötelezőek, és a tesztelési élmény fokozására használhatók.

A `ICommandLineOptionsProvider` bővítmények

Jegyzet

Az API kiterjesztésekor az egyéni bővítmény a tesztgazdafolyamatban és azon kívül is létezik.

Az architektúra szakaszában leírtak szerint a kezdeti lépés a tesztelési keretrendszer és a bővítmények regisztrálásához szükséges ITestApplicationBuilder létrehozása.

var builder = await TestApplication.CreateBuilderAsync(args);

A CreateBuilderAsync metódus egy string[]nevű sztringtömböt (args) fogad el. Ezekkel az argumentumokkal parancssori beállításokat adhat át a tesztelési platform összes összetevőjének (beleértve a beépített összetevőket, a tesztelési keretrendszereket és a bővítményeket), lehetővé téve a viselkedés testreszabását.

Az átadott argumentumok általában a standard Main(string[] args) metódusban kapott argumentumok. Ha azonban az üzemeltetési környezet eltér, az argumentumok bármelyik listája megadható.

Az argumentumokat kell előtaggal rendelkezni. Például: --filter.

Ha egy összetevő, például egy tesztelési keretrendszer vagy egy bővítménypont egyéni parancssori lehetőségeket szeretne kínálni, ezt a ICommandLineOptionsProvider felület implementálásával teheti meg. Ez a megvalósítás ezután regisztrálható a ITestApplicationBuilder-nak a CommandLine tulajdonság regisztrációs gyárán keresztül, ahogy azt az alábbiakban láthatjuk:

builder.CommandLine.AddProvider(
    static () => new CustomCommandLineOptions());

A megadott példában CustomCommandLineOptions a ICommandLineOptionsProvider felület implementálása, ez az interfész a következő tagokból és adattípusokból áll:

public interface ICommandLineOptionsProvider : IExtension
{
    IReadOnlyCollection<CommandLineOption> GetCommandLineOptions();

    Task<ValidationResult> ValidateOptionArgumentsAsync(
        CommandLineOption commandOption,
        string[] arguments);

    Task<ValidationResult> ValidateCommandLineOptionsAsync(
        ICommandLineOptions commandLineOptions);
}

public sealed class CommandLineOption
{
    public string Name { get; }
    public string Description { get; }
    public ArgumentArity Arity { get; }
    public bool IsHidden { get; }

    // ...
}

public interface ICommandLineOptions
{
    bool IsOptionSet(string optionName);

    bool TryGetOptionArgumentList(
        string optionName,
        out string[]? arguments);
}

Mint látható, a ICommandLineOptionsProvider kibővíti a IExtension felületet. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

A ICommandLineOptionsProvider végrehajtásának sorrendje a következő:

Vizsgáljuk meg az API-k és középértéküket:

ICommandLineOptionsProvider.GetCommandLineOptions(): Ez a módszer az összetevő által kínált összes lehetőség lekérésére használható. Minden CommandLineOption a következő tulajdonságokat kell megadni:

string name: Ez a lehetőség neve, kötőjel nélkül jelenik meg. A például szűrőt felhasználók használják --filter-ként.

string description: Ez a beállítás leírása. Akkor jelenik meg, ha a felhasználók argumentumként adják át --help az alkalmazásszerkesztőnek.

ArgumentArity arity: Egy beállítás aritása az adott beállítás vagy parancs megadása esetén átadható értékek száma. A jelenlegi elérhető lehetőségek a következők:

Zero: Nulla argumentum-aritást jelöl.
ZeroOrOne: Nulla vagy egy argumentum aritását jelöli.
ZeroOrMore: Nulla vagy több argumentum aritását jelöli.
OneOrMore: Egy vagy több argumentum aritását jelöli.
ExactlyOne: Pontosan egy argumentum aritását jelöli.

Példákért tekintse meg a System.CommandLine arity táblát.

bool isHidden: Ez a tulajdonság azt jelzi, hogy a beállítás használható, de --help meghívásakor nem jelenik meg a leírásban.

ICommandLineOptionsProvider.ValidateOptionArgumentsAsync: Ez a módszer a felhasználó által megadott argumentum ellenőrzésére szolgál.

Ha például --dop nevű paraméterrel rendelkezik, amely az egyéni tesztelési keretrendszer párhuzamossági fokát jelöli, a felhasználó --dop 0adhat meg. Ebben a forgatókönyvben a 0 érték érvénytelen lenne, mert a párhuzamossági fokának 1-nek vagy annál nagyobbnak kell lennie. A ValidateOptionArgumentsAsynchasználatával előzetes ellenőrzést végezhet, és szükség esetén hibaüzenetet adhat vissza.

A fenti minta lehetséges implementációja a következő lehet:

public Task<ValidationResult> ValidateOptionArgumentsAsync(
    CommandLineOption commandOption,
    string[] arguments)
{
    if (commandOption.Name == "dop")
    {
        if (!int.TryParse(arguments[0], out int dopValue) || dopValue <= 0)
        {
            return ValidationResult.InvalidTask("--dop must be a positive integer");
        }
    }

    return ValidationResult.ValidTask;
}

ICommandLineOptionsProvider.ValidateCommandLineOptionsAsync: Ez a metódus az utolsó, és lehetővé teszi a globális koherencia-ellenőrzést.

Tegyük fel például, hogy a tesztelési keretrendszer képes létrehozni egy teszteredmény-jelentést, és menteni egy fájlba. Ez a funkció a --generatereport beállítással érhető el, a fájlnév pedig a --reportfilename myfile.rep. Ebben az esetben, ha egy felhasználó csak a --generatereport lehetőséget adja meg fájlnév megadása nélkül, az érvényesítés sikertelen lesz, mert a jelentés nem hozható létre fájlnév nélkül. A fenti minta lehetséges implementációja a következő lehet:

public Task<ValidationResult> ValidateCommandLineOptionsAsync(ICommandLineOptions commandLineOptions)
{
    bool generateReportEnabled = commandLineOptions.IsOptionSet(GenerateReportOption);
    bool reportFileName = commandLineOptions.TryGetOptionArgumentList(ReportFilenameOption, out string[]? _);

    return (generateReportEnabled || reportFileName) && !(generateReportEnabled && reportFileName)
        ? ValidationResult.InvalidTask("Both `--generatereport` and `--reportfilename` need to be provided simultaneously.")
        : ValidationResult.ValidTask;
}

Vegye figyelembe, hogy a ValidateCommandLineOptionsAsync metódus biztosítja a ICommandLineOptions szolgáltatást, amely a platform által elemezett argumentumadatok lekérésére szolgál.

A `ITestSessionLifetimeHandler` bővítmények

A ITestSessionLifeTimeHandler egy folyamatban lévő bővítmény, amely lehetővé teszi a kód végrehajtását előtt, és a tesztmunkamenet után.

Egyéni ITestSessionLifeTimeHandlerregisztrálásához használja a következő API-t:

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

builder.TestHost.AddTestSessionLifetimeHandle(
    static serviceProvider => new CustomTestSessionLifeTimeHandler());

A gyár az IServiceProvider használja a tesztelési platform által kínált szolgáltatásokhoz való hozzáféréshez.

Fontos

A regisztráció sorrendje jelentős, mivel az API-k a regisztráció sorrendjében vannak meghívva.

A ITestSessionLifeTimeHandler felület a következő módszereket tartalmazza:

public interface ITestSessionLifetimeHandler : ITestHostExtension
{
    Task OnTestSessionStartingAsync(
        SessionUid sessionUid,
        CancellationToken cancellationToken);

    Task OnTestSessionFinishingAsync(
        SessionUid sessionUid,
        CancellationToken cancellationToken);
}

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

public interface ITestHostExtension : IExtension
{
}

A ITestSessionLifetimeHandler egy ITestHostExtensiontípusa, amely az összes tesztgazda bővítmény alapjaként szolgál. Az összes többi bővítményponthoz hasonlóan ez is örökli a IExtension-t. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

Vegye figyelembe az API következő részleteit:

OnTestSessionStartingAsync: Ezt a metódust a rendszer a tesztmunkamenet megkezdése előtt hívja meg, és megkapja a SessionUid objektumot, amely átlátszatlan azonosítót biztosít az aktuális teszt munkamenethez.

OnTestSessionFinishingAsync: Ezt a metódust a tesztmunkamenet befejezése után hívja meg a program, biztosítva, hogy a tesztelési keretrendszer végzett az összes teszt végrehajtásával, és minden releváns adatot jelentett a platformnak. Ebben a módszerben a bővítmény általában a IMessageBus használja az egyéni objektumok vagy adatok megosztott platformbuszba való továbbítására. Ez a módszer bármilyen egyéni folyamaton kívüli bővítménynek is jelezheti, hogy a tesztmunkamenet befejeződött.

Végül mindkét API fogad egy CancellationToken-t, amelyet a bővítmény várhatóan figyelembe vesz.

Ha a bővítmény intenzív inicializálást igényel, és az aszinkron/várakozási mintát kell használnia, tekintse meg a Async extension initialization and cleanup. Ha meg kell osztania az állapot a bővítménypontok között, tekintse meg a CompositeExtensionFactory<T> szakaszt.

A `ITestApplicationLifecycleCallbacks` bővítmények

A ITestApplicationLifecycleCallbacks egy folyamatközi bővítmény, amely lehetővé teszi a kód végrehajtását minden előtt, mintha a tesztházigazdahipotetikus fő programjának első sorához férne hozzá.

Egyéni ITestApplicationLifecycleCallbacksregisztrálásához használja a következő api-t:

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

builder.TestHost.AddTestApplicationLifecycleCallbacks(
    static serviceProvider
    => new CustomTestApplicationLifecycleCallbacks());

A gyár az IServiceProvider használja a tesztelési platform által kínált szolgáltatásokhoz való hozzáféréshez.

Fontos

A regisztráció sorrendje jelentős, mivel az API-k a regisztráció sorrendjében vannak meghívva.

A ITestApplicationLifecycleCallbacks felület a következő módszereket tartalmazza:

public interface ITestApplicationLifecycleCallbacks : ITestHostExtension
{
    Task BeforeRunAsync(CancellationToken cancellationToken);

    Task AfterRunAsync(
        int exitCode,
        CancellationToken cancellation);
}

public interface ITestHostExtension : IExtension
{
}

A ITestApplicationLifecycleCallbacks egy ITestHostExtensiontípusa, amely az összes tesztgazda bővítmény alapjaként szolgál. Az összes többi bővítményponthoz hasonlóan ez is örökli a IExtension-t. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

BeforeRunAsync: Ez a módszer szolgál a tesztgazda kezdeti kapcsolattartó pontjaként, és ez az első lehetőség egy folyamatban lévő bővítmény számára egy funkció végrehajtására. Általában arra használják, hogy kapcsolatot létesítsen a megfelelő folyamaton kívüli bővítményekkel, ha egy szolgáltatás mindkét környezetben való működésre van tervezve.

A beépített lefagyási memóriakép funkció például folyamaton belüli és folyamaton kívüli bővítményekből áll, és ez a módszer a bővítmény folyamaton kívüli összetevőjével való információcserére szolgál.

AfterRunAsync: Ez a metódus az utolsó hívás, mielőtt kilép a int ITestApplication.RunAsync()-ből, és ellátja a exit code-t. Kizárólag tisztítási feladatokhoz használható, és a megfelelő folyamaton kívüli bővítmény értesítésére, hogy a tesztgazda hamarosan leáll.

Végül mindkét API fogad egy CancellationToken-t, amelyet a bővítmény várhatóan figyelembe vesz.

A `IDataConsumer` bővítmények

A IDataConsumer egy folyamatban lévő bővítmény, amely képes az IDatatesztelési keretrendszer és bővítményei által leküldött információkra feliratkozni és fogadni.

Ez a bővítménypont kulcsfontosságú, mivel lehetővé teszi a fejlesztők számára, hogy összegyűjtsék és feldolgozzák a tesztelési munkamenet során létrehozott összes információt.

Egyéni IDataConsumerregisztrálásához használja a következő api-t:

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

builder.TestHost.AddDataConsumer(
    static serviceProvider => new CustomDataConsumer());

A gyár az IServiceProvider használja a tesztelési platform által kínált szolgáltatásokhoz való hozzáféréshez.

Fontos

A regisztráció sorrendje jelentős, mivel az API-k a regisztráció sorrendjében vannak meghívva.

A IDataConsumer felület a következő módszereket tartalmazza:

public interface IDataConsumer : ITestHostExtension
{
    Type[] DataTypesConsumed { get; }

    Task ConsumeAsync(
        IDataProducer dataProducer,
        IData value,
        CancellationToken cancellationToken);
}

public interface IData
{
    string DisplayName { get; }
    string? Description { get; }
}

A IDataConsumer egy ITestHostExtensiontípusa, amely az összes tesztgazda bővítmény alapjaként szolgál. Az összes többi bővítményponthoz hasonlóan ez is örökli a IExtension-t. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

DataTypesConsumed: Ez a tulajdonság a bővítmény által használni kívánt Type listáját adja vissza. Ez a IDataProducer.DataTypesProducedfelel meg. Figyelemre méltó módon egy IDataConsumer probléma nélkül előfizethet több különböző IDataProducer-példányból származó típusra is.

ConsumeAsync: Ez a metódus akkor aktiválódik, ha a rendszer olyan típusú adatokat helyez be, amelyekre az aktuális fogyasztó fel van iratkozva IMessageBus. Megkapja a IDataProducer-t, hogy részleteket nyújtson a hasznos adat gyártójáról, valamint magáról a IData hasznos adatról is. Mint látható, a IData egy általános helyőrző felület, amely általános informatív adatokat tartalmaz. A különböző típusú IData használatának képessége azt jelenti, hogy a fogyasztónak kell váltania magán a típuson, hogy a megfelelő típusra állítva legyen, és hozzáférhessen a szükséges információkhoz.

Egy fogyasztó mintája, amely ki szeretné dolgozni a TestNodeUpdateMessage által előállított -t, a következő lehet:

internal class CustomDataConsumer : IDataConsumer, IOutputDeviceDataProducer
{
    public Type[] DataTypesConsumed => new[] { typeof(TestNodeUpdateMessage) };
    ...
    public Task ConsumeAsync(
        IDataProducer dataProducer,
        IData value,
        CancellationToken cancellationToken)
    {
        var testNodeUpdateMessage = (TestNodeUpdateMessage)value;

        switch (testNodeUpdateMessage.TestNode.Properties.Single<TestNodeStateProperty>())
        {
            case InProgressTestNodeStateProperty _:
                {
                    ...
                    break;
                }
            case PassedTestNodeStateProperty _:
                {
                    ...
                    break;
                }
            case FailedTestNodeStateProperty failedTestNodeStateProperty:
                {
                    ...
                    break;
                }
            case SkippedTestNodeStateProperty _:
                {
                    ...
                    break;
                }
            ...
        }

        return Task.CompletedTask;
    }
...
}

Végül az API egy CancellationToken paramétert vesz át, amit a bővítmény várhatóan betart.

Fontos

Fontos, hogy a hasznos adatokat közvetlenül a ConsumeAsync metóduson belül dolgozzák fel. Az IMessageBus szinkron és aszinkron feldolgozást is képes kezelni, és összehangolja a végrehajtást a tesztelési keretrendszerrel. Bár a használati folyamat teljesen aszinkron, és nem blokkolja az IMessageBus.Push íráskor, ez egy implementáció részletei, amelyek a jövőben változhatnak a jövőbeli követelmények miatt. A platform azonban biztosítja, hogy ezt a módszert mindig egyszer nevezik, így nincs szükség összetett szinkronizálásra, valamint a felhasználók skálázhatóságának kezelésére.

Figyelmeztetés

Ha IDataConsumer-ot a ITestHostProcessLifetimeHandler-vel együtt használunk egy összetett bővítménycsomóponton, fontos figyelmen kívül hagyni az adatokat, amelyeket a végrehajtás után kapunk, miután a ITestSessionLifetimeHandler.OnTestSessionFinishingAsyncfutása befejeződött. A OnTestSessionFinishingAsync az utolsó lehetőség a felhalmozott adatok feldolgozására és új információk továbbítására az IMessageBus, ezért az ezen a ponton túl felhasznált adatok nem lesznek a bővítmény által használható.

A `ITestHostEnvironmentVariableProvider` bővítmények

A ITestHostEnvironmentVariableProvider egy folyamaton kívüli bővítmény, amely lehetővé teszi egyéni környezeti változók létrehozását a tesztgazda számára. A bővítménypont használata biztosítja, hogy a tesztelési platform új hosztot indítson a megfelelő környezeti változókkal, ahogy az az architektúra szakaszban részletezve van.

Egyéni ITestHostEnvironmentVariableProviderregisztrálásához használja a következő API-t:

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

builder.TestHostControllers.AddEnvironmentVariableProvider(
    static serviceProvider => new CustomEnvironmentVariableForTestHost());

A gyár az IServiceProvider használja a tesztelési platform által kínált szolgáltatásokhoz való hozzáféréshez.

Fontos

A regisztráció sorrendje jelentős, mivel az API-k a regisztráció sorrendjében vannak meghívva.

A ITestHostEnvironmentVariableProvider felület a következő módszereket és típusokat tartalmazza:

public interface ITestHostEnvironmentVariableProvider : ITestHostControllersExtension, IExtension
{
    Task UpdateAsync(IEnvironmentVariables environmentVariables);

    Task<ValidationResult> ValidateTestHostEnvironmentVariablesAsync(
        IReadOnlyEnvironmentVariables environmentVariables);
}

public interface IEnvironmentVariables : IReadOnlyEnvironmentVariables
{
    void SetVariable(EnvironmentVariable environmentVariable);
    void RemoveVariable(string variable);
}

public interface IReadOnlyEnvironmentVariables
{
    bool TryGetVariable(
        string variable,
        [NotNullWhen(true)] out OwnedEnvironmentVariable? environmentVariable);
}

public sealed class OwnedEnvironmentVariable : EnvironmentVariable
{
    public IExtension Owner { get; }

    public OwnedEnvironmentVariable(
        IExtension owner,
        string variable,
        string? value,
        bool isSecret,
        bool isLocked);
}

public class EnvironmentVariable
{
    public string Variable { get; }
    public string? Value { get; }
    public bool IsSecret { get; }
    public bool IsLocked { get; }
}

A ITestHostEnvironmentVariableProvider egy ITestHostControllersExtensiontípusa, amely az összes tesztgazdavezérlő bővítmény alapjaként szolgál. Az összes többi bővítményponthoz hasonlóan ez is örökli a IExtension-t. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

Tekintse át az API részleteit:

UpdateAsync: Ez a frissítési API a IEnvironmentVariables objektum egy példányát biztosítja, amelyből meghívhatja a SetVariable vagy RemoveVariable metódusokat. A SetVariablehasználatakor egy EnvironmentVariabletípusú objektumot kell átadnia, amelyhez a következő specifikációk szükségesek:

Variable: A környezeti változó neve.
Value: A környezeti változó értéke.
IsSecret: Ez azt jelzi, hogy a környezeti változó olyan bizalmas információkat tartalmaz-e, amelyeket nem szabad naplózni vagy elérni a TryGetVariable.
IsLocked: Ez határozza meg, hogy más ITestHostEnvironmentVariableProvider bővítmények módosíthatják-e ezt az értéket.

ValidateTestHostEnvironmentVariablesAsync: Ezt a metódust a rendszer a regisztrált UpdateAsync példányok összes ITestHostEnvironmentVariableProvider metódusának meghívása után hívja meg. Lehetővé teszi, hogy ellenőrizze a környezeti változók helyes beállítását. Olyan objektumot használ, amely implementálja a IReadOnlyEnvironmentVariables, amely a TryGetVariable metódust biztosítja adott környezeti változók adatainak lekéréséhez az OwnedEnvironmentVariable objektumtípussal. Az ellenőrzés után visszaad egy ValidationResult-t, amely tartalmazza az esetleges hibák okait.

Jegyzet

A tesztelési platform alapértelmezés szerint implementálja és regisztrálja a SystemEnvironmentVariableProvider. Ez a szolgáltató betölti az összes jelenlegi környezeti változót. Első regisztrált szolgáltatóként először végrehajtja, és hozzáférést biztosít az összes többi ITestHostEnvironmentVariableProvider felhasználói bővítmény alapértelmezett környezeti változóihoz.

A `ITestHostProcessLifetimeHandler` bővítmények

A ITestHostProcessLifetimeHandler egy folyamaton kívüli bővítmény, amely lehetővé teszi a tesztgazdafolyamat külső szempontból történő megfigyelését. Ez biztosítja, hogy a bővítményt ne érintik a tesztelés alatt álló kód által kiváltott esetleges összeomlások vagy lefagyások. Ha ezt a bővítménypontot használja, a tesztelési platform új gazdagépet indít el, ahogyan az a architektúra szakaszában részletezve van.

Egyéni ITestHostProcessLifetimeHandlerregisztrálásához használja a következő API-t:

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

builder.TestHostControllers.AddProcessLifetimeHandler(
    static serviceProvider => new CustomMonitorTestHost());

A gyár az IServiceProvider használja a tesztelési platform által kínált szolgáltatásokhoz való hozzáféréshez.

Fontos

A regisztráció sorrendje jelentős, mivel az API-k a regisztráció sorrendjében vannak meghívva.

A ITestHostProcessLifetimeHandler felület a következő módszereket tartalmazza:

public interface ITestHostProcessLifetimeHandler : ITestHostControllersExtension
{
    Task BeforeTestHostProcessStartAsync(CancellationToken cancellationToken);

    Task OnTestHostProcessStartedAsync(
        ITestHostProcessInformation testHostProcessInformation,
        CancellationToken cancellation);

    Task OnTestHostProcessExitedAsync(
        ITestHostProcessInformation testHostProcessInformation,
        CancellationToken cancellation);
}

public interface ITestHostProcessInformation
{
    int PID { get; }
    int ExitCode { get; }
    bool HasExitedGracefully { get; }
}

A ITestHostProcessLifetimeHandler egy ITestHostControllersExtensiontípusa, amely az összes tesztgazdavezérlő bővítmény alapjaként szolgál. Az összes többi bővítményponthoz hasonlóan ez is örökli a IExtension-t. Ezért, mint minden más bővítmény, engedélyezheti vagy letilthatja a IExtension.IsEnabledAsync API-val.

Vegye figyelembe az API következő részleteit:

BeforeTestHostProcessStartAsync: Ezt a metódust a tesztelési platform a tesztgazdagépek elindítása előtt hívja meg.

OnTestHostProcessStartedAsync: Ezt a metódust közvetlenül a tesztgazda elindulása után hívják meg. Ez a metódus egy objektumot kínál, amely implementálja a ITestHostProcessInformation felületet, amely a tesztgazdafolyamat eredményének legfontosabb részleteit tartalmazza.

Fontos

A metódus meghívása nem akadályozza meg a tesztgazda végrehajtását. Ha szüneteltetnie kell, regisztrálnia kell egy folyamaton belüli bővítményt, például ITestApplicationLifecycleCallbacks, és szinkronizálnia kell azt a folyamaton kívüli bővítménnyel.

OnTestHostProcessExitedAsync: Ezt a metódust akkor hívja meg a program, ha a tesztcsomag végrehajtása befejeződött. Ez a módszer egy olyan objektumot biztosít, amely megfelel a ITestHostProcessInformation interfésznek, amely a tesztgazdafolyamat eredményével kapcsolatos fontos részleteket közvetít.

A ITestHostProcessInformation felület a következő részleteket tartalmazza:

PID: A tesztgazda folyamatazonosítója.
ExitCode: A folyamat kilépési kódja. Ez az érték csak a OnTestHostProcessExitedAsync metóduson belül érhető el. A OnTestHostProcessStartedAsync metóduson belüli elérésének megkísérlése kivételt eredményez.
HasExitedGracefully: Logikai érték, amely jelzi, hogy a tesztgazda összeomlott-e. Ha igaz, az azt jelzi, hogy a teszt gazdagép nem lépett ki zavartalanul.

Bővítmények végrehajtási sorrendje

A tesztelési platform egy tesztelési keretrendszerből áll, és tetszőleges számú, folyamaton belül vagy folyamaton kívülműködő bővítményből. Ez a dokumentum a hívássorozatot ismerteti az összes lehetséges bővíthetőségi pont számára annak érdekében, hogy világos legyen, mikor várható egy funkció meghívása.

ITestHostEnvironmentVariableProvider.UpdateAsync: Folyamaton kívüli
ITestHostEnvironmentVariableProvider.ValidateTestHostEnvironmentVariablesAsync: Folyamaton kívüli
ITestHostProcessLifetimeHandler.BeforeTestHostProcessStartAsync: Folyamaton kívüli
A tesztgazdagép folyamatának indítása
ITestHostProcessLifetimeHandler.OnTestHostProcessStartedAsync: A folyamaton kívüli esemény a versenyfeltételek függvényében összefonhatja bővítmények műveleteit.
ITestApplicationLifecycleCallbacks.BeforeRunAsync: Folyamatban
ITestSessionLifetimeHandler.OnTestSessionStartingAsync: Folyamatban van
ITestFramework.CreateTestSessionAsync: Folyamatban van.
ITestFramework.ExecuteRequestAsync: A folyamatban lévő metódus egy vagy több alkalommal hívható meg. Ezen a ponton a tesztelési keretrendszer adatokat továbbít a IMessageBus, amelyeket az IDataConsumerhasználhat fel.
ITestFramework.CloseTestSessionAsync: Folyamatban lévő folyamat
ITestSessionLifetimeHandler.OnTestSessionFinishingAsync: Folyamatban
ITestApplicationLifecycleCallbacks.AfterRunAsync: Folyamatban
A folyamaton belüli törlés magában foglalja a törlés meghívását és az IAsyncCleanableExtension az összes bővítményponton.
ITestHostProcessLifetimeHandler.OnTestHostProcessExitedAsync: Folyamaton kívüli
A folyamaton kívüli törlés magában foglalja a dispose meghívását és az IAsyncCleanableExtension függvényt minden bővítményponton.

Kiterjesztések segítői

A tesztelési platform számos segédosztályt és felületet biztosít a bővítmények implementálásának egyszerűsítése érdekében. Ezek a segítők úgy lettek kialakítva, hogy egyszerűsítsék a fejlesztési folyamatot, és biztosítsák, hogy a bővítmény megfeleljen a platform szabványainak.

Bővítmények aszinkron inicializálása és törlése

A tesztelési keretrendszer és a bővítmények gyárakon keresztüli létrehozása megfelel a szabványos .NET objektumlétrehozási mechanizmusnak, amely szinkron konstruktorokat használ. Ha egy bővítmény intenzív inicializálást igényel (például a fájlrendszerhez vagy a hálózathoz való hozzáférést), akkor nem tudja alkalmazni a aszinkron/várakozási mintát a konstruktorban, mert a konstruktorok üresek, nem Task.

Ezért a tesztelési platform egy módszert biztosít egy bővítmény inicializálására az aszinkron/várakozási mintával egy egyszerű felületen keresztül. A szimmetria érdekében aszinkron felületet is kínál a tisztításhoz, amelyet a bővítmények zökkenőmentesen implementálhatnak.

public interface IAsyncInitializableExtension
{
    Task InitializeAsync();
}

public interface IAsyncCleanableExtension
{
    Task CleanupAsync();
}

IAsyncInitializableExtension.InitializeAsync: Ez a metódus biztosan meg lesz hívva a gyári létrehozás után.

IAsyncCleanableExtension.CleanupAsync: Ez a módszer a tesztelési munkamenet befejezésekor legalább egyszer az alapértelmezett DisposeAsync vagy Disposeelőtt hívható meg.

Fontos

A standard Dispose metódushoz hasonlóan a CleanupAsync többször is meghívható. Ha egy objektum CleanupAsync metódusa többször van meghívva, az objektumnak figyelmen kívül kell hagynia az első utáni összes hívást. Az objektum nem hozhat kivételt, ha a CleanupAsync metódust többször is meghívják.

Jegyzet

Alapértelmezés szerint a tesztelési platform meghívja DisposeAsync, ha elérhető, vagy Dispose, ha implementálva van. Fontos megjegyezni, hogy a tesztelési platform nem hívja meg mindkét megsemmisítési metódust, de a implementáláskor rangsorolja az aszinkront.

A CompositeExtensionFactory<T>

A bővítmények szakaszban leírtaknak megfelelően a tesztelési platform lehetővé teszi, hogy olyan interfészeket implementáljon, amelyek egyéni bővítményeket tartalmaznak mind folyamaton belül, mind azon kívül.

Minden felület egy adott funkcióval foglalkozik, és .NET kialakításnak megfelelően ezt az interfészt egy adott objektumban valósítja meg. A bővítményt az adott regisztrációs API-AddXXX használatával regisztrálhatja a TestHost vagy TestHostController objektumból származó ITestApplicationBuilder-ból a megfelelő szakaszokban részletezett módon.

Ha azonban meg kell osztania az állapot két bővítmény között, az a tény, hogy különböző interfészeket implementáló különböző objektumokat implementálhat és regisztrálhat, kihívást jelentő feladattá teszi a megosztást. Segítség nélkül szüksége lenne arra, hogy az egyik bővítményt átadhassa a másiknak az információk megosztásához, ami bonyolítja a kialakítást.

Ezért a tesztelési platform kifinomult módszert kínál több bővítménypont azonos típusú implementálásához, így az adatmegosztás egyszerű feladat. Mindössze annyit kell tennie, hogy a CompositeExtensionFactory<T>-t használja, amelyet aztán ugyanazzal az API-val lehet regisztrálni, mint egy felület implementációjához.

Vegyük például azt a típust, amely ITestSessionLifetimeHandler és IDataConsumeris implementál. Ez egy gyakori forgatókönyv, mert gyakran szeretne adatokat gyűjteni a tesztelési keretrendszerből, majd amikor a tesztelési munkamenet befejeződik, az összetevőt a IMessageBusITestSessionLifetimeHandler.OnTestSessionFinishingAsync használatával küldi el.

A felületeket általában a következő módon kell implementálni:

internal class CustomExtension : ITestSessionLifetimeHandler, IDataConsumer, ...
{
   ...
}

Miután létrehozta a típusához tartozó CompositeExtensionFactory<CustomExtension>-t, regisztrálhatja azt a IDataConsumer- és ITestSessionLifetimeHandler-API-kkal is, amelyek túlterhelési lehetőséget kínálnak a CompositeExtensionFactory<T>számára.

var builder = await TestApplication.CreateBuilderAsync(args);

// ...

var factory = new CompositeExtensionFactory<CustomExtension>(serviceProvider => new CustomExtension());

builder.TestHost.AddTestSessionLifetimeHandle(factory);
builder.TestHost.AddDataConsumer(factory);

A gyári konstruktor az IServiceProvider használja a tesztelési platform által biztosított szolgáltatások elérésére.

Az összetett bővítmény életciklusának kezeléséért a tesztelési platform felel.

Fontos megjegyezni, hogy mivel a tesztelési platform támogatja a folyamatban lévő és folyamaton kívüli bővítményeket, nem kombinálhat tetszőlegesen egy bővítménypontot sem. A bővítmények létrehozása és használata a gazdagép típusán múlik, ami azt jelenti, hogy csak folyamaton belüli (TestHost) és folyamaton kívüli (TestHostController) bővítményeket lehet együtt csoportosítani.

A következő kombinációk lehetségesek:

A ITestApplicationBuilder.TestHostesetében a IDataConsumer és ITestSessionLifetimeHandlerkombinálhatók össze.
A ITestApplicationBuilder.TestHostControllersesetében a ITestHostEnvironmentVariableProvider és ITestHostProcessLifetimeHandlerkombinálhatók össze.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-03-11

Megosztás a következőn keresztül:

Bővítmények létrehozása a Microsoft.Testing.Platformhoz

Bővíthetőségi pontok

A ICommandLineOptionsProvider bővítmények

A ITestSessionLifetimeHandler bővítmények

A ITestApplicationLifecycleCallbacks bővítmények

A IDataConsumer bővítmények

A ITestHostEnvironmentVariableProvider bővítmények

A ITestHostProcessLifetimeHandler bővítmények

Bővítmények végrehajtási sorrendje

Kiterjesztések segítői

Bővítmények aszinkron inicializálása és törlése

A CompositeExtensionFactory<T>

Visszajelzés

További források

A `ICommandLineOptionsProvider` bővítmények

A `ITestSessionLifetimeHandler` bővítmények

A `ITestApplicationLifecycleCallbacks` bővítmények

A `IDataConsumer` bővítmények

A `ITestHostEnvironmentVariableProvider` bővítmények

A `ITestHostProcessLifetimeHandler` bővítmények