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();
}
});
}
async Task PeekDeliveryCountTest(string queueName)
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1);
var message = await TestUtility.PeekMessageAsync(queueClient.InnerReceiver);
Assert.Equal(0, message.SystemProperties.DeliveryCount);
}
finally
{
var messageToDelete = await TestUtility.ReceiveMessagesAsync(queueClient.InnerReceiver, 1);
await TestUtility.CompleteMessagesAsync(queueClient.InnerReceiver, messageToDelete);
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);
}
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);
}
}