Skip to content

Convert Akka.TestKit.Tests to async - NoImplicitSenderSpec TestSchedulerSpec #5853

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Apr 19, 2022
Merged

Convert Akka.TestKit.Tests to async - NoImplicitSenderSpec TestSchedulerSpec #5853

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions src/core/Akka.TestKit.Tests/NoImplicitSenderSpec.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,57 +5,57 @@
// </copyright>
//-----------------------------------------------------------------------

using System.Threading.Tasks;
using Akka.Actor;
using Akka.TestKit;
using Akka.Actor.Dsl;
using Xunit;

namespace Akka.Testkit.Tests
namespace Akka.TestKit.Tests
{
public class NoImplicitSenderSpec : AkkaSpec, INoImplicitSender
{
[Fact(Skip = "Type assertion on null message causes NullReferenceException")]
public void When_Not_ImplicitSender_then_testActor_is_not_sender()
public async Task When_Not_ImplicitSender_then_testActor_is_not_sender()
{
var echoActor = Sys.ActorOf(c => c.ReceiveAny((m, ctx) => TestActor.Tell(ctx.Sender)));
echoActor.Tell("message");
ExpectMsg<IActorRef>(actorRef => Equals(actorRef, ActorRefs.NoSender));
await ExpectMsgAsync<IActorRef>(actorRef => Equals(actorRef, ActorRefs.NoSender));
}

}

public class ImplicitSenderSpec : AkkaSpec
{
[Fact]
public void ImplicitSender_should_have_testActor_as_sender()
public async Task ImplicitSender_should_have_testActor_as_sender()
{
var echoActor = Sys.ActorOf(c => c.ReceiveAny((m, ctx) => TestActor.Tell(ctx.Sender)));
echoActor.Tell("message");
ExpectMsg<IActorRef>(actorRef => Equals(actorRef, TestActor));
await ExpectMsgAsync<IActorRef>(actorRef => Equals(actorRef, TestActor));

//Test that it works after we know that context has been changed
echoActor.Tell("message");
ExpectMsg<IActorRef>(actorRef => Equals(actorRef, TestActor));
await ExpectMsgAsync<IActorRef>(actorRef => Equals(actorRef, TestActor));

}


[Fact]
public void ImplicitSender_should_not_change_when_creating_Testprobes()
public async Task ImplicitSender_should_not_change_when_creating_Testprobes()
{
//Verifies that bug #459 has been fixed
var testProbe = CreateTestProbe();
TestActor.Tell("message");
ReceiveOne();
await ReceiveOneAsync();
LastSender.ShouldBe(TestActor);
}

[Fact]
public void ImplicitSender_should_not_change_when_creating_TestActors()
public async Task ImplicitSender_should_not_change_when_creating_TestActors()
{
var testActor2 = CreateTestActor("test2");
TestActor.Tell("message");
ReceiveOne();
await ReceiveOneAsync();
LastSender.ShouldBe(TestActor);
}
}
Expand Down
51 changes: 26 additions & 25 deletions src/core/Akka.TestKit.Tests/TestSchedulerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
//-----------------------------------------------------------------------

using System;
using System.Threading.Tasks;
using Akka.Actor;
using Akka.TestKit.Configs;
using Xunit;
Expand All @@ -24,88 +25,88 @@ public TestSchedulerTests()
}

[Fact]
public void Delivers_message_when_scheduled_time_reached()
public async Task Delivers_message_when_scheduled_time_reached()
{
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(1)));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.Advance(TimeSpan.FromSeconds(1));
ExpectMsg<ScheduleOnceMessage>();
await ExpectMsgAsync<ScheduleOnceMessage>();
}

[Fact]
public void Does_not_deliver_message_prematurely()
public async Task Does_not_deliver_message_prematurely()
{
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(1)));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.Advance(TimeSpan.FromMilliseconds(999));
ExpectNoMsg(TimeSpan.FromMilliseconds(20));
await ExpectNoMsgAsync(TimeSpan.FromMilliseconds(20));
}

[Fact]
public void Delivers_messages_scheduled_for_same_time_in_order_they_were_added()
public async Task Delivers_messages_scheduled_for_same_time_in_order_they_were_added()
{
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(1), 1));
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(1), 2));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.Advance(TimeSpan.FromSeconds(1));
var firstId = ExpectMsg<ScheduleOnceMessage>().Id;
var secondId = ExpectMsg<ScheduleOnceMessage>().Id;
var firstId = (await ExpectMsgAsync<ScheduleOnceMessage>()).Id;
var secondId = (await ExpectMsgAsync<ScheduleOnceMessage>()).Id;
Assert.Equal(1, firstId);
Assert.Equal(2, secondId);
}

[Fact]
public void Keeps_delivering_rescheduled_message()
public async Task Keeps_delivering_rescheduled_message()
{
_testReceiveActor.Tell(new RescheduleMessage(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5)));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

for (int i = 0; i < 500; i ++)
{
Scheduler.Advance(TimeSpan.FromSeconds(5));
ExpectMsg<RescheduleMessage>();
await ExpectMsgAsync<RescheduleMessage>();
}
}

[Fact]
public void Uses_initial_delay_to_schedule_first_rescheduled_message()
public async Task Uses_initial_delay_to_schedule_first_rescheduled_message()
{
_testReceiveActor.Tell(new RescheduleMessage(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5)));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.Advance(TimeSpan.FromSeconds(1));
ExpectMsg<RescheduleMessage>();
await ExpectMsgAsync<RescheduleMessage>();
}

[Fact]
public void Doesnt_reschedule_cancelled()
public async Task Doesnt_reschedule_cancelled()
{
_testReceiveActor.Tell(new CancelableMessage(TimeSpan.FromSeconds(1)));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.Advance(TimeSpan.FromSeconds(1));
ExpectMsg<CancelableMessage>();
await ExpectMsgAsync<CancelableMessage>();
_testReceiveActor.Tell(new CancelMessage());
Scheduler.Advance(TimeSpan.FromSeconds(1));
ExpectNoMsg(TimeSpan.FromMilliseconds(20));
await ExpectNoMsgAsync(TimeSpan.FromMilliseconds(20));
}


[Fact]
public void Advance_to_takes_us_to_correct_time()
public async Task Advance_to_takes_us_to_correct_time()
{
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(1), 1));
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(2), 2));
_testReceiveActor.Tell(new ScheduleOnceMessage(TimeSpan.FromSeconds(3), 3));
_testReceiveActor.AskAndWait<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started
await _testReceiveActor.Ask<ActorIdentity>(new Identify(null), RemainingOrDefault); // verify that the ActorCell has started

Scheduler.AdvanceTo(Scheduler.Now.AddSeconds(2));
var firstId = ExpectMsg<ScheduleOnceMessage>().Id;
var secondId = ExpectMsg<ScheduleOnceMessage>().Id;
ExpectNoMsg(TimeSpan.FromMilliseconds(20));
var firstId = (await ExpectMsgAsync<ScheduleOnceMessage>()).Id;
var secondId = (await ExpectMsgAsync<ScheduleOnceMessage>()).Id;
await ExpectNoMsgAsync(TimeSpan.FromMilliseconds(20));
Assert.Equal(1, firstId);
Assert.Equal(2, secondId);
}
Expand Down