protected async Task PeekLockWithAbandonTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive 5 messages and Abandon them
int abandonMessagesCount = 5;
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, abandonMessagesCount);
Assert.True(receivedMessages.Count() == abandonMessagesCount);
await TestUtility.AbandonMessagesAsync(messageReceiver, receivedMessages);
// Receive all 10 messages
receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
Assert.True(receivedMessages.Count() == messageCount);
// TODO: Some reason for partitioned entities the delivery count is incorrect. Investigate and enable
// 5 of these messages should have deliveryCount = 2
int messagesWithDeliveryCount2 = receivedMessages.Where(message => message.DeliveryCount == 2).Count();
TestUtility.Log($"Messages with Delivery Count 2: {messagesWithDeliveryCount2}");
Assert.True(messagesWithDeliveryCount2 == abandonMessagesCount);
// Complete Messages
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
}
protected async Task RenewLockTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive messages
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
BrokeredMessage message = receivedMessages.First();
DateTime firstLockedUntilUtcTime = message.LockedUntilUtc;
TestUtility.Log($"MessageLockedUntil: {firstLockedUntilUtcTime}");
TestUtility.Log("Sleeping 10 seconds...");
await Task.Delay(TimeSpan.FromSeconds(10));
DateTime lockedUntilUtcTime = await messageReceiver.RenewLockAsync(receivedMessages.First().LockToken);
TestUtility.Log($"After First Renewal: {lockedUntilUtcTime}");
Assert.True(lockedUntilUtcTime >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
TestUtility.Log("Sleeping 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
lockedUntilUtcTime = await messageReceiver.RenewLockAsync(receivedMessages.First().LockToken);
TestUtility.Log($"After Second Renewal: {lockedUntilUtcTime}");
Assert.True(lockedUntilUtcTime >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(5));
// Complete Messages
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
Assert.True(receivedMessages.Count() == messageCount);
}
protected async Task PeekLockWithDeadLetterTestCase(MessageSender messageSender, MessageReceiver messageReceiver, MessageReceiver deadLetterReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive 5 messages and Deadletter them
int deadLetterMessageCount = 5;
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, deadLetterMessageCount);
Assert.True(receivedMessages.Count() == deadLetterMessageCount);
await TestUtility.DeadLetterMessagesAsync(messageReceiver, receivedMessages);
// Receive and Complete 5 other regular messages
receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount - deadLetterMessageCount);
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
// TODO: After implementing Receive(WithTimeSpan), Add Try another Receive, We should not get anything.
// IEnumerable<BrokeredMessage> dummyMessages = await this.ReceiveMessagesAsync(queueClient, 10);
// Assert.True(dummyMessages == null);
// Receive 5 DLQ messages and Complete them
receivedMessages = await TestUtility.ReceiveMessagesAsync(deadLetterReceiver, deadLetterMessageCount);
Assert.True(receivedMessages.Count() == deadLetterMessageCount);
await TestUtility.CompleteMessagesAsync(deadLetterReceiver, receivedMessages);
}
internal async Task RenewLockTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
// Send messages
await TestUtility.SendMessagesAsync(messageSender, messageCount);
// Receive messages
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
var message = receivedMessages.First();
var firstLockedUntilUtcTime = message.SystemProperties.LockedUntilUtc;
TestUtility.Log($"MessageLockedUntil: {firstLockedUntilUtcTime}");
TestUtility.Log("Sleeping 10 seconds...");
await Task.Delay(TimeSpan.FromSeconds(10));
await messageReceiver.RenewLockAsync(message);
TestUtility.Log($"After First Renewal: {message.SystemProperties.LockedUntilUtc}");
Assert.True(message.SystemProperties.LockedUntilUtc >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
TestUtility.Log("Sleeping 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
await messageReceiver.RenewLockAsync(message.SystemProperties.LockToken);
TestUtility.Log($"After Second Renewal: {message.SystemProperties.LockedUntilUtc}");
Assert.True(message.SystemProperties.LockedUntilUtc >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(5));
// Complete Messages
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
Assert.True(receivedMessages.Count == messageCount);
}
protected async Task PeekLockTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
IEnumerable <BrokeredMessage> 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);
IEnumerable <Message> receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
Assert.True(messageCount == receivedMessages.Count());
}
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 PeekLockTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
var receivedMessages = await TestUtility.ReceiveMessagesAsync(messageReceiver, messageCount);
await TestUtility.CompleteMessagesAsync(messageReceiver, receivedMessages);
}
protected async Task ReceiveDeleteTestCase(MessageSender messageSender, MessageReceiver messageReceiver, int messageCount)
{
await TestUtility.SendMessagesAsync(messageSender, messageCount);
IEnumerable <BrokeredMessage> 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 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();
}
});
}
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();
}
}
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();
}
});
}
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);
}
}