Testowanie jednostkowe z Orleans

W tym samouczku pokazano, jak testować ziarna, aby upewnić się, że działają prawidłowo. Istnieją dwa główne sposoby testowania ziarna, a wybrana metoda zależy od typu testowych funkcji. Użyj pakietu NuGet Microsoft.TestingHost do tworzenia silosów testowych dla grains, lub użyj frameworku do pozorowania, takiego jak Moq, aby symulować części środowiska uruchomieniowego, z którymi współdziała grain.

Użyj TestCluster

Pakiet Microsoft.Orleans.TestingHost NuGet zawiera TestCluster, którego można użyć do utworzenia klastra w pamięci (składającego się domyślnie z dwóch silosów) do testowania ziaren.

using Orleans.TestingHost;

namespace Tests;

public class HelloGrainTests
{
    [Fact]
    public async Task SaysHelloCorrectly()
    {
        var builder = new TestClusterBuilder();
        var cluster = builder.Build();
        cluster.Deploy();

        var hello = cluster.GrainFactory.GetGrain<IHelloGrain>(Guid.NewGuid());
        var greeting = await hello.SayHello("World");

        cluster.StopAllSilos();

        Assert.Equal("Hello, World!", greeting);
    }
}

Ze względu na obciążenie związane z uruchamianiem klastra w pamięci, warto utworzyć TestCluster i użyć go ponownie w wielu testach. Na przykład można to osiągnąć przy użyciu klasowych lub kolekcyjnych fixtureów xUnit.

Aby udostępnić TestCluster między wieloma przypadkami testowymi, najpierw utwórz typ fikstury.

using Orleans.TestingHost;

public sealed class ClusterFixture : IDisposable
{
    public TestCluster Cluster { get; } = new TestClusterBuilder().Build();

    public ClusterFixture() => Cluster.Deploy();

    void IDisposable.Dispose() => Cluster.StopAllSilos();
}

Następnie utwórz oprawę kolekcji:

[CollectionDefinition(Name)]
public sealed class ClusterCollection : ICollectionFixture<ClusterFixture>
{
    public const string Name = nameof(ClusterCollection);
}

Teraz możesz ponownie użyć elementu TestCluster w swoich przypadkach testowych:

using Orleans.TestingHost;

namespace Tests;

[Collection(ClusterCollection.Name)]
public class HelloGrainTestsWithFixture(ClusterFixture fixture)
{
    private readonly TestCluster _cluster = fixture.Cluster;

    [Fact]
    public async Task SaysHelloCorrectly()
    {
        var hello = _cluster.GrainFactory.GetGrain<IHelloGrain>(Guid.NewGuid());
        var greeting = await hello.SayHello("World");

        Assert.Equal("Hello, World!", greeting);
    }
}

Po zakończeniu wszystkich testów i zatrzymaniu silosów klastra w pamięci funkcja xUnit wywołuje metodę Dispose()ClusterFixture typu . TestCluster Ma również konstruktor akceptujący TestClusterOptions , którego można użyć do skonfigurowania silosów w klastrze.

Jeśli używasz iniekcji zależności w swoim silosie, aby udostępniać usługi Grains, możesz także zastosować ten wzorzec:

using Microsoft.Extensions.DependencyInjection;
using Orleans.TestingHost;

namespace Tests;

public sealed class ClusterFixtureWithConfig : IDisposable
{
    public TestCluster Cluster { get; } = new TestClusterBuilder()
        .AddSiloBuilderConfigurator<TestSiloConfigurations>()
        .Build();

    public ClusterFixtureWithConfig() => Cluster.Deploy();

    void IDisposable.Dispose() => Cluster.StopAllSilos();
}

file sealed class TestSiloConfigurations : ISiloConfigurator
{
    public void Configure(ISiloBuilder siloBuilder)
    {
        siloBuilder.ConfigureServices(static services =>
        {
            // TODO: Call required service registrations here.
            // services.AddSingleton<T, Impl>(/* ... */);
        });
    }
}

Używaj mocków

Orleans umożliwia również wyśmiewanie wielu części systemu. W przypadku wielu scenariuszy jest to najprostszy sposób na jednostkowe testowanie "grains". Takie podejście ma ograniczenia (np. dotyczące planowania ponownego wchodzenia do funkcji i serializacji) i może wymagać od grających włączenia kodu używanego wyłącznie do testów jednostkowych. ZestawOrleans TestKit zapewnia alternatywne podejście, które pomija wiele z tych ograniczeń.

Załóżmy na przykład, że testowane ziarno współdziała z innymi ziarnami. Aby stworzyć atrapę dla innych ziaren, musisz również stworzyć atrapę dla członka GrainFactory ziarna poddawanego testom. Domyślnie GrainFactory jest to normalna protected właściwość, ale większość frameworków do mockowania wymaga, aby właściwości były public i virtual, aby umożliwić mockowanie. W związku z tym pierwszym krokiem jest wykonanie zarówno GrainFactory, jak i public oraz virtual.

public new virtual IGrainFactory GrainFactory
{
    get => base.GrainFactory;
}

Teraz możesz utworzyć ziarno poza Orleans środowiskiem uruchomieniowym i użyć pozorowania, aby kontrolować zachowanie elementu GrainFactory:

using Xunit;
using Moq;

namespace Tests;

public class WorkerGrainTests
{
    [Fact]
    public async Task RecordsMessageInJournal()
    {
        var data = "Hello, World";
        var journal = new Mock<IJournalGrain>();
        var worker = new Mock<WorkerGrain>();
        worker
            .Setup(x => x.GrainFactory.GetGrain<IJournalGrain>(It.IsAny<Guid>()))
            .Returns(journal.Object);

        await worker.DoWork(data)

        journal.Verify(x => x.Record(data), Times.Once());
    }
}

W tym miejscu, za pomocą Moq, utwórz testowane ziarno WorkerGrain. Dzięki temu można zastąpić zachowanie GrainFactory, aby zwracało ono mockowany element IJournalGrain. Następnie możesz sprawdzić, czy WorkerGrain współdziała z IJournalGrain zgodnie z oczekiwaniami.