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 RegisterHandlerOptions()
{
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);
}
async Task OnSessionTestAsync(string topicName, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete)
{
TestUtility.Log($"Topic: {topicName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName);
var subscriptionClient = new SubscriptionClient(
TestUtility.NamespaceConnectionString,
topicClient.TopicName,
this.SubscriptionName,
ReceiveMode.PeekLock);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = 5,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = true
};
var testSessionHandler = new TestSessionHandler(
subscriptionClient.ReceiveMode,
sessionHandlerOptions,
topicClient.InnerSender,
subscriptionClient.SessionPumpHost);
// Send messages to Session
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandler(sessionHandlerOptions);
// Verify messages were received.
await testSessionHandler.VerifyRun();
}
finally
{
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}
async Task AcceptAndCompleteSessionsAsync(SessionClient sessionClient, string sessionId, string messageId)
{
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
if (sessionId != null)
{
Assert.True(sessionReceiver.SessionId == sessionId);
}
var message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
await sessionReceiver.CloseAsync();
}
public async Task OnMessageExceptionHandlerCalledTest()
{
var invalidQueueName = "nonexistentqueuename";
var exceptionReceivedHandlerCalled = false;
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, invalidQueueName, ReceiveMode.ReceiveAndDelete);
queueClient.RegisterMessageHandler(
(message, token) => throw new Exception("Unexpected exception: Did not expect messages here"),
(eventArgs) =>
{
Assert.NotNull(eventArgs);
Assert.NotNull(eventArgs.Exception);
if (eventArgs.Exception is MessagingEntityNotFoundException)
{
exceptionReceivedHandlerCalled = true;
}
return(Task.CompletedTask);
});
try
{
var stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 10)
{
if (exceptionReceivedHandlerCalled)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
TestUtility.Log($"{DateTime.Now}: ExceptionReceivedHandlerCalled: {exceptionReceivedHandlerCalled}");
Assert.True(exceptionReceivedHandlerCalled);
}
finally
{
await queueClient.CloseAsync();
}
}
async Task PeekAndDeleteMessageAsync(SessionClient sessionClient, string sessionId, string messageId)
{
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
if (sessionId != null)
{
Assert.True(sessionReceiver.SessionId == sessionId);
}
var message = await sessionReceiver.PeekAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Peeked Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
await sessionReceiver.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 SessionTest(string queueName)
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await sender.SendAsync(new Message { MessageId = messageId1, SessionId = sessionId1 }).ConfigureAwait(false);
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await sender.SendAsync(new Message { MessageId = messageId2, SessionId = sessionId2 }).ConfigureAwait(false);
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Receive Message, Complete and Close with SessionId - sessionId 1
await this.AcceptAndCompleteSessionsAsync(sessionClient, sessionId1, messageId1).ConfigureAwait(false);
// Receive Message, Complete and Close with SessionId - sessionId 2
await this.AcceptAndCompleteSessionsAsync(sessionClient, sessionId2, messageId2).ConfigureAwait(false);
// Receive Message, Complete and Close - With Null SessionId specified
var messageId3 = "test-message3";
var sessionId3 = "sessionId3";
await sender.SendAsync(new Message { MessageId = messageId3, SessionId = sessionId3 }).ConfigureAwait(false);
await this.AcceptAndCompleteSessionsAsync(sessionClient, null, messageId3).ConfigureAwait(false);
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
async Task PeekSessionAsyncTest(string topicName, int messageCount = 10)
{
var entityConnectionString = TestUtility.GetEntityConnectionString(topicName);
var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName, ReceiveMode.ReceiveAndDelete);
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}");
// Peek Message, Receive and Delete with SessionId - sessionId 1
await this.PeekAndDeleteMessageAsync(subscriptionClient, sessionId1, messageId1);
// Peek Message, Receive and Delete with SessionId - sessionId 2
await this.PeekAndDeleteMessageAsync(subscriptionClient, sessionId2, messageId2);
}
finally
{
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}
public async Task OnSessionHandler(IMessageSession session, Message message, CancellationToken token)
{
Assert.NotNull(session);
Assert.NotNull(message);
this.totalMessageCount++;
TestUtility.Log($"Received Session: {session.SessionId} message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
if (this.receiveMode == ReceiveMode.PeekLock && !this.sessionHandlerOptions.AutoComplete)
{
await session.CompleteAsync(message.SystemProperties.LockToken);
}
if (!this.sessionMessageMap.ContainsKey(session.SessionId))
{
this.sessionMessageMap[session.SessionId] = 1;
}
else
{
this.sessionMessageMap[session.SessionId]++;
}
}
internal async Task CancelScheduledMessagesAsyncTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
var scheduleTime = new DateTimeOffset(DateTime.UtcNow).AddSeconds(30);
var brokeredMessage = new Message(Encoding.UTF8.GetBytes("Test1"))
{
MessageId = Guid.NewGuid().ToString()
};
TestUtility.Log(
$"Sending message with schedule time: {scheduleTime.UtcDateTime} and messageID {brokeredMessage.MessageId}");
var sequenceNumber = await messageSender.ScheduleMessageAsync(brokeredMessage, scheduleTime);
TestUtility.Log($"Received sequence number: {sequenceNumber}");
Assert.True(sequenceNumber > 0);
TestUtility.Log("Cancelling scheduled message");
await messageSender.CancelScheduledMessageAsync(sequenceNumber);
TestUtility.Log("Sleeping for 30 seconds...");
await Task.Delay(TimeSpan.FromSeconds(30));
// Sending a dummy message so that ReceiveAsync(2) returns immediately after getting 1 message
// instead of waiting for connection timeout on a single message.
await messageSender.SendAsync(new Message(Encoding.UTF8.GetBytes(("Dummy"))) { MessageId = "Dummy" });
IList <Message> messages = null;
var retryCount = 5;
while (messages == null && --retryCount > 0)
{
messages = await messageReceiver.ReceiveAsync(2);
}
Assert.NotNull(messages);
Assert.True(messages.Count == 1);
Assert.True(messages.First().MessageId == "Dummy");
}
async Task PeekSessionAsyncTest(string queueName, int messageCount = 10)
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await sender.SendAsync(new Message()
{
MessageId = messageId1, SessionId = sessionId1
});
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await sender.SendAsync(new Message()
{
MessageId = messageId2, SessionId = sessionId2
});
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Peek Message, Receive and Delete with SessionId - sessionId 1
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId1, messageId1);
// Peek Message, Receive and Delete with SessionId - sessionId 2
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId2, messageId2);
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Creates a temporary Service Bus queue to be used within a given scope and then removed.
/// </summary>
///
/// <param name="partitioned">If <c>true</c>, a partitioned queue will be used.</param>
/// <param name="sessionEnabled">If <c>true</c>, a session will be enabled on the queue.</param>
/// <param name="configureQueue">If provided, an action that can override the default properties used for queue creation.</param>
/// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param>
///
/// <returns>The queue scope that was created.</returns>
///
public static async Task <QueueScope> CreateQueueAsync(bool partitioned,
bool sessionEnabled,
Action <QueueDescription> configureQueue = null,
[CallerMemberName] string caller = "")
{
var name = $"{ caller }-{ Guid.NewGuid().ToString("D").Substring(0, 8) }";
var queueDescription = BuildQueueDescription(name, partitioned, sessionEnabled);
configureQueue?.Invoke(queueDescription);
await CreateRetryPolicy <QueueDescription>().ExecuteAsync(() => ManagementClient.CreateQueueAsync(queueDescription));
return(new QueueScope(name, async() =>
{
try
{
await CreateRetryPolicy().ExecuteAsync(() => ManagementClient.DeleteQueueAsync(name));
}
catch (Exception ex)
{
TestUtility.Log($"There was an issue removing the queue: [{ name }]. This is considered non-fatal, but you should remove this manually from the Service Bus namespace. Exception: [{ ex.Message }]");
}
}));
}
public async Task VerifyRun()
{
// Wait for the OnMessage Tasks to finish
var stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 180)
{
if (this.totalMessageCount == MessagesPerSession * NumberOfSessions)
{
TestUtility.Log($"All '{this.totalMessageCount}' messages Received.");
break;
}
await Task.Delay(TimeSpan.FromSeconds(5));
}
foreach (KeyValuePair <string, int> keyValuePair in this.sessionMessageMap)
{
TestUtility.Log($"Session: {keyValuePair.Key}, Messages Received in this Session: {keyValuePair.Value}");
}
Assert.True(this.sessionMessageMap.Keys.Count == NumberOfSessions);
Assert.True(this.totalMessageCount == MessagesPerSession * NumberOfSessions);
}
async Task UseITokenProviderWithAad()
{
var tenantId = "";
var aadAppId = "";
var aadAppSecret = "";
if (string.IsNullOrEmpty(tenantId))
{
TestUtility.Log($"Skipping test during scheduled runs.");
return;
}
var authContext = new AuthenticationContext($"https://login.windows.net/{tenantId}");
var cc = new ClientCredential(aadAppId, aadAppSecret);
var tokenProvider = TokenProvider.CreateAadTokenProvider(authContext, cc);
// Create new client with updated connection string.
var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString);
var queueClient = new QueueClient(csb.Endpoint, csb.EntityPath, tokenProvider);
// Send and receive messages.
await this.PeekLockTestCase(queueClient.InnerSender, queueClient.InnerReceiver, 10);
}
async Task OnSessionTestAsync(bool partitioned, bool sessionEnabled, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var handlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
handlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandler(handlerOptions);
// Verify messages were received.
await testSessionHandler.VerifyRun();
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task PeekSessionAsyncTest(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
var messageId1 = "test-message1";
var sessionId1 = "sessionId1";
await sender.SendAsync(new Message {
MessageId = messageId1, SessionId = sessionId1
});
TestUtility.Log($"Sent Message: {messageId1} to Session: {sessionId1}");
var messageId2 = "test-message2";
var sessionId2 = "sessionId2";
await sender.SendAsync(new Message {
MessageId = messageId2, SessionId = sessionId2
});
TestUtility.Log($"Sent Message: {messageId2} to Session: {sessionId2}");
// Peek Message, Receive and Delete with SessionId - sessionId 1
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId1, messageId1);
// Peek Message, Receive and Delete with SessionId - sessionId 2
await this.PeekAndDeleteMessageAsync(sessionClient, sessionId2, messageId2);
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
});
}
public async Task WaitingReceiveShouldReturnImmediatelyWhenReceiverIsClosed()
{
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName, ReceiveMode.ReceiveAndDelete);
TestUtility.Log("Begin to receive from an empty queue.");
Task quickTask;
try
{
quickTask = Task.Run(async() =>
{
try
{
await receiver.ReceiveAsync(TimeSpan.FromSeconds(40));
}
catch (Exception e)
{
TestUtility.Log("Unexpected exception: " + e);
}
});
await Task.Delay(2000);
TestUtility.Log("Waited for 2 Seconds for the ReceiveAsync to establish connection.");
}
finally
{
await receiver.CloseAsync().ConfigureAwait(false);
TestUtility.Log("Closed Receiver");
}
TestUtility.Log("Waiting for maximum 10 Secs");
var waitingTask = Task.Delay(10000);
Assert.Equal(quickTask, await Task.WhenAny(quickTask, waitingTask));
}
internal async Task ScheduleMessagesAppearAfterScheduledTimeAsyncTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount)
{
var startTime = DateTime.UtcNow;
var scheduleTime = new DateTimeOffset(DateTime.UtcNow).AddSeconds(5);
TestUtility.Log($"Sending message with schedule time: {scheduleTime.UtcDateTime}");
var sequenceNumber =
await
messageSender.ScheduleMessageAsync(
new Message(Encoding.UTF8.GetBytes("Test")) { MessageId = "randomId", Label = "randomLabel" }, scheduleTime);
TestUtility.Log($"Received sequence number: {sequenceNumber}");
Assert.True(sequenceNumber > 0);
TestUtility.Log("Sleeping for 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
var message = await messageReceiver.ReceiveAsync();
// Asserting using Math.Ceiling since TotalSeconds usually ends up being around 4.999 due to precision of
// the scheduleTime in requestMessage and responseMessage.
Assert.True(Math.Ceiling(message.ScheduledEnqueueTimeUtc.Subtract(startTime).TotalSeconds) >= 5);
}
async Task GetAndSetSessionStateTest(string queueName)
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName);
try
{
var messageId = "test-message1";
var sessionId = Guid.NewGuid().ToString();
await sender.SendAsync(new Message
{
MessageId = messageId,
SessionId = sessionId
});
TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(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 = Encoding.UTF8.GetBytes(sessionStateString);
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
var returnedSessionState = await sessionReceiver.GetStateAsync();
var returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
// Complete message using Session Receiver
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
sessionStateString = "Completed Message On Session!";
sessionState = Encoding.UTF8.GetBytes(sessionStateString);
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
returnedSessionState = await sessionReceiver.GetStateAsync();
returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
private Task ExceptionReceivedHandler(ExceptionReceivedEventArgs eventArgs)
{
TestUtility.Log($"Exception Received: ClientId: {eventArgs.ExceptionReceivedContext.ClientId}, EntityPath: {eventArgs.ExceptionReceivedContext.EntityPath}, Exception: {eventArgs.Exception.Message}");
return(Task.CompletedTask);
}
private async Task OnSessionTestAsync(bool partitioned, bool sessionEnabled, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var handlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
handlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandler(handlerOptions);
// Verify messages were received.
await testSessionHandler.VerifyRun();
testSessionHandler.ClearData();
}
finally
{
await queueClient.CloseAsync();
}
});
// test UnregisterSessionHandler can wait for message handling upto the timeout user defined.
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
sessionHandlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
var count = 0;
testSessionHandler.RegisterSessionHandler(
async(session, message, token) =>
{
await Task.Delay(TimeSpan.FromSeconds(8));
TestUtility.Log($"Received Session: {session.SessionId} message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
if (queueClient.ReceiveMode == ReceiveMode.PeekLock && !sessionHandlerOptions.AutoComplete)
{
await session.CompleteAsync(message.SystemProperties.LockToken);
}
Interlocked.Increment(ref count);
},
sessionHandlerOptions);
await Task.Delay(TimeSpan.FromSeconds(2));
// UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks
await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(10));
Assert.True(count == maxConcurrentCalls);
testSessionHandler.ClearData();
}
finally
{
await queueClient.CloseAsync();
}
});
// test UnregisterSessionHandler can close down in time when message handling takes longer than wait timeout user defined.
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
sessionHandlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
var count = 0;
testSessionHandler.RegisterSessionHandler(
async(session, message, token) =>
{
await Task.Delay(TimeSpan.FromSeconds(8));
TestUtility.Log($"Received Session: {session.SessionId} message: SequenceNumber: {message.SystemProperties.SequenceNumber}");
if (queueClient.ReceiveMode == ReceiveMode.PeekLock && !sessionHandlerOptions.AutoComplete)
{
await session.CompleteAsync(message.SystemProperties.LockToken);
}
Interlocked.Increment(ref count);
},
sessionHandlerOptions);
await Task.Delay(TimeSpan.FromSeconds(2));
// UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks
await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(2));
Assert.True(count == 0);
testSessionHandler.ClearData();
}
finally
{
await queueClient.CloseAsync();
}
});
}
private async Task OnSessionTestAsync(bool partitioned, bool sessionEnabled, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var handlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
handlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandler(handlerOptions);
// Verify messages were received.
await testSessionHandler.VerifyRun();
testSessionHandler.ClearData();
}
finally
{
await queueClient.CloseAsync();
}
});
// test UnregisterSessionHandler can wait for message handling upto the timeout user defined.
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
sessionHandlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 8);
// Session handler set up has greater latency than message handler. Delay here to enable some processing time of the session pump.
await Task.Delay(TimeSpan.FromSeconds(2));
// UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks
await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(10));
Assert.True(testSessionHandler.ReceivedMessageCount == maxConcurrentCalls);
// Reregister won't have any problems
testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 0);
await testSessionHandler.WaitForAllMessagesReceived(ExpectedMessageCount);
Assert.True(testSessionHandler.ReceivedMessageCount == ExpectedMessageCount);
testSessionHandler.ClearData();
}
finally
{
await queueClient.CloseAsync();
}
});
// test UnregisterSessionHandler can close down in time when message handling takes longer than wait timeout user defined.
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}");
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = maxConcurrentCalls,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = autoComplete
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
sessionHandlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Send messages to Session first
await testSessionHandler.SendSessionMessages();
// Register handler
testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 8);
// UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks
await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(2));
Assert.True(testSessionHandler.ReceivedMessageCount == 0);
// Reregister won't have any problems
testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 0);
await testSessionHandler.WaitForAllMessagesReceived(ExpectedMessageCount);
Assert.True(testSessionHandler.ReceivedMessageCount == ExpectedMessageCount);
testSessionHandler.ClearData();
}
finally
{
await queueClient.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();
}
}
public async Task CorrelationFilterTestCase(string topicName)
{
var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName);
var subscriptionClient = new SubscriptionClient(
TestUtility.NamespaceConnectionString,
topicName,
this.SubscriptionName,
ReceiveMode.ReceiveAndDelete);
try
{
try
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
catch (Exception e)
{
TestUtility.Log($"Remove Default Rule failed with Exception: {e.Message}");
}
await subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter {
Label = "Red"
},
Name = "RedCorrelation"
});
var messageId1 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message { MessageId = messageId1, Label = "Blue" });
TestUtility.Log($"Sent Message: {messageId1}");
var messageId2 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message { MessageId = messageId2, Label = "Red" });
TestUtility.Log($"Sent Message: {messageId2}");
var messages = await subscriptionClient.InnerSubscriptionClient.InnerReceiver.ReceiveAsync(maxMessageCount : 2);
Assert.NotNull(messages);
Assert.True(messages.Count == 1);
Assert.Equal(messageId2, messages.First().MessageId);
}
finally
{
try
{
await subscriptionClient.RemoveRuleAsync("RedCorrelation");
await subscriptionClient.AddRuleAsync(RuleDescription.DefaultRuleName, new TrueFilter());
}
catch (Exception e)
{
TestUtility.Log($" Cleanup failed with Exception: {e.Message}");
}
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}
async Task SessionLockLostExceptionTest()
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
try
{
var messageId = "test-message1";
var sessionId = Guid.NewGuid().ToString();
await sender.SendAsync(new Message()
{
MessageId = messageId, SessionId = sessionId
});
TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
Message message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
// Let the Session expire with some buffer time
TestUtility.Log($"Waiting for session lock to time out...");
await Task.Delay((sessionReceiver.LockedUntilUtc - DateTime.UtcNow) + TimeSpan.FromSeconds(10));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.ReceiveAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.RenewSessionLockAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.GetStateAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.SetStateAsync(null));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken));
await sessionReceiver.CloseAsync();
TestUtility.Log($"Closed Session Receiver...");
//Accept a new Session and Complete the message
sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}");
message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
}
public async Task SqlFilterTestCase(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingTopicAsync(partitioned, sessionEnabled, async (topicName, subscriptionName) =>
{
var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName);
var subscriptionClient = new SubscriptionClient(
TestUtility.NamespaceConnectionString,
topicName,
subscriptionName,
ReceiveMode.ReceiveAndDelete);
try
{
try
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
catch (Exception e)
{
TestUtility.Log($"Remove Default Rule failed with: {e.Message}");
}
await subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new SqlFilter("Color = 'RedSql'"),
Name = "RedSql"
});
var messageId1 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message
{
MessageId = messageId1,
Label = "BlueSql",
UserProperties = { { "color", "BlueSql" } }
});
TestUtility.Log($"Sent Message: {messageId1}");
var messageId2 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message
{
MessageId = messageId2,
Label = "RedSql",
UserProperties = { { "color", "RedSql" } }
});
TestUtility.Log($"Sent Message: {messageId2}");
var messages = await subscriptionClient.InnerSubscriptionClient.InnerReceiver.ReceiveAsync(maxMessageCount: 2);
Assert.NotNull(messages);
Assert.True(messages.Count == 1);
Assert.Equal(messageId2, messages.First().MessageId);
}
finally
{
try
{
await subscriptionClient.RemoveRuleAsync("RedSql");
await subscriptionClient.AddRuleAsync(RuleDescription.DefaultRuleName, new TrueFilter());
}
catch (Exception e)
{
TestUtility.Log($" Cleanup failed with Exception: {e.Message}");
}
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
});
}
public override void After(MethodInfo methodUnderTest)
{
TestUtility.Log($"End {methodUnderTest.DeclaringType}.{methodUnderTest.Name}");
base.After(methodUnderTest);
}
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);
}
public override void Before(MethodInfo methodUnderTest)
{
TestUtility.Log($"Begin {methodUnderTest.DeclaringType}.{methodUnderTest.Name} on {PlatformServices.Default.Application.RuntimeFramework}");
base.Before(methodUnderTest);
}
public async Task SqlActionTestCase(string topicName)
{
var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName);
var subscriptionClient = new SubscriptionClient(
TestUtility.NamespaceConnectionString,
topicName,
this.SubscriptionName,
ReceiveMode.ReceiveAndDelete);
try
{
try
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
catch
{
// ignored
}
await subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new SqlFilter("Color = 'RedSqlAction'"),
Action = new SqlRuleAction("SET Color = 'RedSqlActionProcessed'"),
Name = "RedSqlAction"
});
var messageId1 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message
{
MessageId = messageId1,
Label = "BlueSqlAction",
UserProperties = { { "color", "BlueSqlAction" } }
});
TestUtility.Log($"Sent Message: {messageId1}");
var messageId2 = Guid.NewGuid().ToString();
await topicClient.SendAsync(new Message
{
MessageId = messageId2,
Label = "RedSqlAction",
UserProperties = { { "color", "RedSqlAction" } }
});
TestUtility.Log($"Sent Message: {messageId2}");
var messages = await subscriptionClient.InnerSubscriptionClient.InnerReceiver.ReceiveAsync(maxMessageCount : 2);
Assert.NotNull(messages);
Assert.True(messages.Count == 1);
Assert.Equal(messageId2, messages.First().MessageId);
Assert.True(messages.First().UserProperties["color"].Equals("RedSqlActionProcessed"));
}
finally
{
await subscriptionClient.RemoveRuleAsync("RedSqlAction");
await subscriptionClient.AddRuleAsync(RuleDescription.DefaultRuleName, new TrueFilter());
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}