async Task PeekSessionAsyncTest(string queueName, int messageCount = 10)
{
var queueClient = QueueClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(queueName), ReceiveMode.ReceiveAndDelete);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await queueClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId1, SessionId = sessionId1
});
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await queueClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId2, SessionId = sessionId2
});
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Peek Message, Receive and Delete with SessionId - sessionId 1
await this.PeekAndDeleteMessageAsync(queueClient, sessionId1, messageId1);
// Peek Message, Receive and Delete with SessionId - sessionId 2
await this.PeekAndDeleteMessageAsync(queueClient, sessionId2, messageId2);
}
finally
{
await queueClient.CloseAsync();
}
}
async Task SessionRenewLockTestCase(string topicName)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName);
try
{
var messageId = "test-message1";
var sessionId = Guid.NewGuid().ToString();
await topicClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId, SessionId = sessionId
});
TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}");
var sessionReceiver = await subscriptionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull((object)sessionReceiver);
var initialSessionLockedUntilTime = sessionReceiver.LockedUntilUtc;
TestUtility.Log($"Session LockedUntilUTC: {initialSessionLockedUntilTime} for Session: {sessionReceiver.SessionId}");
var message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
Assert.True(message.MessageId == messageId);
TestUtility.Log("Sleeping 10 seconds...");
await Task.Delay(TimeSpan.FromSeconds(10));
await sessionReceiver.RenewLockAsync();
var firstLockedUntilUtcTime = sessionReceiver.LockedUntilUtc;
TestUtility.Log($"After Renew Session LockedUntilUTC: {firstLockedUntilUtcTime} for Session: {sessionReceiver.SessionId}");
Assert.True(firstLockedUntilUtcTime >= initialSessionLockedUntilTime + TimeSpan.FromSeconds(10));
TestUtility.Log("Sleeping 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
await sessionReceiver.RenewLockAsync();
TestUtility.Log($"After Second Renew Session LockedUntilUTC: {sessionReceiver.LockedUntilUtc} for Session: {sessionReceiver.SessionId}");
Assert.True(sessionReceiver.LockedUntilUtc >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(5));
await message.CompleteAsync();
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
await sessionReceiver.CloseAsync();
}
finally
{
subscriptionClient.Close();
topicClient.Close();
}
}
async Task PeekLockDeferTest(string queueName, int messageCount = 10)
{
var queueClient = QueueClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(queueName));
try
{
await this.PeekLockDeferTestCase(queueClient.InnerSender, queueClient.InnerReceiver, messageCount);
}
finally
{
await queueClient.CloseAsync();
}
}
async Task ReceiveDeleteTest(string queueName, int messageCount = 10)
{
var queueClient = QueueClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(queueName), ReceiveMode.ReceiveAndDelete);
try
{
await this.ReceiveDeleteTestCase(queueClient.InnerSender, queueClient.InnerReceiver, messageCount);
}
finally
{
await queueClient.CloseAsync();
}
}
async Task SessionTest(string topicName)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await topicClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId1, SessionId = sessionId1
});
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await topicClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId2, SessionId = sessionId2
});
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Receive Message, Complete and Close with SessionId - sessionId 1
await this.AcceptAndCompleteSessionsAsync(subscriptionClient, sessionId1, messageId1);
// Receive Message, Complete and Close with SessionId - sessionId 2
await this.AcceptAndCompleteSessionsAsync(subscriptionClient, sessionId2, messageId2);
// Receive Message, Complete and Close - With Null SessionId specified
var messageId3 = "test-message3";
var sessionId3 = "sessionId3";
await topicClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId3, SessionId = sessionId3
});
await this.AcceptAndCompleteSessionsAsync(subscriptionClient, null, messageId3);
}
finally
{
subscriptionClient.Close();
topicClient.Close();
}
}
async Task TopicClientPeekLockWithAbandonTestCase(string topicName, int messageCount = 10)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName);
try
{
await this.PeekLockWithAbandonTestCase(topicClient.InnerSender, subscriptionClient.InnerReceiver, messageCount);
}
finally
{
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}
async Task SessionTest(string queueName)
{
var queueClient = QueueClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(queueName));
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await queueClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId1, SessionId = sessionId1
});
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await queueClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId2, SessionId = sessionId2
});
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Receive Message, Complete and Close with SessionId - sessionId 1
await this.AcceptAndCompleteSessionsAsync(queueClient, sessionId1, messageId1);
// Receive Message, Complete and Close with SessionId - sessionId 2
await this.AcceptAndCompleteSessionsAsync(queueClient, sessionId2, messageId2);
// Receive Message, Complete and Close - With Null SessionId specified
var messageId3 = "test-message3";
var sessionId3 = "sessionId3";
await queueClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId3, SessionId = sessionId3
});
await this.AcceptAndCompleteSessionsAsync(queueClient, null, messageId3);
}
finally
{
await queueClient.CloseAsync();
}
}
async Task PeekLockWithDeadLetterTest(string queueName, int messageCount = 10)
{
var queueClient = QueueClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(queueName));
// Create DLQ Client To Receive DeadLetteredMessages
var builder = new ServiceBusConnectionStringBuilder(TestUtility.GetEntityConnectionString(queueName));
builder.EntityPath = EntityNameHelper.FormatDeadLetterPath(queueClient.QueueName);
var deadLetterQueueClient = QueueClient.CreateFromConnectionString(builder.ToString());
try
{
await this.PeekLockWithDeadLetterTestCase(queueClient.InnerSender, queueClient.InnerReceiver, deadLetterQueueClient.InnerReceiver, messageCount);
}
finally
{
await deadLetterQueueClient.CloseAsync();
await queueClient.CloseAsync();
}
}
async Task TopicClientPeekLockWithDeadLetterTestCase(string topicName, int messageCount = 10)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName);
// Create DLQ Client To Receive DeadLetteredMessages
var builder = new ServiceBusConnectionStringBuilder(TestUtility.GetEntityConnectionString(topicName));
var subscriptionDeadletterPath = EntityNameHelper.FormatDeadLetterPath(this.SubscriptionName);
var deadLetterSubscriptionClient = SubscriptionClient.CreateFromConnectionString(TestUtility.GetEntityConnectionString(topicName), subscriptionDeadletterPath);
try
{
await this.PeekLockWithDeadLetterTestCase(topicClient.InnerSender, subscriptionClient.InnerReceiver, deadLetterSubscriptionClient.InnerReceiver, messageCount);
}
finally
{
await deadLetterSubscriptionClient.CloseAsync();
await topicClient.CloseAsync();
await subscriptionClient.CloseAsync();
}
}
async Task GetAndSetSessionStateTest(string topicName)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName);
try
{
var messageId = "test-message1";
var sessionId = Guid.NewGuid().ToString();
await topicClient.SendAsync(new BrokeredMessage()
{
MessageId = messageId, SessionId = sessionId
});
TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}");
var sessionReceiver = await subscriptionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull((object)sessionReceiver);
var message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
Assert.True(message.MessageId == messageId);
var sessionStateString = "Received Message From Session!";
var sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString));
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
var returnedSessionState = await sessionReceiver.GetStateAsync();
using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8))
{
var returnedSessionStateString = await reader.ReadToEndAsync();
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
}
// Complete message using Session Receiver
await sessionReceiver.CompleteAsync(new Guid[] { message.LockToken });
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
sessionStateString = "Completed Message On Session!";
sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString));
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
returnedSessionState = await sessionReceiver.GetStateAsync();
using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8))
{
var returnedSessionStateString = await reader.ReadToEndAsync();
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
}
await sessionReceiver.CloseAsync();
}
finally
{
subscriptionClient.Close();
topicClient.Close();
}
}
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();
}