public async Task AutoLockRenewalWorks(int numThreads)
{
var lockDuration = TimeSpan.FromSeconds(10);
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false,
lockDuration: lockDuration))
{
await using var client = GetClient();
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = false
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
var lockedUntil = message.LockedUntil;
await Task.Delay(lockDuration);
Assert.That(message.LockedUntil > lockedUntil, $"{lockedUntil},{DateTime.UtcNow}");
await args.CompleteAsync(message, args.CancellationToken);
Interlocked.Increment(ref messageCt);
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
Assert.AreEqual(numThreads, messageCt);
}
}
public async Task ProcessEvent(int numThreads, bool autoComplete)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
// use double the number of threads so we can make sure we test that we don't
// retrieve more messages than expected when there are more messages available
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads * 2;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = autoComplete
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
if (!autoComplete)
{
var lockedUntil = message.LockedUntil;
await args.RenewMessageLockAsync(message);
Assert.That(message.LockedUntil > lockedUntil);
await args.CompleteAsync(message, args.CancellationToken);
}
Interlocked.Increment(ref messageCt);
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
// we complete each task after one message being processed, so the total number of messages
// processed should equal the number of threads, but it's possible that we may process a few more per thread.
Assert.IsTrue(messageCt >= numThreads);
Assert.IsTrue(messageCt < messageSendCt);
}
}
public async Task MaxAutoLockRenewalDurationRespected(int numThreads, int autoLockRenewalDuration)
{
var lockDuration = TimeSpan.FromSeconds(10);
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false,
lockDuration: lockDuration))
{
await using var client = GetClient();
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = false,
MaxAutoLockRenewalDuration = TimeSpan.FromSeconds(autoLockRenewalDuration)
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
var lockedUntil = message.LockedUntil;
await Task.Delay(lockDuration.Add(TimeSpan.FromSeconds(1)));
if (!args.CancellationToken.IsCancellationRequested)
{
// only do the assertion if cancellation wasn't requested as otherwise
// the exception we would get is a TaskCanceledException rather than ServiceBusException
Assert.AreEqual(lockedUntil, message.LockedUntil);
Assert.That(
async() => await args.CompleteAsync(message, args.CancellationToken),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageLockLost));
Interlocked.Increment(ref messageCt);
}
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
Assert.AreEqual(numThreads, messageCt);
}
}
public async Task SenderReceiverActivities(bool useSessions)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: useSessions))
{
using var listener = new TestDiagnosticListener(EntityScopeFactory.DiagnosticNamespace);
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
string sessionId = null;
if (useSessions)
{
sessionId = "sessionId";
}
int numMessages = 5;
var msgs = GetMessages(numMessages, sessionId);
await sender.SendAsync(msgs);
Activity[] sendActivities = AssertSendActivities(useSessions, sender, msgs, listener);
ServiceBusReceiver receiver = null;
if (useSessions)
{
receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
}
else
{
receiver = client.CreateReceiver(scope.QueueName);
}
var remaining = numMessages;
List <ServiceBusReceivedMessage> receivedMsgs = new List <ServiceBusReceivedMessage>();
while (remaining > 0)
{
// loop in case we don't receive all messages in one attempt
var received = await receiver.ReceiveBatchAsync(remaining);
receivedMsgs.AddRange(received);
(string Key, object Value, DiagnosticListener)receiveStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveActivityName + ".Start", receiveStart.Key);
Activity receiveActivity = (Activity)receiveStart.Value;
AssertCommonTags(receiveActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.RequestedMessageCountAttribute,
remaining.ToString()));
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.MessageIdAttribute,
string.Join(",", received.Select(m => m.MessageId).ToArray())));
remaining -= received.Count;
if (useSessions)
{
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
string.Join(",", msgs.Select(m => m.SessionId).Distinct().ToArray())));
}
var receiveLinkedActivities = ((IEnumerable <Activity>)receiveActivity.GetType().GetProperty("Links").GetValue(receiveActivity)).ToArray();
for (int i = 0; i < receiveLinkedActivities.Length; i++)
{
Assert.AreEqual(sendActivities[i].ParentId, receiveLinkedActivities[i].ParentId);
}
(string Key, object Value, DiagnosticListener)receiveStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveActivityName + ".Stop", receiveStop.Key);
}
var msgIndex = 0;
var completed = receivedMsgs[msgIndex];
await receiver.CompleteAsync(completed);
(string Key, object Value, DiagnosticListener)completeStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Start", completeStart.Key);
Activity completeActivity = (Activity)completeStart.Value;
AssertCommonTags(completeActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(completeActivity, completed.LockToken);
(string Key, object Value, DiagnosticListener)completeStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Stop", completeStop.Key);
var deferred = receivedMsgs[++msgIndex];
await receiver.DeferAsync(deferred);
(string Key, object Value, DiagnosticListener)deferStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Start", deferStart.Key);
Activity deferActivity = (Activity)deferStart.Value;
AssertCommonTags(deferActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(deferActivity, deferred.LockToken);
(string Key, object Value, DiagnosticListener)deferStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Stop", deferStop.Key);
var deadLettered = receivedMsgs[++msgIndex];
await receiver.DeadLetterAsync(deadLettered);
(string Key, object Value, DiagnosticListener)deadLetterStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Start", deadLetterStart.Key);
Activity deadLetterActivity = (Activity)deadLetterStart.Value;
AssertCommonTags(deadLetterActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(deadLetterActivity, deadLettered.LockToken);
(string Key, object Value, DiagnosticListener)deadletterStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Stop", deadletterStop.Key);
var abandoned = receivedMsgs[++msgIndex];
await receiver.AbandonAsync(abandoned);
(string Key, object Value, DiagnosticListener)abandonStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.AbandonActivityName + ".Start", abandonStart.Key);
Activity abandonActivity = (Activity)abandonStart.Value;
AssertCommonTags(abandonActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(abandonActivity, abandoned.LockToken);
(string Key, object Value, DiagnosticListener)abandonStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.AbandonActivityName + ".Stop", abandonStop.Key);
var receiveDeferMsg = await receiver.ReceiveDeferredMessageAsync(deferred.SequenceNumber);
(string Key, object Value, DiagnosticListener)receiveDeferStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveDeferredActivityName + ".Start", receiveDeferStart.Key);
Activity receiveDeferActivity = (Activity)receiveDeferStart.Value;
AssertCommonTags(receiveDeferActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
receiveDeferActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.MessageIdAttribute,
deferred.MessageId));
CollectionAssert.Contains(
receiveDeferActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SequenceNumbersAttribute,
deferred.SequenceNumber.ToString()));
(string Key, object Value, DiagnosticListener)receiveDeferStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveDeferredActivityName + ".Stop", receiveDeferStop.Key);
// renew lock
if (useSessions)
{
var sessionReceiver = (ServiceBusSessionReceiver)receiver;
await sessionReceiver.RenewSessionLockAsync();
(string Key, object Value, DiagnosticListener)renewStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewSessionLockActivityName + ".Start", renewStart.Key);
Activity renewActivity = (Activity)renewStart.Value;
AssertCommonTags(renewActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
renewActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)renewStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewSessionLockActivityName + ".Stop", renewStop.Key);
// set state
var state = Encoding.UTF8.GetBytes("state");
await sessionReceiver.SetSessionStateAsync(state);
(string Key, object Value, DiagnosticListener)setStateStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.SetSessionStateActivityName + ".Start", setStateStart.Key);
Activity setStateActivity = (Activity)setStateStart.Value;
AssertCommonTags(setStateActivity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
setStateActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)setStateStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.SetSessionStateActivityName + ".Stop", setStateStop.Key);
// get state
var getState = await sessionReceiver.GetSessionStateAsync();
Assert.AreEqual(state, getState);
(string Key, object Value, DiagnosticListener)getStateStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.GetSessionStateActivityName + ".Start", getStateStart.Key);
Activity getStateActivity = (Activity)getStateStart.Value;
AssertCommonTags(getStateActivity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
getStateActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)getStateStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.GetSessionStateActivityName + ".Stop", getStateStop.Key);
}
else
{
await receiver.RenewMessageLockAsync(receivedMsgs[4]);
(string Key, object Value, DiagnosticListener)renewStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewMessageLockActivityName + ".Start", renewStart.Key);
Activity renewActivity = (Activity)renewStart.Value;
AssertCommonTags(renewActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(renewActivity, receivedMsgs[4].LockToken);
CollectionAssert.Contains(
renewActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.LockedUntilAttribute,
receivedMsgs[4].LockedUntil.ToString()));
(string Key, object Value, DiagnosticListener)renewStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewMessageLockActivityName + ".Stop", renewStop.Key);
}
// schedule
msgs = GetMessages(numMessages, sessionId);
foreach (var msg in msgs)
{
var seq = await sender.ScheduleMessageAsync(msg, DateTimeOffset.UtcNow.AddMinutes(1));
Assert.IsNotNull(msg.Properties[DiagnosticProperty.DiagnosticIdAttribute]);
(string Key, object Value, DiagnosticListener)startMessage = listener.Events.Dequeue();
Activity messageActivity = (Activity)startMessage.Value;
AssertCommonTags(messageActivity, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.MessageActivityName + ".Start", startMessage.Key);
(string Key, object Value, DiagnosticListener)stopMessage = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.MessageActivityName + ".Stop", stopMessage.Key);
(string Key, object Value, DiagnosticListener)startSchedule = listener.Events.Dequeue();
AssertCommonTags((Activity)startSchedule.Value, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.ScheduleActivityName + ".Start", startSchedule.Key);
(string Key, object Value, DiagnosticListener)stopSchedule = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ScheduleActivityName + ".Stop", stopSchedule.Key);
var linkedActivities = ((IEnumerable <Activity>)startSchedule.Value.GetType().GetProperty("Links").GetValue(startSchedule.Value)).ToArray();
Assert.AreEqual(1, linkedActivities.Length);
Assert.AreEqual(messageActivity.Id, linkedActivities[0].ParentId);
await sender.CancelScheduledMessageAsync(seq);
(string Key, object Value, DiagnosticListener)startCancel = listener.Events.Dequeue();
AssertCommonTags((Activity)startCancel.Value, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.CancelActivityName + ".Start", startCancel.Key);
(string Key, object Value, DiagnosticListener)stopCancel = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CancelActivityName + ".Stop", stopCancel.Key);
}
// send a batch
var batch = await sender.CreateBatchAsync();
for (int i = 0; i < numMessages; i++)
{
batch.TryAdd(GetMessage(sessionId));
}
await sender.SendAsync(batch);
AssertSendActivities(useSessions, sender, batch.AsEnumerable <ServiceBusMessage>(), listener);
};
}
public async Task DeadLetterMessagesSubscription(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.TopicName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
var topicName = scope.TopicName;
var subscriptionName = scope.SubscriptionNames.First();
var receiver = await client.CreateSessionReceiverAsync(
topicName : topicName,
subscriptionName : subscriptionName,
new ServiceBusSessionReceiverOptions
{
SessionId = useSpecificSession ? sessionId : null
});
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
var props = new Dictionary <string, object>();
// these should be ignored by DeadLetter property getters as they are not strings
props[ServiceBusReceivedMessage.DeadLetterReasonHeader] = DateTime.UtcNow;
props[ServiceBusReceivedMessage.DeadLetterErrorDescriptionHeader] = DateTime.UtcNow;
await receiver.DeadLetterAsync(item.LockToken, props);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
remainingMessages = messageCount;
var deadLetterReceiver = client.CreateDeadLetterReceiver(topicName, subscriptionName);
while (remainingMessages > 0)
{
foreach (var msg in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId);
Assert.IsNull(msg.DeadLetterErrorDescription);
Assert.IsNull(msg.DeadLetterReason);
Assert.IsNotNull(msg.Properties[ServiceBusReceivedMessage.DeadLetterReasonHeader]);
Assert.IsNotNull(msg.Properties[ServiceBusReceivedMessage.DeadLetterErrorDescriptionHeader]);
await deadLetterReceiver.CompleteAsync(msg.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var deadLetterMessage = await deadLetterReceiver.PeekAsync();
Assert.IsNull(deadLetterMessage);
}
}
public async Task DeadLetterMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
var receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = useSpecificSession ? sessionId : null
});
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.DeadLetterAsync(item.LockToken, "testReason", "testDescription");
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
remainingMessages = messageCount;
var deadLetterReceiver = client.CreateDeadLetterReceiver(scope.QueueName);
while (remainingMessages > 0)
{
foreach (var msg in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId);
Assert.AreEqual("testReason", msg.DeadLetterReason);
Assert.AreEqual("testDescription", msg.DeadLetterErrorDescription);
await deadLetterReceiver.CompleteAsync(msg.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var deadLetterMessage = await deadLetterReceiver.PeekAsync();
Assert.IsNull(deadLetterMessage);
}
}
