public async Task SendAndPeekMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
#region Snippet:ServiceBusPeek
ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync();
#endregion
// get the message body as a string
string body = Encoding.Default.GetString(peekedMessage.Body.ToArray());
Assert.AreEqual(Encoding.Default.GetBytes("Hello world!"), peekedMessage.Body.ToArray());
}
}
public async Task PeekIncrementsSequenceNumber(int messageCt)
{
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 = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId);
await sender.SendAsync(messagebatch);
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
long seq = 0;
for (int i = 0; i < messageCt; i++)
{
ServiceBusReceivedMessage msg = await receiver.PeekAsync();
Assert.IsTrue(msg.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SequenceNumber == seq + 1);
}
seq = msg.SequenceNumber;
}
}
}
public async Task CompleteMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
var receiver = client.CreateReceiver(scope.QueueName);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
await receiver.CompleteAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
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.SendAsync(message);
// not completing the transaction
}
ServiceBusReceiver receiver = sessionEnabled ?
await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = "sessionId"
})
: client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
Assert.IsNull(receivedMessage);
};
}
public async Task Peek()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCt = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
await using var receiver = client.CreateReceiver(scope.QueueName);
Dictionary <string, string> sentMessageIdToLabel = new Dictionary <string, string>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToLabel.Add(message.MessageId, Encoding.Default.GetString(message.Body.ToArray()));
}
var ct = 0;
while (ct < messageCt)
{
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync(
maxMessages: messageCt))
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body.ToArray());
ct++;
}
}
Assert.AreEqual(messageCt, ct);
}
}
public async Task AbandonMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
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 that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive and settle the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
#region Snippet:ServiceBusAbandonMessage
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
// abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers
await receiver.AbandonAsync(receivedMessage);
#endregion
Assert.IsNotNull(GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync());
}
}
public async Task Peek()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCt = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
await using var receiver = client.CreateReceiver(scope.QueueName);
var messageEnum = sentMessages.GetEnumerator();
var ct = 0;
while (ct < messageCt)
{
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync(
maxMessages: messageCt))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, peekedMessage.MessageId);
ct++;
}
}
Assert.AreEqual(messageCt, ct);
}
}
public async Task TransactionalSendMultipleSessionsRollback()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var options = new ServiceBusClientOptions();
options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5);
options.RetryOptions.MaxRetries = 0;
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message1 = GetMessage("session1");
ServiceBusMessage message2 = GetMessage("session2");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendAsync(message1);
await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1));
}
Assert.That(
async() =>
await client.CreateSessionReceiverAsync(scope.QueueName), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.ServiceTimeout));
};
}
public async Task TransactionalSendCommit(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.SendAsync(message);
ts.Complete();
}
ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message.Body.ToArray(), receivedMessage.Body.ToArray());
await receiver.CompleteAsync(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.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId);
await sender.SendAsync(messageBatch);
var options = new ServiceBusSessionReceiverOptions
{
SessionId = sessionId
};
ServiceBusReceiver receiver1 = await client.CreateSessionReceiverAsync(
scope.QueueName,
options);
Assert.That(
async() =>
await GetNoRetryClient().CreateSessionReceiverAsync(
scope.QueueName,
options),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.SessionCannotBeLocked));
}
}
public async Task TransactionalSendMultipleSessions()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message1 = GetMessage("session1");
ServiceBusMessage message2 = GetMessage("session2");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendAsync(message1);
await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow);
ts.Complete();
}
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message1.Body.ToArray(), receivedMessage.Body.ToArray());
await receiver.CompleteAsync(receivedMessage);
receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message2.Body.ToArray(), receivedMessage.Body.ToArray());
await receiver.CompleteAsync(receivedMessage);
};
}
public async Task SendAndReceiveMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#region Snippet:ServiceBusSendAndReceive
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// 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 that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
// get the message body as a string
string body = Encoding.Default.GetString(receivedMessage.Body.ToArray());
Console.WriteLine(body);
#endregion
Assert.AreEqual(Encoding.Default.GetBytes("Hello world!"), receivedMessage.Body.ToArray());
}
}
public async Task RenewMessageLock()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 1;
ServiceBusMessage message = GetMessage();
await sender.SendAsync(message);
var receiver = client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray();
var receivedMessage = receivedMessages.First();
var firstLockedUntilUtcTime = receivedMessage.LockedUntil;
// Sleeping for 10 seconds...
await Task.Delay(10000);
await receiver.RenewMessageLockAsync(receivedMessage);
Assert.True(receivedMessage.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
// Complete Messages
await receiver.CompleteAsync(receivedMessage.LockToken);
Assert.AreEqual(messageCount, receivedMessages.Length);
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task CanPeekADeferredMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
await sender.SendAsync(GetMessage());
var receiver = client.CreateReceiver(scope.QueueName);
var receivedMsg = await receiver.ReceiveAsync();
await receiver.DeferAsync(receivedMsg);
var peekedMsg = await receiver.PeekAsync();
Assert.AreEqual(receivedMsg.MessageId, peekedMsg.MessageId);
Assert.AreEqual(receivedMsg.SequenceNumber, peekedMsg.SequenceNumber);
var deferredMsg = await receiver.ReceiveDeferredMessageAsync(peekedMsg.SequenceNumber);
Assert.AreEqual(peekedMsg.MessageId, deferredMsg.MessageId);
Assert.AreEqual(peekedMsg.SequenceNumber, deferredMsg.SequenceNumber);
}
}
public void SendMessageExceptionLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportSender = new Mock <TransportSender>();
var mockConnection = GetMockConnection(mockTransportSender);
var sender = new ServiceBusSender(
"queueName",
mockConnection.Object)
{
Logger = mockLogger.Object
};
mockTransportSender.Setup(
sender => sender.SendAsync(
It.IsAny <IReadOnlyList <ServiceBusMessage> >(),
It.IsAny <CancellationToken>()))
.Throws(new Exception());
Assert.That(
async() => await sender.SendMessageAsync(ServiceBusTestUtilities.GetMessage()),
Throws.InstanceOf <Exception>());
mockLogger
.Verify(
log => log.SendMessageStart(
sender.Identifier,
1),
Times.Once);
mockLogger
.Verify(
log => log.SendMessageException(
sender.Identifier,
It.IsAny <string>()),
Times.Once);
}
public async Task CompleteMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#region Snippet:ServiceBusCompleteMessage
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// 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 that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive and settle the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
// complete the message, thereby deleting it from the service
await receiver.CompleteAsync(receivedMessage);
#endregion
Assert.IsNull(await GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync());
}
}
public async Task DeadLetterMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
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 that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive and settle the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
#region Snippet:ServiceBusDeadLetterMessage
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
// deadletter the message, thereby preventing the message from being received again without receiving from the dead letter queue.
await receiver.DeadLetterAsync(receivedMessage);
// receive the dead lettered message with receiver scoped to the dead letter queue.
ServiceBusReceiver dlqReceiver = client.CreateDeadLetterReceiver(queueName);
ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveAsync();
#endregion
Assert.IsNotNull(dlqMessage);
}
}
public async Task SessionProcessorActivities()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
using var listener = new TestDiagnosticListener(EntityScopeFactory.DiagnosticNamespace);
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCt = 2;
var msgs = GetMessages(messageCt, "sessionId");
await sender.SendAsync(msgs);
Activity[] sendActivities = AssertSendActivities(false, sender, msgs, listener);
ServiceBusSessionProcessor processor = client.CreateSessionProcessor(scope.QueueName,
new ServiceBusSessionProcessorOptions
{
AutoComplete = false,
MaxReceiveWaitTime = TimeSpan.FromSeconds(10),
MaxConcurrentCalls = 1
});
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
int processedMsgCt = 0;
processor.ProcessMessageAsync += args =>
{
processedMsgCt++;
if (processedMsgCt == messageCt)
{
tcs.SetResult(true);
}
return(Task.CompletedTask);
};
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
await tcs.Task;
await processor.StopProcessingAsync();
for (int i = 0; i < messageCt; i++)
{
(string Key, object Value, DiagnosticListener)receiveStart = listener.Events.Dequeue();
(string Key, object Value, DiagnosticListener)receiveStop = listener.Events.Dequeue();
(string Key, object Value, DiagnosticListener)processStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ProcessSessionMessageActivityName + ".Start", processStart.Key);
Activity processActivity = (Activity)processStart.Value;
AssertCommonTags(processActivity, processor.EntityPath, processor.FullyQualifiedNamespace);
CollectionAssert.Contains(
processActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.MessageIdAttribute,
msgs[i].MessageId));
CollectionAssert.Contains(
processActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
msgs[i].SessionId));
(string Key, object Value, DiagnosticListener)processStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ProcessSessionMessageActivityName + ".Stop", processStop.Key);
}
};
}
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.GetSender(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.SendAsync(GetMessage("sessionId2"));
await sender.SendAsync(message);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName, sessionId : isSessionSpecified?sessionId1 : null);
var session = receiver.GetSessionManager();
if (isSessionSpecified)
{
Assert.AreEqual(sessionId1, session.SessionId);
}
ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray();
var receivedMessage = receivedMessages.First();
var firstLockedUntilUtcTime = session.LockedUntil;
// Sleeping for 10 seconds...
await Task.Delay(10000);
await session.RenewSessionLockAsync();
Assert.True(session.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
// Complete Messages
await receiver.CompleteAsync(receivedMessage.LockToken);
Assert.AreEqual(messageCount, receivedMessages.Length);
if (isSessionSpecified)
{
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
}
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task TransactionalCompleteRollback(bool partitioned, bool sessionEnabled, bool completeInTransactionAfterRollback)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
string body = Guid.NewGuid().ToString("N");
ServiceBusMessage message = GetMessage(
sessionEnabled ? "sessionId" : null,
partitioned ? "sessionId" : null);
await sender.SendAsync(message);
ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName);
var receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(
message.Body.ToString(),
receivedMessage.Body.ToString());
var sequenceNumber = receivedMessage.SequenceNumber;
await receiver.DeferAsync(receivedMessage);
ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessageAsync(sequenceNumber);
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(deferredMessage);
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
if (completeInTransactionAfterRollback)
{
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(deferredMessage);
ts.Complete();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
}
else
{
await receiver.CompleteAsync(deferredMessage);
}
Assert.That(
async() =>
await receiver.CompleteAsync(deferredMessage), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.MessageLockLost));
}
}
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.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = 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.ReceiveBatchAsync(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.AbandonAsync(msg);
}
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
ServiceBusMessage message1 = GetMessage();
ServiceBusMessage message2 = GetMessage();
await sender.SendAsync(message1);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString());
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage);
await sender.SendAsync(message2);
ts.Complete();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
// Assert that complete did succeed
Assert.That(
async() =>
await receiver.CompleteAsync(receivedMessage), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.MessageLockLost));
// Assert that send did succeed
receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString());
await receiver.CompleteAsync(receivedMessage);
}
}
public async Task CanStopProcessingFromHandler(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
int numMessages = 100;
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, numMessages);
await sender.SendAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
var processor = client.CreateProcessor(scope.QueueName, options);
int messageProcessedCt = 0;
// stop processing halfway through
int stopAfterMessagesCt = numMessages / 2;
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
Task ProcessMessage(ProcessMessageEventArgs args)
{
var currentCt = Interlocked.Increment(ref messageProcessedCt);
if (currentCt == stopAfterMessagesCt)
{
// awaiting here would cause a deadlock
_ = processor.StopProcessingAsync();
tcs.SetResult(true);
}
return(Task.CompletedTask);
}
await tcs.Task;
var receiver = GetNoRetryClient().CreateReceiver(scope.QueueName);
var receivedMessages = await receiver.ReceiveBatchAsync(numMessages);
// can't assert on the exact amount processed due to threads that
// are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages
Assert.IsTrue(receivedMessages.Count > 0);
Assert.IsTrue(messageProcessedCt < numMessages);
}
}
public async Task PeekSession(long?sequenceNumber, string partitionKey)
{
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 messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt, sessionId, partitionKey).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToMsg.Add(message.MessageId, message);
}
var receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = sessionId
});
sequenceNumber ??= 1;
// verify peeked == send
var ct = 0;
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync(
sequenceNumber: (long)sequenceNumber,
maxMessages: messageCt))
{
var peekedText = peekedMessage.Body.AsString();
var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId];
sentMessageIdToMsg.Remove(peekedMessage.MessageId);
Assert.AreEqual(sentMsg.Body.AsString(), peekedText);
Assert.AreEqual(sentMsg.PartitionKey, peekedMessage.PartitionKey);
Assert.IsTrue(peekedMessage.SequenceNumber >= sequenceNumber);
ct++;
}
if (sequenceNumber == 1)
{
Assert.AreEqual(messageCt, ct);
}
}
}
public async Task DeadLetterMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount);
await sender.SendAsync(messages);
var receiver = client.CreateReceiver(scope.QueueName);
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);
await receiver.DeadLetterAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
string deadLetterQueuePath = EntityNameFormatter.FormatDeadLetterPath(scope.QueueName);
var deadLetterReceiver = client.CreateReceiver(deadLetterQueuePath);
remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
await deadLetterReceiver.CompleteAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var deadLetterMessage = deadLetterReceiver.PeekAsync();
Assert.IsNull(deadLetterMessage.Result);
}
}
public async Task CanSendAnEmptyBodyMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>()));
await sender.SendAsync(batch);
}
}
public async Task CanSendAMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, 3);
await sender.SendAsync(messageBatch);
}
}
public async Task SessionReceiverThrowsWhenUsingNonSessionEntity()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage sentMessage = GetMessage();
await sender.SendAsync(sentMessage);
Assert.That(
async() => await client.CreateSessionReceiverAsync(scope.QueueName),
Throws.InstanceOf <InvalidOperationException>());
}
}
public async Task CannotSendLargerThanMaximumSize()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
// Actual limit is 262144 bytes for a single message.
ServiceBusMessage message = new ServiceBusMessage(new byte[300000]);
Assert.That(async() => await sender.SendAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageSizeExceeded));
}
}
public async Task TransactionRollbackWorksAcrossClientsUsingSameConnectionToSameEntity()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
ServiceBusMessage message1 = GetMessage();
ServiceBusMessage message2 = GetMessage();
await sender.SendAsync(message1);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString());
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage.LockToken);
await sender.SendAsync(message2);
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
// Following should succeed without exceptions
await receiver.CompleteAsync(receivedMessage.LockToken);
// Assert that send failed
receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
Assert.Null(receivedMessage);
}
}
