C# Akka.net-尝试测试重复的计划消息

我正在使用.NETCore开发Akka.net系统，并编写了一个特性，其中一个参与者使用调度器每24小时执行一个进程

我想对此进行单元测试，但当然测试需要快速运行。我试图使用Akka.TestKit TestScheduler来人为地提前时间，但示例似乎很难获得。我的代码与标准调度程序一起工作，但我无法让TestScheduler工作

我将我的过程提炼为一个简单的参与者和两个单元测试（见下面的代码）。一个是使用标准调度程序成功运行的测试。另一个使用TestScheduler运行，但失败。参与者没有收到来自TestScheduler的消息，我不确定我可能做错了什么，或者如何进一步调试

任何帮助都将不胜感激

using System;
using System.Linq;
using Akka.Actor;
using Akka.TestKit;
using Akka.TestKit.Xunit2;
using Xunit;

namespace akkaSchedulerTest.Test
{
    // Requires Nuget Package "Akka.TestKit.Xunit2" (version 1.3.11 at the time this was written)


    public class RepeatedScheduleTest_Standard_Scheduler : TestKit
    {
        /// <summary>
        /// This test passes
        /// </summary>
        [Fact]
        public void Sender_Actor_Sends_Out_Message_Expected_Number_Of_Times()
        {
            var interval = TimeSpan.FromSeconds(1);
            var testDuration = TimeSpan.FromSeconds(2.1);
            int expectedMessageCount = 2;

            var recipientActorRef = this.TestActor;
            var messageText = "Message";

            var senderActor = Sys.ActorOf(Props.Create(() => new RepeatedMessageSenderActor(recipientActorRef, messageText, interval)));

            // verify that the other actor receives the right number of messages over the expected time
            var allExpectedMessages = Enumerable.Repeat(messageText, expectedMessageCount).ToArray();
            ExpectMsgAllOf(testDuration, allExpectedMessages);
        }
    }

    public class RepeatedScheduleTest_Test_Scheduler : TestKit
    {
        // REF: https://petabridge.com/blog/how-to-unit-test-akkadotnet-actors-akka-testkit/#how-do-i-test-scheduled-messages

        public RepeatedScheduleTest_Test_Scheduler()
            : base(@"akka.scheduler.implementation = ""Akka.TestKit.TestScheduler, Akka.TestKit""") { }

        private TestScheduler Scheduler => (TestScheduler)Sys.Scheduler;

        /// <summary>
        /// This test fails with the error:
        /// Timeout (00:00:03) while expecting 5 messages. Only got 0 after 00:00:02.9992044.
        /// In realtime it should last many hours. This is an attempt to verify the scheduled behavior in a quick test.
        /// </summary>
        [Fact]
        public void Sender_Actor_Sends_Out_Message_Expected_Number_Of_Times()
        {
            var interval = TimeSpan.FromHours(1);
            var testDuration = TimeSpan.FromHours(5.1);
            int expectedMessageCount = 5;

            var recipientActorRef = this.TestActor;
            var messageText = "Message";

            var senderActor = Sys.ActorOf(Props
                .Create(() => new RepeatedMessageSenderActor(recipientActorRef, messageText, interval))
                .WithDispatcher(CallingThreadDispatcher.Id));

            // advance the TestScheduler by enough time that the repeated messages should be processed
            Scheduler.Advance(testDuration);

            // verify that the other actor receives the right number of messages over the expected time
            var allExpectedMessages = Enumerable.Repeat(messageText, expectedMessageCount).ToArray();
            ExpectMsgAllOf(allExpectedMessages);
        }
    }

    public class RepeatedMessageSenderActor : ReceiveActor
    {
        private readonly IActorRef _recipientActorRef;
        private readonly string _messageText;
        private readonly TimeSpan _interval;

        public RepeatedMessageSenderActor(IActorRef recipientActorRef, string messageText, TimeSpan interval)
        {
            _recipientActorRef = recipientActorRef;
            _messageText = messageText;
            _interval = interval;

            Receive<SendOutMessage>(msg => HandleSendOutMessage());

            // use the scheduler to repeatedly tell this actor to send out a message at a regular interval
            Context.System.Scheduler
                .ScheduleTellRepeatedly(_interval, _interval, Self, new SendOutMessage(), Self);
        }

        /// <summary>
        /// in the failing test, this method never gets called
        /// </summary>
        private void HandleSendOutMessage()
        {
            _recipientActorRef.Tell(_messageText);
        }

        public class SendOutMessage { }
    }
}

使用系统；
使用System.Linq；
使用Akka.Actor；
使用Akka.TestKit；
使用Akka.TestKit.Xunit2；
使用Xunit；
命名空间akkaSchedulerTest.Test
{
//需要Nuget包“Akka.TestKit.Xunit2”（编写此文件时的版本为1.3.11）
公共类RepeatedScheduleTest_Standard_调度程序：TestKit
{
/// 
///这个测试通过了
/// 
[事实]
公共无效发送者\u参与者\u发送\u消息\u预期\u次数\u次数（）
{
var间隔=从秒开始的时间跨度（1）；
var testDuration=TimeSpan.FromSeconds（2.1）；
int expectedMessageCount=2；
var recipientActorRef=this.TestActor；
var messageText=“Message”；
var senderActor=Sys.ActorOf（Props.Create（（）=>newrepeatedmessagesenderActor（recipientActorRef，messageText，interval））；
//验证其他参与者在预期时间内收到的消息数量是否正确
var allExpectedMessages=Enumerable.Repeat（messageText，expectedMessageCount）.ToArray（）；
ExpectmGallof（测试持续时间，所有预期消息）；
}
}
公共类RepeatedScheduleTest\u Test\u调度程序：TestKit
{
//参考：https://petabridge.com/blog/how-to-unit-test-akkadotnet-actors-akka-testkit/#how-do-i-test-scheduled-messages
公共RepeatedScheduleTest\u Test\u调度程序（）
：base（@“akka.scheduler.implementation=”“akka.TestKit.TestScheduler，akka.TestKit”“”）{}
私有TestScheduler=>（TestScheduler）Sys.Scheduler；
/// 
///此测试失败，错误如下：
///等待5条消息时超时（00:00:03）。仅在00:00:02.9992044之后获得0。
///实时测试应该持续数小时。这是在快速测试中验证计划行为的尝试。
/// 
[事实]
公共无效发送者\u参与者\u发送\u消息\u预期\u次数\u次数（）
{
var间隔=从小时开始的时间跨度（1）；
var testDuration=TimeSpan.FromHours（5.1）；
int expectedMessageCount=5；
var recipientActorRef=this.TestActor；
var messageText=“Message”；
var senderActor=Sys.ActorOf（Props
.创建（（）=>新的RepeatedMessageSenderActor（recipientActorRef、messageText、interval））
.WithDispatcher（callingReadDispatcher.Id））；
//将TestScheduler提前足够的时间以处理重复的消息
调度程序.Advance（testDuration）；
//验证其他参与者在预期时间内收到的消息数量是否正确
var allExpectedMessages=Enumerable.Repeat（messageText，expectedMessageCount）.ToArray（）；
预期加仑（所有预期消息）；
}
}
公共类RepeatedMessagesEndactor:ReceiveActor
{
私有只读IActorRef_recipientActorRef；
私有只读字符串_messageText；
专用只读时间间隔；
公共RepeatedMessageSenderActor（IActorRef recipientActorRef、字符串messageText、TimeSpan间隔）
{
_recipientActorRef=recipientActorRef；
_messageText=messageText；
_间隔=间隔；
接收（msg=>HandleSendOutMessage（））；
//使用调度程序反复告诉此参与者以固定间隔发送消息
Context.System.Scheduler
.scheduleTells（_interval，_interval，Self，new SendOutMessage（），Self）；
}
/// 
///在失败的测试中，从未调用此方法
/// 
私有void HandleSendOutMessage（）
{
_recipientActorRef.Tell（_messageText）；
}
公共类SendOutMessage{}
}
}

您提前了计划程序。在您可以安全地开始玩时间游戏之前，您必须确保操作是实际安排的

---

在这里，您可以找到一种修复示例的方法

是否有其他方法来确保消息已安排？向另一个不使用“初始化”消息的参与者发送“初始化”消息似乎有点武断。