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);
}
public async Task SendSessionMessages()
{
await TestUtility.SendSessionMessagesAsync(this.sender, NumberOfSessions, MessagesPerSession);
}
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();
}
});
}
private Task ExceptionReceivedHandler(ExceptionReceivedEventArgs eventArgs)
{
TestUtility.Log($"Exception Received: ClientId: {eventArgs.ExceptionReceivedContext.ClientId}, EntityPath: {eventArgs.ExceptionReceivedContext.EntityPath}, Exception: {eventArgs.Exception.Message}");
return(Task.CompletedTask);
}
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 = 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(message.SystemProperties.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
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
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();
}
}
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 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();
}
async Task SqlFilterTestCase(string topicName, int messageCount = 10)
{
var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName);
var subscriptionClient = new SubscriptionClient(
TestUtility.NamespaceConnectionString,
topicName,
this.SubscriptionName,
ReceiveMode.ReceiveAndDelete);
try
{
try
{
await subscriptionClient.RemoveRuleAsync(SubscriptionClient.DefaultRule);
}
catch
{
// ignored
}
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.True(messageId2.Equals(messages.First().MessageId));
}
finally
{
await subscriptionClient.RemoveRuleAsync("RedSql");
await subscriptionClient.AddRuleAsync(SubscriptionClient.DefaultRule, new TrueFilter());
await subscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
}
