internal async Task PeekLockTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
}
internal async Task ReceiveDeleteTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount, TimeSpan.FromSeconds(10));
Assert.Equal(receivedMessages.Count, messageCount);
}
internal async Task ReceiveDeleteTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
Assert.True(messageCount == receivedMessages.Count);
}
internal async Task ReceiveDeleteTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount, TimeSpan timeout)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount, timeout);
TestUtility.VaidateMessageState(receivedMessages, MessageState.Active);
Assert.Equal(messageCount, receivedMessages.Count);
}
async Task PeekLockDeliveryCountTest(string queueName)
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
var messages = await TestUtility.ReceiveMessagesAsync(queueClient.InnerReceiver, 1);
await TestUtility.CompleteMessagesAsync(queueClient.InnerReceiver, messages);
Assert.Equal(1, messages.First().SystemProperties.DeliveryCount);
}
finally
{
await queueClient.CloseAsync();
}
}
internal async Task OnMessageAsyncTestCase(
IMessageSender messageSender,
IMessageReceiver messageReceiver,
int maxConcurrentCalls,
bool autoComplete,
int messageCount)
{
int count = 0;
await TestUtility.SendMessagesAsync(messageSender, messageCount);
messageReceiver.RegisterMessageHandler(
async(message, token) =>
{
TestUtility.Log($"Received message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
count++;
if (messageReceiver.ReceiveMode == ReceiveMode.PeekLock && !autoComplete)
{
await messageReceiver.CompleteAsync(message.SystemProperties.LockToken);
}
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = maxConcurrentCalls, AutoComplete = autoComplete
});
// Wait for the OnMessage Tasks to finish
Stopwatch stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 60)
{
if (count == messageCount)
{
TestUtility.Log($"All '{messageCount}' messages Received.");
break;
}
else
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
Assert.True(count == messageCount);
}
internal async Task PeekAsyncTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var peekedMessages = new List <Message>();
peekedMessages.Add(await TestUtility.PeekMessageAsync(messageReceiver));
peekedMessages.AddRange(await TestUtility.PeekMessagesAsync(messageReceiver, messageCount - 1));
Assert.True(messageCount == peekedMessages.Count);
long lastSequenceNumber = -1;
foreach (var message in peekedMessages)
{
Assert.True(message.SystemProperties.SequenceNumber != lastSequenceNumber);
lastSequenceNumber = message.SystemProperties.SequenceNumber;
}
await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
}
protected async Task PeekAsyncTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
List <BrokeredMessage> peekedMessages = new List <BrokeredMessage>();
peekedMessages.Add(await TestUtility.PeekMessageAsync(messageReceiver));
peekedMessages.AddRange(await TestUtility.PeekMessagesAsync(messageReceiver, messageCount - 1));
Assert.True(messageCount == peekedMessages.Count());
long lastSequenceNumber = -1;
foreach (BrokeredMessage message in peekedMessages)
{
Assert.True(message.SequenceNumber != lastSequenceNumber);
lastSequenceNumber = message.SequenceNumber;
}
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
}
public async Task Should_return_true_for_peeked_message()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.PeekLock);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
var peekedMessage = await TestUtility.PeekMessageAsync(queueClient.InnerReceiver);
var result = peekedMessage.SystemProperties.IsReceived;
Assert.True(result);
}
finally
{
var messages = await TestUtility.ReceiveMessagesAsync(queueClient.InnerReceiver, 1);
await TestUtility.CompleteMessagesAsync(queueClient.InnerReceiver, messages);
await queueClient.CloseAsync();
}
});
}
public async Task PeekLockDeliveryCountTest(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
var messages = await TestUtility.ReceiveMessagesAsync(queueClient.InnerReceiver, 1);
await TestUtility.CompleteMessagesAsync(queueClient.InnerReceiver, messages);
Assert.Equal(1, messages.First().SystemProperties.DeliveryCount);
}
finally
{
await queueClient.CloseAsync();
}
});
}
internal async Task OnMessageRegistrationWithoutPendingMessagesTestCase(
IMessageSender messageSender,
IMessageReceiver messageReceiver,
int maxConcurrentCalls,
bool autoComplete)
{
int count = 0;
messageReceiver.RegisterMessageHandler(
async(message, token) =>
{
TestUtility.Log($"Received message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
count++;
await Task.CompletedTask;
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = maxConcurrentCalls, AutoComplete = autoComplete
});
await TestUtility.SendMessagesAsync(messageSender, 1);
Stopwatch stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 20)
{
if (count == 1)
{
TestUtility.Log($"All messages Received.");
break;
}
else
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
TestUtility.Log($"{DateTime.Now}: MessagesReceived: {count}");
Assert.True(count == 1);
}
async Task Should_return_true_for_peeked_message()
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName, ReceiveMode.PeekLock);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerClient.InnerSender, 1);
var peekedMessage = await TestUtility.PeekMessageAsync(queueClient.InnerClient.InnerReceiver);
var result = peekedMessage.SystemProperties.IsReceived;
Assert.True(result);
}
finally
{
var messages = await TestUtility.ReceiveMessagesAsync(queueClient.InnerClient.InnerReceiver, 1);
await TestUtility.CompleteMessagesAsync(queueClient.InnerClient.InnerReceiver, messages);
await queueClient.CloseAsync();
}
}
internal async Task PeekLockDeferTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive 5 messages And Defer them
var deferMessagesCount = 5;
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, deferMessagesCount);
Assert.True(receivedMessages.Count == deferMessagesCount);
var sequenceNumbers = receivedMessages.Select(receivedMessage => receivedMessage.SystemProperties.SequenceNumber).ToList();
await TestUtility.DeferMessagesAsync(messageReceiver, receivedMessages);
// Receive and Complete 5 other regular messages
receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount - deferMessagesCount);
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
Assert.True(receivedMessages.Count == messageCount - deferMessagesCount);
// Receive / Abandon deferred messages
receivedMessages = await TestUtility.ReceiveDeferredMessagesAsync(messageReceiver, sequenceNumbers);
Assert.True(receivedMessages.Count == 5);
TestUtility.VaidateMessageState(receivedMessages, MessageState.Deferred);
await TestUtility.DeferMessagesAsync(messageReceiver, receivedMessages);
// Receive Again and Check delivery count
receivedMessages = await TestUtility.ReceiveDeferredMessagesAsync(messageReceiver, sequenceNumbers);
var count = receivedMessages.Count(message => message.SystemProperties.DeliveryCount == 3);
TestUtility.VaidateMessageState(receivedMessages, MessageState.Deferred);
Assert.True(count == receivedMessages.Count);
// Complete messages
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
}
async Task Should_return_true_for_message_that_was_sent_and_received(ReceiveMode receiveMode)
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName, receiveMode);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerClient.InnerSender, 1);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(queueClient.InnerClient.InnerReceiver, 1);
Assert.True(receivedMessages.First().SystemProperties.IsReceived);
// TODO: remove when per test cleanup is possible
if (receiveMode == ReceiveMode.PeekLock)
{
await queueClient.CompleteAsync(receivedMessages.First().SystemProperties.LockToken);
}
}
finally
{
await queueClient.CloseAsync();
}
}
protected async Task PeekLockDeferTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive 5 messages And Defer them
int deferMessagesCount = 5;
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, deferMessagesCount);
Assert.True(receivedMessages.Count() == deferMessagesCount);
var sequenceNumbers = receivedMessages.Select(receivedMessage => receivedMessage.SequenceNumber);
await TestUtility.DeferMessagesAsync(messageReceiver, receivedMessages);
// Receive and Complete 5 other regular messages
receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount - deferMessagesCount);
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
Assert.True(receivedMessages.Count() == messageCount - deferMessagesCount);
// Receive / Abandon deferred messages
receivedMessages = await messageReceiver.ReceiveBySequenceNumberAsync(sequenceNumbers);
Assert.True(receivedMessages.Count() == 5);
await TestUtility.DeferMessagesAsync(messageReceiver, receivedMessages);
// Receive Again and Check delivery count
receivedMessages = await messageReceiver.ReceiveBySequenceNumberAsync(sequenceNumbers);
int count = receivedMessages.Where((message) => message.DeliveryCount == 3).Count();
Assert.True(count == receivedMessages.Count());
// Complete messages
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
}
async Task MessageLockLostExceptionTest()
{
const int messageCount = 2;
var sender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName, receiveMode: ReceiveMode.PeekLock);
try
{
await TestUtility.SendMessagesAsync(sender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount);
Assert.True(receivedMessages.Count() == messageCount);
// Let the messages expire
await Task.Delay(TimeSpan.FromMinutes(1));
// Complete should throw
await
Assert.ThrowsAsync <MessageLockLostException>(
async() => await TestUtility.CompleteMessagesAsync(receiver, receivedMessages));
receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount);
Assert.True(receivedMessages.Count() == messageCount);
await TestUtility.CompleteMessagesAsync(receiver, receivedMessages);
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await receiver.CloseAsync().ConfigureAwait(false);
}
}
public async Task MessageLockLostExceptionTest()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
const int messageCount = 2;
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.PeekLock);
try
{
await TestUtility.SendMessagesAsync(sender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount);
Assert.True(receivedMessages.Count == messageCount);
// Let the messages expire
await Task.Delay(TimeSpan.FromMinutes(1));
// Complete should throw
await
Assert.ThrowsAsync <MessageLockLostException>(
async() => await TestUtility.CompleteMessagesAsync(receiver, receivedMessages));
receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount);
Assert.True(receivedMessages.Count == messageCount);
await TestUtility.CompleteMessagesAsync(receiver, receivedMessages);
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
}
});
}
internal async Task OnMessageAsyncUnregisterHandlerShortTimeoutTestCase(
IMessageSender messageSender,
IMessageReceiver messageReceiver,
int maxConcurrentCalls,
bool autoComplete,
int messageCount)
{
var count = 0;
await TestUtility.SendMessagesAsync(messageSender, messageCount);
messageReceiver.RegisterMessageHandler(
async(message, token) =>
{
TestUtility.Log($"Received message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
await Task.Delay(TimeSpan.FromSeconds(8));
if (messageReceiver.ReceiveMode == ReceiveMode.PeekLock && !autoComplete)
{
await messageReceiver.CompleteAsync(message.SystemProperties.LockToken);
}
Interlocked.Increment(ref count);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = maxConcurrentCalls, AutoComplete = autoComplete
});
await messageReceiver.UnregisterMessageHandlerAsync(TimeSpan.FromSeconds(2));
Assert.True(count == 0);
// Reregister won't have any problems
count = 0;
var remainingMessageCount = messageCount - maxConcurrentCalls;
messageReceiver.RegisterMessageHandler(
async(message, token) =>
{
TestUtility.Log($"Received message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
if (messageReceiver.ReceiveMode == ReceiveMode.PeekLock && !autoComplete)
{
await messageReceiver.CompleteAsync(message.SystemProperties.LockToken);
}
Interlocked.Increment(ref count);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = maxConcurrentCalls, AutoComplete = autoComplete
});
var stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 60)
{
if (count == remainingMessageCount)
{
TestUtility.Log($"All '{remainingMessageCount}' messages Received.");
break;
}
await Task.Delay(TimeSpan.FromSeconds(5));
}
Assert.True(count == remainingMessageCount);
}
async Task BrokeredMessageOperationsTest()
{
// Create QueueClient with ReceiveDelete,
// Send and Receive a message, Try to Complete/Abandon/Defer/DeadLetter should throw InvalidOperationException()
var queueClient = QueueClient.CreateFromConnectionString(
TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName),
ReceiveMode.ReceiveAndDelete);
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
var message = await queueClient.ReceiveAsync();
Assert.NotNull((object)message);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.CompleteAsync());
await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.AbandonAsync());
await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.DeferAsync());
await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.DeadLetterAsync());
// Create a PeekLock queueClient and do rest of the operations
// Send a Message, Receive/ Abandon and Complete it using BrokeredMessage methods
queueClient = QueueClient.CreateFromConnectionString(
TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName),
ReceiveMode.PeekLock);
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
message = await queueClient.ReceiveAsync();
Assert.NotNull((object)message);
await message.AbandonAsync();
await Task.Delay(TimeSpan.FromMilliseconds(100));
message = await queueClient.ReceiveAsync();
await message.CompleteAsync();
// Send a Message, Receive / DeadLetter using BrokeredMessage methods
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
message = await queueClient.ReceiveAsync();
await message.DeadLetterAsync();
var builder = new ServiceBusConnectionStringBuilder(TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName));
builder.EntityPath = EntityNameHelper.FormatDeadLetterPath(queueClient.QueueName);
var deadLetterQueueClient = QueueClient.CreateFromConnectionString(builder.ToString());
message = await deadLetterQueueClient.ReceiveAsync();
await message.CompleteAsync();
// Send a Message, Receive/Defer using BrokeredMessage methods
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
message = await queueClient.ReceiveAsync();
var deferredSequenceNumber = message.SequenceNumber;
await message.DeferAsync();
var deferredMessage = await queueClient.ReceiveBySequenceNumberAsync(deferredSequenceNumber);
await deferredMessage.CompleteAsync();
await queueClient.CloseAsync();
}