Testing a KernelProcessStep in isolation for emitting Events

[mand-jyskebank-dk]

I am trying to wrap my head around on how to best test a KernelProcessStep in isolation.

I would like to test that my KernelProcessStep emits a specific event and event arguments

I came up with the following code, but is left with a few questions:

• Is this really the most efficient way to test this? It seems like an awfull lot of code
• How can I obtain af reference to the Event Id (PartialResponseGenerated ) being emitted from MyStep in my ReportStep?

Any help is greatly appreciated

public class MyProcessStepEvents
{
    public const string Start = "Start";
    public const string PartialResponseGenerated = "PartialResponseGenerated";
}

public class MyStep : KernelProcessStep
{
    [KernelFunction]
    public async ValueTask ExecuteAsync(KernelProcessStepContext context, string input)
    {
        var result = input + " - Processed by MyToolStep";

        await context.EmitEventAsync(new KernelProcessEvent()
        {
            Id = MyProcessStepEvents.PartialResponseGenerated,
            Data = result
        });
    }
}

public class MyStepTest
{
    private string prompt = "Sun makes me happy. Rain makes me happy to.";

    [Fact]
    public async Task TestMyStepEmitsEventWithProcessedResponse()
    {

        // Arrange 
        var kernelBuilder = Kernel.CreateBuilder();
        var kernel = kernelBuilder.Build();
        ProcessBuilder processBuilder = new("TestMyToolStepEmitsEventWithGeneratedResponse");
        var sutStep = processBuilder.AddStepFromType<MyStep>();
        var echoStep = processBuilder.AddStepFromType<ReportStep>();

        processBuilder
        .OnInputEvent(MyProcessStepEvents.Start)
        .SendEventTo(new ProcessFunctionTargetBuilder(sutStep, "Execute"));

        sutStep
        .OnEvent(MyProcessStepEvents.PartialResponseGenerated)
        .SendEventTo(new ProcessFunctionTargetBuilder(echoStep, "Execute"));

        // Act 
        var process = processBuilder.Build();
        var result = await process.StartAsync(kernel, new KernelProcessEvent
        {
            Id = MyProcessStepEvents.Start,
            Data = prompt
        });

        var processState = await result.GetStateAsync();
        var echoProcessStepState = ((KernelProcessStepState<StepState>)processState.Steps.FirstOrDefault(s => s.InnerStepType.Equals(typeof(ReportStep)))!.State!).State;

        // Assert
        Assert.Equal($"{prompt} - Processed by MyToolStep", echoProcessStepState!.LastMessage);
        Assert.Equal(1, echoProcessStepState!.InvocationCount);
    }
    public class ReportStep : KernelProcessStep<StepState>
    {
        private StepState _state = new StepState();
        public override ValueTask ActivateAsync(KernelProcessStepState<StepState> state)
        {
            _state = state.State ?? new StepState();
            return ValueTask.CompletedTask;
        }
        [KernelFunction]
        public async ValueTask ExecuteAsync(KernelProcessStepContext context, string message)
        {
            _state.InvocationCount++;
            _state.LastMessage = message;
            await context.EmitEventAsync(new KernelProcessEvent
            {
                Id = MyProcessStepEvents.PartialResponseGenerated,
                Data = _state.LastMessage
            });
        }
    }
    public class StepState
    {
        public int InvocationCount { get; set; } = 0;
        public string? LastMessage { get; set; } = null;
    }
}