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); } }