Skip to content

Commit fed6ecb

Browse files
authored
Port Akka.Tests.Actor tests to async/await - DeadLetter*Spec (#5771)
1 parent 77e1ef1 commit fed6ecb

File tree

2 files changed

+41
-39
lines changed

2 files changed

+41
-39
lines changed

src/core/Akka.Tests/Actor/DeadLetterSupressionSpec.cs

Lines changed: 26 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
using Xunit;
1414
using FluentAssertions;
1515
using FluentAssertions.Extensions;
16+
using System.Threading.Tasks;
1617

1718
namespace Akka.Tests.Actor
1819
{
@@ -45,7 +46,7 @@ public DeadLetterSupressionSpec()
4546
}
4647

4748
[Fact]
48-
public void Must_suppress_message_from_default_dead_letters_logging_sent_to_deadActor()
49+
public async Task Must_suppress_message_from_default_dead_letters_logging_sent_to_deadActor()
4950
{
5051
var deadListener = CreateTestProbe();
5152
Sys.EventStream.Subscribe(deadListener.Ref, typeof(DeadLetter));
@@ -59,46 +60,46 @@ public void Must_suppress_message_from_default_dead_letters_logging_sent_to_dead
5960
deadActor.Tell(new SuppressedMessage());
6061
deadActor.Tell(new NormalMessage());
6162

62-
var deadLetter = deadListener.ExpectMsg<DeadLetter>();
63+
var deadLetter = await deadListener.ExpectMsgAsync<DeadLetter>();
6364
deadLetter.Message.Should().BeOfType<NormalMessage>();
6465
deadLetter.Sender.Should().Be(TestActor);
6566
deadLetter.Recipient.Should().Be(deadActor);
66-
deadListener.ExpectNoMsg(200.Milliseconds());
67+
await deadListener.ExpectNoMsgAsync(200.Milliseconds());
6768

68-
var suppressedDeadLetter = suppressedListener.ExpectMsg<SuppressedDeadLetter>();
69+
var suppressedDeadLetter = await suppressedListener.ExpectMsgAsync<SuppressedDeadLetter>();
6970
suppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
7071
suppressedDeadLetter.Sender.Should().Be(TestActor);
7172
suppressedDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
72-
suppressedListener.ExpectNoMsg(200.Milliseconds());
73+
await suppressedListener.ExpectNoMsgAsync(200.Milliseconds());
7374

74-
var allSuppressedDeadLetter = allListener.ExpectMsg<SuppressedDeadLetter>();
75+
var allSuppressedDeadLetter = await allListener.ExpectMsgAsync<SuppressedDeadLetter>();
7576
allSuppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
7677
allSuppressedDeadLetter.Sender.Should().Be(TestActor);
7778
allSuppressedDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
7879

79-
var allDeadLetter = allListener.ExpectMsg<DeadLetter>();
80+
var allDeadLetter = await allListener.ExpectMsgAsync<DeadLetter>();
8081
allDeadLetter.Message.Should().BeOfType<NormalMessage>();
8182
allDeadLetter.Sender.Should().Be(TestActor);
8283
allDeadLetter.Recipient.Should().Be(deadActor);
8384

84-
allListener.ExpectNoMsg(200.Milliseconds());
85+
await allListener.ExpectNoMsgAsync(200.Milliseconds());
8586

8687
// unwrap for ActorSelection
8788
Sys.ActorSelection(deadActor.Path).Tell(new SuppressedMessage());
8889
Sys.ActorSelection(deadActor.Path).Tell(new NormalMessage());
8990

9091
// the recipient ref isn't the same as deadActor here so only checking the message
91-
deadLetter = deadListener.ExpectMsg<DeadLetter>();//
92+
deadLetter = await deadListener.ExpectMsgAsync<DeadLetter>();//
9293
deadLetter.Message.Should().BeOfType<NormalMessage>();
93-
suppressedDeadLetter = suppressedListener.ExpectMsg<SuppressedDeadLetter>();
94+
suppressedDeadLetter = await suppressedListener.ExpectMsgAsync<SuppressedDeadLetter>();
9495
suppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
9596

96-
deadListener.ExpectNoMsg(200.Milliseconds());
97-
suppressedListener.ExpectNoMsg(200.Milliseconds());
97+
await deadListener.ExpectNoMsgAsync(200.Milliseconds());
98+
await suppressedListener.ExpectNoMsgAsync(200.Milliseconds());
9899
}
99100

100101
[Fact]
101-
public void Must_suppress_message_from_default_dead_letters_logging_sent_to_dead_letters()
102+
public async Task Must_suppress_message_from_default_dead_letters_logging_sent_to_dead_letters()
102103
{
103104
var deadListener = CreateTestProbe();
104105
Sys.EventStream.Subscribe(deadListener.Ref, typeof(DeadLetter));
@@ -112,46 +113,46 @@ public void Must_suppress_message_from_default_dead_letters_logging_sent_to_dead
112113
Sys.DeadLetters.Tell(new SuppressedMessage());
113114
Sys.DeadLetters.Tell(new NormalMessage());
114115

115-
var deadLetter = deadListener.ExpectMsg<DeadLetter>(200.Milliseconds());
116+
var deadLetter = await deadListener.ExpectMsgAsync<DeadLetter>(200.Milliseconds());
116117
deadLetter.Message.Should().BeOfType<NormalMessage>();
117118
deadLetter.Sender.Should().Be(TestActor);
118119
deadLetter.Recipient.Should().Be(Sys.DeadLetters);
119120

120-
var suppressedDeadLetter = suppressedListener.ExpectMsg<SuppressedDeadLetter>(200.Milliseconds());
121+
var suppressedDeadLetter = await suppressedListener.ExpectMsgAsync<SuppressedDeadLetter>(200.Milliseconds());
121122
suppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
122123
suppressedDeadLetter.Sender.Should().Be(TestActor);
123124
suppressedDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
124125

125-
var allSuppressedDeadLetter = allListener.ExpectMsg<SuppressedDeadLetter>(200.Milliseconds());
126+
var allSuppressedDeadLetter = await allListener.ExpectMsgAsync<SuppressedDeadLetter>(200.Milliseconds());
126127
allSuppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
127128
allSuppressedDeadLetter.Sender.Should().Be(TestActor);
128129
allSuppressedDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
129130

130-
var allDeadLetter = allListener.ExpectMsg<DeadLetter>(200.Milliseconds());
131+
var allDeadLetter = await allListener.ExpectMsgAsync<DeadLetter>(200.Milliseconds());
131132
allDeadLetter.Message.Should().BeOfType<NormalMessage>();
132133
allDeadLetter.Sender.Should().Be(TestActor);
133134
allDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
134135

135-
Thread.Sleep(200);
136-
deadListener.ExpectNoMsg(TimeSpan.Zero);
137-
suppressedListener.ExpectNoMsg(TimeSpan.Zero);
138-
allListener.ExpectNoMsg(TimeSpan.Zero);
136+
await Task.Delay(200);
137+
await deadListener.ExpectNoMsgAsync(TimeSpan.Zero);
138+
await suppressedListener.ExpectNoMsgAsync(TimeSpan.Zero);
139+
await allListener.ExpectNoMsgAsync(TimeSpan.Zero);
139140

140141
// unwrap for ActorSelection
141142
Sys.ActorSelection(Sys.DeadLetters.Path).Tell(new SuppressedMessage());
142143
Sys.ActorSelection(Sys.DeadLetters.Path).Tell(new NormalMessage());
143144

144-
deadLetter = deadListener.ExpectMsg<DeadLetter>();
145+
deadLetter = await deadListener.ExpectMsgAsync<DeadLetter>();
145146
deadLetter.Message.Should().BeOfType<NormalMessage>();
146147
deadLetter.Sender.Should().Be(TestActor);
147148
deadLetter.Recipient.Should().Be(Sys.DeadLetters);
148-
suppressedDeadLetter = suppressedListener.ExpectMsg<SuppressedDeadLetter>();
149+
suppressedDeadLetter = await suppressedListener.ExpectMsgAsync<SuppressedDeadLetter>();
149150
suppressedDeadLetter.Message.Should().BeOfType<SuppressedMessage>();
150151
suppressedDeadLetter.Sender.Should().Be(TestActor);
151152
suppressedDeadLetter.Recipient.Should().Be(Sys.DeadLetters);
152153

153-
deadListener.ExpectNoMsg(200.Milliseconds());
154-
suppressedListener.ExpectNoMsg(200.Milliseconds());
154+
await deadListener.ExpectNoMsgAsync(200.Milliseconds());
155+
await suppressedListener.ExpectNoMsgAsync(200.Milliseconds());
155156
}
156157
}
157158
}

src/core/Akka.Tests/Actor/DeadLetterSuspensionSpec.cs

Lines changed: 15 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
//-----------------------------------------------------------------------
77

88
using System.Threading;
9+
using System.Threading.Tasks;
910
using Akka.Actor;
1011
using Akka.Configuration;
1112
using Akka.Event;
@@ -80,38 +81,38 @@ private string ExpectedUnhandledLogMessage(int count) =>
8081

8182

8283
[Fact]
83-
public void Must_suspend_dead_letters_logging_when_reaching_akka_log_dead_letters_and_then_re_enable()
84+
public async Task Must_suspend_dead_letters_logging_when_reaching_akka_log_dead_letters_and_then_re_enable()
8485
{
85-
EventFilter
86+
await EventFilter
8687
.Info(start: ExpectedDeadLettersLogMessage(1))
87-
.Expect(1, () => _deadActor.Tell(1));
88+
.ExpectAsync(1, () => _deadActor.Tell(1));
8889

89-
EventFilter
90+
await EventFilter
9091
.Info(start: ExpectedDroppedLogMessage(2))
91-
.Expect(1, () => _droppingActor.Tell(2));
92+
.ExpectAsync(1, () => _droppingActor.Tell(2));
9293

93-
EventFilter
94+
await EventFilter
9495
.Info(start: ExpectedUnhandledLogMessage(3))
95-
.Expect(1, () => _unhandledActor.Tell(3));
96+
.ExpectAsync(1, () => _unhandledActor.Tell(3));
9697

97-
EventFilter
98+
await EventFilter
9899
.Info(start: ExpectedDeadLettersLogMessage(4) + ", no more dead letters will be logged in next")
99-
.Expect(1, () => _deadActor.Tell(4));
100+
.ExpectAsync(1, () => _deadActor.Tell(4));
100101
_deadActor.Tell(5);
101102
_droppingActor.Tell(6);
102103

103104
// let suspend-duration elapse
104-
Thread.Sleep(2050);
105+
await Task.Delay(2050);
105106

106107
// re-enabled
107-
EventFilter
108+
await EventFilter
108109
.Info(start: ExpectedDeadLettersLogMessage(7) + ", of which 2 were not logged")
109-
.Expect(1, () => _deadActor.Tell(7));
110+
.ExpectAsync(1, () => _deadActor.Tell(7));
110111

111112
// reset count
112-
EventFilter
113+
await EventFilter
113114
.Info(start: ExpectedDeadLettersLogMessage(1))
114-
.Expect(1, () => _deadActor.Tell(8));
115+
.ExpectAsync(1, () => _deadActor.Tell(8));
115116
}
116117
}
117118
}

0 commit comments

Comments
 (0)