Best way to mix Akka.Net and Specflow ReqNroll

[andre-steenbergen]

I used to test with TestKit and BDDfy, but BDDFy seems like an abandoned project now, and I have been missing hooks from the start. At this moment I have a working test package. But I am wondering if this is the best way to go.

I am using Reqnroll.Microsoft.Extensions.DependencyInjection to register a scoped HostBuilder.

In the hooks I am checking the When steps:

        [BeforeStep]
        public async Task BeforeWhenStepMakeSureEventsArePersisted()
        {
            if (scenarioContext.CurrentScenarioBlock == ScenarioBlock.When && !whenStepReceived)
            {
                whenStepReceived = true;

where I am persisting all events gathered in Given steps. and start the system

//create test probe
                var system = akkaHost.Services.GetService<ActorSystem>();
                var testProbe = new TestProbe(system, new XunitAssertions(), "JournalWriter");
                
                // persist all events
                var journalRef = Persistence.Instance.Apply(system).JournalFor(string.Empty);
                foreach (var (pid, events) in EventsToPersist)
                {
                    var seqNrCounter = new AtomicCounterLong(1L);
                    var persistents = events
                        .Select(e =>  new Persistent(e, seqNrCounter.GetAndIncrement(), pid, e.GetType().FullName))
                        .ToArray();
                    journalRef.Tell(new WriteMessages(persistents.Select(x => new AtomicWrite(x)), testProbe, 1));

                    testProbe.ExpectMsg<WriteMessagesSuccessful>();
                    foreach (var p in persistents)
                        testProbe.ExpectMsg(new WriteMessageSuccess(p, 1));    
                }
                
                //start actor system
                await akkaHost.StartAsync();

followed by:

[AfterScenario]
        public async Task StopActorSystemInScenarioContext()
        {
            await akkaHost.StopAsync();
        }

So I know the Akka Host is closed again.

In my step definitions I then use the dependency injector from ReqnRoll to inject and register the service provider:

    public OrderIntakeStepDefinitions(ScenarioContext scenarioContext, IHost akkaHost)
    {
        this.scenarioContext = scenarioContext;
        serviceProvider = akkaHost.Services;
        actorRegistry = serviceProvider.GetService<ActorRegistry>();
        
        if (scenarioContext.TryGetValue("WriteEvents", out Action<string, object[]> evts))
        {
            writeEvents = evts;
        }
    }

What do you think of this angle of approach?

Is there something I am missing?

[andre-steenbergen]

Oh and also the dependency config: It is here where I register my MessageRouter and a Saga actor, checking persisted events and raising commands of it's own.

[ScenarioDependencies]
    public static IServiceCollection CreateServices()
    {
        var serviceCollection = new ServiceCollection();
        
        serviceCollection.AddScoped(_ =>
            {
                var hostBuilder = new HostBuilder();
                
                hostBuilder.ConfigureServices((context, services) =>
                {
                    services.AddSingleton(sp =>
                    {
                        var system = sp.GetService<ActorSystem>();
                        var journalProvider = new InMemoryReadJournalProvider(
                            system.AsInstanceOf<ExtendedActorSystem>(),
                            InMemoryReadJournal.DefaultConfiguration().GetConfig("akka.persistence.query.journal.inmem")
                        );
                        return journalProvider.GetReadJournal() as InMemoryReadJournal;
                    });
                    
                    services.AddAkka("MyActorSystem", (builder, sp) =>
                    {
                        builder
                            .WithInMemoryJournal()
                            .WithInMemorySnapshotStore()
                            .StartActors((system, registry, resolver) =>
                            {
                                var testProbe = new TestProbe(system, new XunitAssertions(), "TestProbe");
                                registry.Register<TestProbe>(testProbe);
                    
                                var readJournal = sp.GetService<InMemoryReadJournal>();
                                var messageRouter = system.ActorOf(MessageRouter.GetProps());
                                registry.Register<MessageRouter>(messageRouter);
                
                                //see: https://getakka.net/articles/actors/dependency-injection.html
                                //important part: DependencyResolver.For
                                var approver = system.ActorOf(resolver.Props<Approver>(readJournal));
                                registry.Register<Approver>(approver);
                            });
                
                    });
                });
                return hostBuilder.Build();
            }
        ); 
        
        return serviceCollection;
    }