using System.Runtime.CompilerServices;

using Foo;

using MassTransit;

using MassTransit.Testing;

using Microsoft.Extensions.DependencyInjection;

using System;

​

var shouldThrowOnAssert = true;

​

var serviceCollection = new ServiceCollection()

  .AddMassTransitTestHarness(cfg =>

  {

    cfg

      .AddSagaStateMachine<Machine, MachineState>()

      .InMemoryRepository();

    cfg

      .UsingInMemory((ctx, conf) => conf.ConfigureEndpoints(ctx));

  });

​

var provider = serviceCollection.BuildServiceProvider(true);

var testHarness = provider.GetTestHarness();

await testHarness.Start();

var sagaHarness = testHarness.GetSagaStateMachineHarness<Machine, MachineState>();

​

var id = Guid.NewGuid();

​

try

{

  await testHarness.Bus.Publish(new MessageA(id));

  AssertTrue(await sagaHarness.Created.Any(x => x.CorrelationId == id));

  AssertTrue(await testHarness.Consumed.Any<MessageA>());

  AssertTrue(sagaHarness.Created.Count() == 1);

​

  await testHarness.Bus.Publish(new MessageB(id));

  AssertTrue(await testHarness.Consumed.Any<MessageB>());

  AssertTrue(sagaHarness.Created.Count() == 1);

​

  await testHarness.Bus.Publish(new MessageC(id));

  AssertTrue(await testHarness.Consumed.Any<MessageC>());

  AssertTrue(sagaHarness.Created.Count() == 1);

}

finally

{

  await testHarness.OutputTimeline(Console.Out);

}

​

void AssertTrue(

  bool t,

  [CallerArgumentExpression("t")] string? tExpression = null)

{

  if (!t)

  {

    var msg = $"Expected \"{tExpression}\" to be true";

    if (shouldThrowOnAssert) throw new Exception(msg);

    else Console.WriteLine(msg);

  }

}

​

namespace Foo

{

​

  public class MachineState : SagaStateMachineInstance

  {

    public State CurrentState { get; set; }

    public Guid CorrelationId { get; set; }

  }

​

  public record MessageA(Guid CorrelationId);

​

  public record MessageB(Guid CorrelationId);

​

  public record MessageC(Guid CorrelationId);

​

  public class Machine : MassTransitStateMachine<MachineState>

  {

    public Machine()

    {

      InstanceState(x => x.CurrentState);

​

      Event(() => OnMessageA, x => x.CorrelateById(m => m.Message.CorrelationId));

      Event(() => OnMessageB, x => x.CorrelateById(m => m.Message.CorrelationId));

      Event(() => OnMessageC, x => x.CorrelateById(m => m.Message.CorrelationId));

​

      Initially(When(OnMessageA).TransitionTo(A));

      During(A, When(OnMessageB).TransitionTo(B));

      During(B, When(OnMessageC).TransitionTo(C));

    }

​

    public State A { get; }

    public State B { get; }

    public State C { get; }

​

    public Event<MessageA> OnMessageA { get; }

    public Event<MessageB> OnMessageB { get; }

    public Event<MessageC> OnMessageC { get; }

  }

}

​