public async Task TransactionalSendRollback(bool partitioned, bool sessionEnabled)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message = GetMessage(
sessionEnabled ? "sessionId" : null,
partitioned ? "sessionId" : null);
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendMessageAsync(message);
// not completing the transaction
}
ServiceBusReceiver receiver = sessionEnabled ?
await client.AcceptSessionAsync(
scope.QueueName,
"sessionId")
: client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5));
Assert.IsNull(receivedMessage);
};
}
public async Task LockSameSessionShouldThrow()
{
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);
int messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId);
await sender.SendMessagesAsync(messageBatch);
ServiceBusReceiver receiver1 = await client.AcceptSessionAsync(
scope.QueueName,
sessionId);
Assert.That(
async() =>
await GetNoRetryClient().AcceptSessionAsync(
scope.QueueName,
sessionId),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.SessionCannotBeLocked));
}
}
public async Task CanAcceptMultipleSessionsUsingSameOptionsTopic(bool acceptSpecificSession)
{
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 msgs = new List <ServiceBusMessage>();
for (int i = 0; i < 20; i++)
{
msgs.Add(new ServiceBusMessage()
{
SessionId = i.ToString()
});
}
await sender.SendMessagesAsync(msgs);
var options = new ServiceBusSessionReceiverOptions {
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
};
var tasks = new List <Task>();
for (int i = 0; i < 20; i++)
{
if (acceptSpecificSession)
{
tasks.Add(client.AcceptSessionAsync(scope.TopicName, scope.SubscriptionNames.First(), i.ToString(), options));
}
else
{
tasks.Add(client.AcceptNextSessionAsync(scope.TopicName, scope.SubscriptionNames.First(), options));
}
}
await Task.WhenAll(tasks);
}
}
public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true, lockDuration: TimeSpan.FromSeconds(5)))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
await sender.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "sessionId1"));
// send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected
await sender.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "sessionId2"));
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
isSessionSpecified? "sessionId1" : null);
if (isSessionSpecified)
{
Assert.AreEqual("sessionId1", receiver.SessionId);
}
var message = await receiver.ReceiveMessageAsync();
Assert.AreEqual(receiver.SessionId, message.SessionId);
var sessionId = receiver.SessionId;
await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5));
Assert.IsTrue(receiver.IsClosed);
Assert.That(async() => await receiver.ReceiveMessageAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.SetSessionStateAsync(null),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.GetSessionStateAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeadLetterMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeferMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
}
}
public async Task AbandonMessages(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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
ServiceBusReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
useSpecificSession?sessionId : null);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
IList <ServiceBusReceivedMessage> receivedMessages = new List <ServiceBusReceivedMessage>();
while (remainingMessages > 0)
{
foreach (var msg in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId);
receivedMessages.Add(msg);
Assert.AreEqual(msg.DeliveryCount, 1);
}
}
Assert.AreEqual(0, remainingMessages);
// don't abandon in the receive loop
// as this would make the message available to be immediately received again
foreach (var msg in receivedMessages)
{
await receiver.AbandonMessageAsync(msg);
}
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekMessagesAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
private async Task <ServiceBusReceiver> GetServiceBusReceiver(
string queueOrTopicName,
string subscriptionName = default,
ServiceBusSubscriberReceiveOptions options = default,
CancellationToken cancellationToken = default)
{
var(sessionId, _, connectToDeadLetterQueue) = (options?.SessionId, ServiceBusSubscriberReceiveMessageTypes.Payload, options?.ConnectToDeadLetterQueue ?? false);
if (string.IsNullOrWhiteSpace(subscriptionName))
{
if (string.IsNullOrWhiteSpace(sessionId))
{
return(_client.CreateReceiver(
queueOrTopicName,
new ServiceBusReceiverOptions
{
SubQueue = connectToDeadLetterQueue ? SubQueue.DeadLetter : SubQueue.None
}));
}
return(await _client.AcceptSessionAsync(
queueOrTopicName,
sessionId,
cancellationToken : cancellationToken));
}
if (string.IsNullOrWhiteSpace(sessionId))
{
return(_client.CreateReceiver(
queueOrTopicName,
subscriptionName,
new ServiceBusReceiverOptions
{
SubQueue = connectToDeadLetterQueue ? SubQueue.DeadLetter : SubQueue.None
}));
}
return(await _client.AcceptSessionAsync(
queueOrTopicName,
subscriptionName,
sessionId,
cancellationToken : cancellationToken));
}
public async Task PeekSession(long?sequenceNumber)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt, sessionId, sessionId)
.AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToMsg.Add(message.MessageId, message);
}
var receiver = await client.AcceptSessionAsync(
scope.QueueName,
sessionId);
sequenceNumber ??= 1;
// verify peeked == send
var ct = 0;
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync(
messageCt,
sequenceNumber))
{
var peekedText = peekedMessage.Body.ToString();
var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId];
sentMessageIdToMsg.Remove(peekedMessage.MessageId);
Assert.AreEqual(sentMsg.Body.ToString(), peekedText);
Assert.AreEqual(sentMsg.SessionId, peekedMessage.SessionId);
Assert.IsTrue(peekedMessage.SequenceNumber >= sequenceNumber);
ct++;
}
if (sequenceNumber == 1)
{
Assert.AreEqual(messageCt, ct);
}
}
}
public async Task RenewSessionLock(bool isSessionSpecified)
{
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 = 1;
var sessionId1 = "sessionId1";
ServiceBusMessage message = GetMessage(sessionId1);
// send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected
await sender.SendMessageAsync(GetMessage("sessionId2"));
await sender.SendMessageAsync(message);
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
isSessionSpecified?sessionId1 : null);
if (isSessionSpecified)
{
Assert.AreEqual(sessionId1, receiver.SessionId);
}
ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveMessagesAsync(messageCount)).ToArray();
var receivedMessage = receivedMessages.First();
var firstLockedUntilUtcTime = receiver.SessionLockedUntil;
// Sleeping for 10 seconds...
await Task.Delay(10000);
await receiver.RenewSessionLockAsync();
Assert.True(receiver.SessionLockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
// Complete Messages
await receiver.CompleteMessageAsync(receivedMessage.LockToken);
Assert.AreEqual(messageCount, receivedMessages.Length);
if (isSessionSpecified)
{
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
}
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task GetAndSetSessionStateTest(bool isSessionSpecified)
{
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 sessionId = "test-sessionId";
ServiceBusMessage message = GetMessage(sessionId);
await sender.SendMessageAsync(message);
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
isSessionSpecified?sessionId : null);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
Assert.AreEqual(message.SessionId, receivedMessage.SessionId);
Assert.AreEqual(message.Body.ToArray(), receivedMessage.Body.ToArray());
var sessionStateString = "Received Message From Session!";
var sessionState = new BinaryData(sessionStateString);
await receiver.SetSessionStateAsync(sessionState);
var returnedSessionState = await receiver.GetSessionStateAsync();
var returnedSessionStateString = returnedSessionState.ToString();
Assert.AreEqual(sessionStateString, returnedSessionStateString);
// Complete message using Session Receiver
await receiver.CompleteMessageAsync(receivedMessage);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
sessionStateString = "Completed Message On Session!";
sessionState = new BinaryData(sessionStateString);
await receiver.SetSessionStateAsync(sessionState);
returnedSessionState = await receiver.GetSessionStateAsync();
returnedSessionStateString = returnedSessionState.ToString();
Assert.AreEqual(sessionStateString, returnedSessionStateString);
}
}
public async Task DeferMessages(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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
var receiver = await client.AcceptSessionAsync(
scope.QueueName,
useSpecificSession?sessionId : null);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
IList <long> sequenceNumbers = new List <long>();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
sequenceNumbers.Add(item.SequenceNumber);
await receiver.DeferMessageAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
IReadOnlyList <ServiceBusReceivedMessage> deferedMessages = await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers);
var messageList = messages.ToList();
Assert.AreEqual(messageList.Count, deferedMessages.Count);
for (int i = 0; i < messageList.Count; i++)
{
Assert.AreEqual(messageList[i].MessageId, deferedMessages[i].MessageId);
}
}
}
public async Task ReceiveFromSpecificSession()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message batch that we can send
ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
messageBatch.TryAddMessage(
new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))
{
SessionId = "Session1"
});
messageBatch.TryAddMessage(
new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))
{
SessionId = "Session2"
});
// send the message batch
await sender.SendMessagesAsync(messageBatch);
#region Snippet:ServiceBusReceiveFromSpecificSession
// create a receiver specifying a particular session
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
queueName,
"Session2");
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
Console.WriteLine(receivedMessage.SessionId);
#endregion
Assert.AreEqual(Encoding.UTF8.GetBytes("Second"), receivedMessage.Body.ToBytes().ToArray());
Assert.AreEqual("Session2", receivedMessage.SessionId);
}
}
public static async Task <ServiceBusReceivedMessage> GetMessageFromSessionAsync(string connectionString, string queueName, string sessionId)
{
await using var client = new ServiceBusClient(connectionString);
ServiceBusSessionReceiver receiver = null;
if (string.IsNullOrEmpty(sessionId))
{
receiver = await client.AcceptNextSessionAsync(queueName);
}
else
{
receiver = await client.AcceptSessionAsync(queueName, sessionId);
}
// the received message is a different type as it contains some service set properties
return(await receiver.ReceiveMessageAsync());
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
var clientOptions = new ServiceBusSessionReceiverOptions
{
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
};
ServiceBusReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
sessionId,
clientOptions);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
remainingMessages--;
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task GetChildClientFromClosedParentClientThrows(bool useSessions)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: useSessions))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var message = GetMessage(useSessions ? "sessionId" : null);
await sender.SendMessageAsync(message);
await sender.DisposeAsync();
ServiceBusReceiver receiver;
if (!useSessions)
{
receiver = client.CreateReceiver(scope.QueueName);
}
else
{
receiver = await client.AcceptNextSessionAsync(scope.QueueName);
}
var receivedMessage = await receiver.ReceiveMessageAsync().ConfigureAwait(false);
Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString());
await client.DisposeAsync();
Assert.IsTrue(client.IsClosed);
if (!useSessions)
{
Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName));
Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName, scope.QueueName));
Assert.Throws <ObjectDisposedException>(() => client.CreateSender(scope.QueueName));
}
else
{
Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.AcceptNextSessionAsync(scope.QueueName));
Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.AcceptSessionAsync(
scope.QueueName,
"sessionId"));
}
Assert.Throws <ObjectDisposedException>(() => client.CreateProcessor(scope.QueueName));
}
}
public async Task CompleteMessages(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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = ServiceBusTestUtilities.AddMessages(batch, messageCount, sessionId).AsReadOnly <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
ServiceBusReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
useSpecificSession?sessionId : null);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.CompleteMessageAsync(item);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
}
}
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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
var topicName = scope.TopicName;
var subscriptionName = scope.SubscriptionNames.First();
var receiver = await client.AcceptSessionAsync(
topicName : topicName,
subscriptionName : subscriptionName,
useSpecificSession?sessionId : null);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(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[AmqpMessageConstants.DeadLetterReasonHeader] = DateTime.UtcNow;
props[AmqpMessageConstants.DeadLetterErrorDescriptionHeader] = DateTime.UtcNow;
await receiver.DeadLetterMessageAsync(item.LockToken, props);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
remainingMessages = messageCount;
var deadLetterReceiver = client.CreateReceiver(topicName, subscriptionName, new ServiceBusReceiverOptions
{
SubQueue = SubQueue.DeadLetter
});
while (remainingMessages > 0)
{
foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(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.ApplicationProperties[AmqpMessageConstants.DeadLetterReasonHeader]);
Assert.IsNotNull(msg.ApplicationProperties[AmqpMessageConstants.DeadLetterErrorDescriptionHeader]);
await deadLetterReceiver.CompleteMessageAsync(msg.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync();
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.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
var receiver = await client.AcceptSessionAsync(
scope.QueueName,
useSpecificSession?sessionId : null);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.DeadLetterMessageAsync(item.LockToken, "testReason", "testDescription");
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
remainingMessages = messageCount;
var deadLetterReceiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions
{
SubQueue = SubQueue.DeadLetter
});
while (remainingMessages > 0)
{
foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(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.CompleteMessageAsync(msg.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync();
Assert.IsNull(deadLetterMessage);
}
}
public async Task ReceiverCanReconnectToSameSession(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true, lockDuration: TimeSpan.FromSeconds(5)))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
await sender.SendMessagesAsync(GetMessages(3, "sessionId1"));
// send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected
await sender.SendMessagesAsync(GetMessages(3, "sessionId2"));
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
isSessionSpecified? "sessionId1" : null);
if (isSessionSpecified)
{
Assert.AreEqual("sessionId1", receiver.SessionId);
}
var firstMessage = await receiver.ReceiveMessageAsync();
Assert.AreEqual(receiver.SessionId, firstMessage.SessionId);
var sessionId = receiver.SessionId;
await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5));
var secondMessage = await receiver.ReceiveMessageAsync();
Assert.AreEqual(sessionId, receiver.SessionId);
Assert.AreEqual(receiver.SessionId, secondMessage.SessionId);
// Even though the receiver has re-established the session link, since the first message was
// received before we reconnected, the message won't be able to be settled. This is analogous
// to the case of reconnecting a regular non-session link and getting a MessageLockLost error.
Assert.That(
async() => await receiver.CompleteMessageAsync(firstMessage),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.SessionLockLost));
await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5));
// If another receiver accepts the session after the lock is lost, we expect a SessionCannotBeLocked error,
// when we try to receive again with our initial receiver.
ServiceBusSessionReceiver secondReceiver = await client.AcceptSessionAsync(
scope.QueueName,
sessionId);
try
{
await receiver.ReceiveMessageAsync();
}
catch (ServiceBusException ex) when(ex.Reason == ServiceBusFailureReason.SessionCannotBeLocked)
{
return;
}
catch (Exception ex)
{
Assert.Fail($"Expected exception not thrown: {ex}");
}
Assert.Fail("No exception thrown!");
}
}
