Documentation on writing unit tests for Actors that access state

[jaq316]

Documentation on writing unit tests, specifically for Actors accessing state would be great.

The below code, for instance, would throw: "InvalidOperationException: The actor was initialized without a state provider, and so cannot interact with state. If this is inside a unit test, replace Actor.StateProvider with a mock."

    internal class MyActor : Actor, IMyActor
    {

        private const string STATE_KEY = "counter";

        public MyActor(ActorHost host) // Accept ActorHost in the constructor
            : base(host) // Pass ActorHost to the base class constructor
        {
        }

        public async Task<int> GetCounter()
        {
            var iCounterState  =(await StateManager.TryGetStateAsync<int>(STATE_KEY).ConfigureAwait(false));
            return iCounterState.Value;
        }
        public async Task Increment()
        {
            var iCounterState = (await StateManager.TryGetStateAsync<int>(STATE_KEY).ConfigureAwait(false));
            if (iCounterState.HasValue)
            {
                await StateManager.SetStateAsync(STATE_KEY, iCounterState.Value + 1).ConfigureAwait(false);
            }
            else
            {
                await StateManager.SetStateAsync(STATE_KEY, 1).ConfigureAwait(false);
            }   
            
        }

    }

    public class MyActorTests
    {
        [Fact]
        public async Task SomeMethod_ShouldSucceed()
        {
            // Arrange
            var actorId = new ActorId("test");
            var host = ActorHost.CreateForTest<MyActor>(new ActorTestOptions
            {
                ActorId = actorId
            });

            var myActor = new MyActor(host);

            // Act
            await myActor.Increment();

            var counter = myActor.GetCounter();
            // Assert
            Assert.AreEqual(1, counter);

        }
    }

[jaq316]

https://github.com/dapr/dotnet-sdk/blob/3b979e6bdb1d779563f1656fa684183b2bfecd08/test/Dapr.Actors.Test/ITestActor.cs#L47C31-L47C31 implements overriding of the StateManager by providing an optional IStateManager parameter in the constructor. If that is provided, this.StateManager is set in the constructor.

[paule96]

@jaq316 is this a recommendation to provide an IActorStartManager parameter in every actor, so it is testable?
That sounds kinda strange because in the real world the Actors doesn't need this injecten

[FullStackChef]

In case it's useful to anyone else, my approach to this was as follows:

internal class TestUserStateActor : UserStateActor
{
    private Dictionary<string, UserState> _state = [];
    public static TestUserStateActor CreateTestActor()
    {
        var actorHost = ActorHost.CreateForTest<UserStateActor>();
        return new TestUserStateActor(actorHost);
    }
    private TestUserStateActor(ActorHost host) : base(host)
    {
        Mock<IActorStateManager> mockStateManager = new();

        mockStateManager
            .Setup(m => m.SetStateAsync(It.IsAny<string>(), It.IsAny<UserState>(), default))
            .Callback((string key, UserState value, CancellationToken _) => _state[key] = value);

        mockStateManager
            .Setup(m => m.GetStateAsync<UserState>(It.IsAny<string>(), default))
            .ReturnsAsync((string key, CancellationToken _) => _state[key]);

        mockStateManager
            .Setup(m => m.TryGetStateAsync<UserState>(It.IsAny<string>(), default))
            .ReturnsAsync((string key, CancellationToken _) =>
            {
                if (_state.TryGetValue(key, out UserState? value))
                {
                    return new ConditionalValue<UserState>(true, value);
                }
                return new ConditionalValue<UserState>();
            });

        mockStateManager
            .Setup(m => m.ContainsStateAsync(It.IsAny<string>(), default))
            .ReturnsAsync((string key, CancellationToken _) => _state.ContainsKey(key));

        StateManager = mockStateManager.Object;
    }
}