public async Task ClientThrowsUnauthorizedExceptionWhenUserDoesntHaveAccess()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString);
csb.SasKeyName = "nonExistingKey";
csb.EntityPath = queueName;
var sender = new MessageSender(csb);
try
{
await Assert.ThrowsAsync <UnauthorizedException>(
async() => await sender.SendAsync(new Message()));
long nonExistingSequenceNumber = 1000;
await Assert.ThrowsAsync <UnauthorizedException>(
async() => await sender.CancelScheduledMessageAsync(nonExistingSequenceNumber));
}
finally
{
await sender.CloseAsync();
}
});
}
public async Task ClientsUseGlobalConnectionCloseFirstClientSecoundClientShouldSendMessage()
{
await ServiceBusScope.UsingQueueAsync(partitioned : true, sessionEnabled : false, async queueName =>
{
var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString);
var connection = new ServiceBusConnection(csb);
var sender = new MessageSender(connection, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
try
{
var messageBody = Encoding.UTF8.GetBytes("Message");
var message = new Message(messageBody);
await sender.SendAsync(message);
await sender.CloseAsync();
var recivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false);
Assert.True(Encoding.UTF8.GetString(recivedMessage.Body) == Encoding.UTF8.GetString(messageBody));
connection = sender.ServiceBusConnection;
sender = new MessageSender(connection, queueName);
messageBody = Encoding.UTF8.GetBytes("Message 2");
message = new Message(messageBody);
await sender.SendAsync(message);
recivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false);
Assert.True(Encoding.UTF8.GetString(recivedMessage.Body) == Encoding.UTF8.GetString(messageBody));
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
}
});
}
public async Task ClientThrowsObjectDisposedExceptionWhenUserCloseConnectionAndWouldUseOldSeviceBusConnection()
{
await ServiceBusScope.UsingQueueAsync(partitioned : true, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
try
{
var messageBody = Encoding.UTF8.GetBytes("Message");
var message = new Message(messageBody);
await sender.SendAsync(message);
await sender.CloseAsync();
var recivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false);
Assert.True(Encoding.UTF8.GetString(recivedMessage.Body) == Encoding.UTF8.GetString(messageBody));
var connection = sender.ServiceBusConnection;
Assert.Throws <ObjectDisposedException>(() => new MessageSender(connection, queueName));
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
}
});
}
public async Task DeadLetterReasonShouldPropagateToTheReceivedMessage()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName);
var dlqReceiver = new MessageReceiver(TestUtility.NamespaceConnectionString, EntityNameHelper.FormatDeadLetterPath(queueName), ReceiveMode.ReceiveAndDelete);
try
{
await sender.SendAsync(new Message(Encoding.UTF8.GetBytes("deadLetterTest2")));
var message = await receiver.ReceiveAsync();
Assert.NotNull(message);
await receiver.DeadLetterAsync(
message.SystemProperties.LockToken,
"deadLetterReason",
"deadLetterDescription");
var dlqMessage = await dlqReceiver.ReceiveAsync();
Assert.NotNull(dlqMessage);
Assert.True(dlqMessage.UserProperties.ContainsKey(Message.DeadLetterReasonHeader));
Assert.True(dlqMessage.UserProperties.ContainsKey(Message.DeadLetterErrorDescriptionHeader));
Assert.Equal("deadLetterReason", dlqMessage.UserProperties[Message.DeadLetterReasonHeader]);
Assert.Equal("deadLetterDescription", dlqMessage.UserProperties[Message.DeadLetterErrorDescriptionHeader]);
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
await dlqReceiver.CloseAsync();
}
});
}
private async Task OnMessageTestAsync(bool partitioned, bool sessionEnabled, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete)
{
const int messageCount = 10;
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
await this.OnMessageAsyncTestCase(
queueClient.InnerSender,
queueClient.InnerReceiver,
maxConcurrentCalls,
autoComplete,
messageCount);
}
finally
{
await queueClient.CloseAsync();
}
});
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
await this.OnMessageAsyncUnregisterHandlerLongTimeoutTestCase(
queueClient.InnerSender,
queueClient.InnerReceiver,
maxConcurrentCalls,
autoComplete,
messageCount);
}
finally
{
await queueClient.CloseAsync();
}
});
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode);
try
{
await this.OnMessageAsyncUnregisterHandlerShortTimeoutTestCase(
queueClient.InnerSender,
queueClient.InnerReceiver,
maxConcurrentCalls,
autoComplete,
messageCount);
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task GetAndSetSessionStateTest(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);
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();
await sessionClient.CloseAsync();
}
});
}
async Task SendAndReceiveWithWebSocketsTest()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var taskCompletionSource = new TaskCompletionSource <Message>();
var queueClient = new QueueClient(TestUtility.WebSocketsNamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
var random = new Random();
var contentAsBytes = new byte[8];
random.NextBytes(contentAsBytes);
queueClient.RegisterMessageHandler((message, token) =>
{
taskCompletionSource.SetResult(message);
return(Task.CompletedTask);
},
exceptionReceivedArgs =>
{
taskCompletionSource.SetException(exceptionReceivedArgs.Exception);
return(Task.CompletedTask);
});
await queueClient.SendAsync(new Message(contentAsBytes));
var receiveTask = taskCompletionSource.Task;
if (receiveTask.IsCompleted || Debugger.IsAttached)
{
await receiveTask;
}
else
{
var cancelletionSource = new CancellationTokenSource();
if (receiveTask == (await Task.WhenAny(receiveTask, Task.Delay(Timeout, cancelletionSource.Token))))
{
cancelletionSource.Cancel();
await receiveTask;
}
else
{
throw new TimeoutException();
}
}
var receivedMessage = receiveTask.Result;
Assert.Equal(contentAsBytes, receivedMessage.Body);
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task MessagePropertiesShouldSupportValidPropertyTypes()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
/// Only following value types are supported:
/// byte, sbyte, char, short, ushort, int, uint, long, ulong, float, double, decimal,
/// bool, Guid, string, Uri, DateTime, DateTimeOffset, TimeSpan
var msg = new Message();
msg.UserProperties.Add("byte", (byte)2);
msg.UserProperties.Add("sbyte", (sbyte)3);
msg.UserProperties.Add("char", 'c');
msg.UserProperties.Add("short", (short)4);
msg.UserProperties.Add("ushort", (ushort)5);
msg.UserProperties.Add("int", (int)6);
msg.UserProperties.Add("uint", (uint)7);
msg.UserProperties.Add("long", (long)8);
msg.UserProperties.Add("ulong", (ulong)9);
msg.UserProperties.Add("float", (float)10.0);
msg.UserProperties.Add("double", (double)11.0);
msg.UserProperties.Add("decimal", (decimal)12.0);
msg.UserProperties.Add("bool", true);
msg.UserProperties.Add("Guid", Guid.NewGuid());
msg.UserProperties.Add("string", "value");
msg.UserProperties.Add("Uri", new Uri("http://nonExistingServiceBusWebsite.com"));
msg.UserProperties.Add("DateTime", DateTime.UtcNow);
msg.UserProperties.Add("DateTimeOffset", DateTimeOffset.UtcNow);
msg.UserProperties.Add("TimeSpan", TimeSpan.FromMinutes(5));
await sender.SendAsync(msg);
var receivedMsg = await receiver.ReceiveAsync();
Assert.IsType <byte>(receivedMsg.UserProperties["byte"]);
Assert.IsType <sbyte>(receivedMsg.UserProperties["sbyte"]);
Assert.IsType <char>(receivedMsg.UserProperties["char"]);
Assert.IsType <short>(receivedMsg.UserProperties["short"]);
Assert.IsType <ushort>(receivedMsg.UserProperties["ushort"]);
Assert.IsType <int>(receivedMsg.UserProperties["int"]);
Assert.IsType <uint>(receivedMsg.UserProperties["uint"]);
Assert.IsType <long>(receivedMsg.UserProperties["long"]);
Assert.IsType <ulong>(receivedMsg.UserProperties["ulong"]);
Assert.IsType <float>(receivedMsg.UserProperties["float"]);
Assert.IsType <double>(receivedMsg.UserProperties["double"]);
Assert.IsType <decimal>(receivedMsg.UserProperties["decimal"]);
Assert.IsType <bool>(receivedMsg.UserProperties["bool"]);
Assert.IsType <Guid>(receivedMsg.UserProperties["Guid"]);
Assert.IsType <string>(receivedMsg.UserProperties["string"]);
Assert.IsType <Uri>(receivedMsg.UserProperties["Uri"]);
Assert.IsType <DateTime>(receivedMsg.UserProperties["DateTime"]);
Assert.IsType <DateTimeOffset>(receivedMsg.UserProperties["DateTimeOffset"]);
Assert.IsType <TimeSpan>(receivedMsg.UserProperties["TimeSpan"]);
});
}
public async Task SessionRenewLockTest(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);
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($"Session LockedUntilUTC: {sessionReceiver.LockedUntilUtc} 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));
// For session it looks like when the session is received, sometimes the session LockedUntil UTC
// is turning out slightly more than the Default Lock Duration(lock is for 1 minute, but the session was locked
// for 1 min and 2 seconds. We will need to look at if this is an issue on service or some kind of time skew.
// Temporarily changing this test to look at the renew request time instead.
var renewRequestTime = DateTime.UtcNow;
await sessionReceiver.RenewSessionLockAsync();
var firstLockedUntilUtcTime = sessionReceiver.LockedUntilUtc;
TestUtility.Log($"After Renew Session LockedUntilUTC: {firstLockedUntilUtcTime} for Session: {sessionReceiver.SessionId}");
Assert.True(firstLockedUntilUtcTime >= renewRequestTime + TimeSpan.FromSeconds(10));
TestUtility.Log("Sleeping 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
renewRequestTime = DateTime.UtcNow;
await sessionReceiver.RenewSessionLockAsync();
TestUtility.Log($"After Second Renew Session LockedUntilUTC: {sessionReceiver.LockedUntilUtc} for Session: {sessionReceiver.SessionId}");
Assert.True(sessionReceiver.LockedUntilUtc >= renewRequestTime + TimeSpan.FromSeconds(5));
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
});
}
public async Task TransactionalSessionDispositionTest(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(ConnectionString, queueName);
var sessionClient = new SessionClient(ConnectionString, queueName);
IMessageSession receiver = null;
try
{
string body = Guid.NewGuid().ToString("N");
var message = new Message(body.GetBytes())
{
SessionId = body
};
await sender.SendAsync(message).ConfigureAwait(false);
receiver = await sessionClient.AcceptMessageSessionAsync(body);
var receivedMessage = await receiver.ReceiveAsync(ReceiveTimeout);
Assert.NotNull(receivedMessage);
Assert.Equal(body, receivedMessage.Body.GetString());
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);
ts.Dispose();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);
ts.Complete();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken));
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
await receiver?.CloseAsync();
}
});
}
public async Task SessionLockLostExceptionTest()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : true, async 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);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
var 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();
}
});
}
async Task QueueClientShouldPassPluginsToMessageSession()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : true, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
var messageReceived = false;
var sendReceivePlugin = new SendReceivePlugin();
queueClient.RegisterPlugin(sendReceivePlugin);
var sendMessage = new Message(Encoding.UTF8.GetBytes("Test message"))
{
MessageId = Guid.NewGuid().ToString(),
SessionId = Guid.NewGuid().ToString()
};
await queueClient.SendAsync(sendMessage);
// Ensure the plugin is called.
Assert.True(sendReceivePlugin.MessageBodies.ContainsKey(sendMessage.MessageId));
queueClient.RegisterSessionHandler(
(session, message, cancellationToken) =>
{
Assert.Equal(sendMessage.SessionId, session.SessionId);
Assert.True(session.RegisteredPlugins.Contains(sendReceivePlugin));
Assert.Equal(sendMessage.Body, message.Body);
messageReceived = true;
return(Task.CompletedTask);
},
exceptionArgs => Task.CompletedTask);
for (var i = 0; i < 20; i++)
{
if (messageReceived)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(2));
}
Assert.True(messageReceived);
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task OnSessionExceptionHandlerCalledWhenRegisteredOnNonSessionFulQueue()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var exceptionReceivedHandlerCalled = false;
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
var sessionHandlerOptions = new SessionHandlerOptions(
(eventArgs) =>
{
Assert.NotNull(eventArgs);
Assert.NotNull(eventArgs.Exception);
if (eventArgs.Exception is InvalidOperationException)
{
exceptionReceivedHandlerCalled = true;
}
return(Task.CompletedTask);
})
{
MaxConcurrentSessions = 1
};
queueClient.RegisterSessionHandler(
(session, message, token) =>
{
return(Task.CompletedTask);
},
sessionHandlerOptions);
var stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds <= 10)
{
if (exceptionReceivedHandlerCalled)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
Assert.True(exceptionReceivedHandlerCalled);
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task WaitingReceiveShouldReturnImmediatelyWhenReceiverIsClosed()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, 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();
TestUtility.Log("Closed Receiver");
}
TestUtility.Log("Waiting for maximum 10 Secs");
bool receiverReturnedInTime = false;
using (var timeoutCancellationTokenSource = new CancellationTokenSource())
{
var completedTask = await Task.WhenAny(quickTask, Task.Delay(10000, timeoutCancellationTokenSource.Token));
if (completedTask == quickTask)
{
timeoutCancellationTokenSource.Cancel();
receiverReturnedInTime = true;
TestUtility.Log("The Receiver closed in time.");
}
else
{
TestUtility.Log("The Receiver did not close in time.");
}
}
Assert.True(receiverReturnedInTime);
});
}
public async Task OnMessageRegistrationWithoutPendingMessagesReceiveAndDelete(bool partitioned, bool sessionEnabled, int maxConcurrentCalls)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
await this.OnMessageRegistrationWithoutPendingMessagesTestCase(queueClient.InnerSender, queueClient.InnerReceiver, maxConcurrentCalls, true);
}
finally
{
await queueClient.CloseAsync();
}
});
}
async Task PeekLockWithAbandonTest(bool partitioned, bool sessionEnabled, int messageCount = 10)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName);
try
{
await this.PeekLockWithAbandonTestCase(queueClient.InnerSender, queueClient.InnerReceiver, messageCount);
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task ReceiveDeleteTest(bool partitioned, bool sessionEnabled, int messageCount = 10)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
await this.ReceiveDeleteTestCase(queueClient.InnerSender, queueClient.InnerReceiver, messageCount);
}
finally
{
await queueClient.CloseAsync();
}
});
}
async Task Unregistering_plugin_should_complete_without_plugin_set()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var messageReceiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
messageReceiver.UnregisterPlugin("Non-existant plugin");
}
finally
{
await messageReceiver.CloseAsync();
}
});
}
public async Task OperationsOnMessageSenderReceiverAfterCloseShouldThrowObjectDisposedExceptionTest()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
await sender.CloseAsync();
await receiver.CloseAsync();
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sender.SendAsync(new Message(Encoding.UTF8.GetBytes("test"))));
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await receiver.ReceiveAsync());
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await receiver.CompleteAsync("blah"));
});
}
public async Task TransactionCommitWorksAcrossClientsUsingSameConnectionToSameEntity()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var connection = new ServiceBusConnection(ConnectionString);
var sender = new MessageSender(connection, queueName);
var receiver = new MessageReceiver(connection, queueName);
try
{
string body1 = Guid.NewGuid().ToString("N");
string body2 = Guid.NewGuid().ToString("N");
var message = new Message(body1.GetBytes());
var message2 = new Message(body2.GetBytes());
await sender.SendAsync(message).ConfigureAwait(false);
var receivedMessage = await receiver.ReceiveAsync(ReceiveTimeout);
Assert.NotNull(receivedMessage);
Assert.Equal(body1, receivedMessage.Body.GetString());
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);
await sender.SendAsync(message2).ConfigureAwait(false);
ts.Complete();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
// Assert that complete did succeed
await Assert.ThrowsAsync <MessageLockLostException>(async() => await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken));
// Assert that send did succeed
receivedMessage = await receiver.ReceiveAsync(ReceiveTimeout);
Assert.NotNull(receivedMessage);
Assert.Equal(body2, receivedMessage.Body.GetString());
await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
await connection.CloseAsync();
}
});
}
public async Task ReceiveShouldThrowForServerTimeoutZeroTest(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
try
{
await this.ReceiveShouldThrowForServerTimeoutZero(receiver);
}
finally
{
await receiver.CloseAsync();
}
});
}
public async Task NonAmqpUriSchemesShouldWorkAsExpected()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString);
csb.Endpoint = new UriBuilder(csb.Endpoint)
{
Scheme = Uri.UriSchemeHttps
}.Uri.ToString();
csb.EntityPath = queueName;
var receiver = new MessageReceiver(csb);
var msg = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
await receiver.CloseAsync();
});
}
public async Task OnSessionCanStartWithNullMessageButReturnSessionLater()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : true, async queueName =>
{
var queueClient = new QueueClient(
TestUtility.NamespaceConnectionString,
queueName,
ReceiveMode.PeekLock);
try
{
var sessionHandlerOptions =
new SessionHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentSessions = 5,
MessageWaitTimeout = TimeSpan.FromSeconds(5),
AutoComplete = true
};
var testSessionHandler = new TestSessionHandler(
queueClient.ReceiveMode,
sessionHandlerOptions,
queueClient.InnerSender,
queueClient.SessionPumpHost);
// Register handler first without any messages
testSessionHandler.RegisterSessionHandler(sessionHandlerOptions);
// Send messages to Session
await testSessionHandler.SendSessionMessages();
// Verify messages were received.
await testSessionHandler.VerifyRun();
// Clear the data and re-run the scenario.
testSessionHandler.ClearData();
await testSessionHandler.SendSessionMessages();
// Verify messages were received.
await testSessionHandler.VerifyRun();
}
finally
{
await queueClient.CloseAsync();
}
});
}
public async Task SessionTest(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);
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();
await sessionClient.CloseAsync();
}
});
}
public async Task CancelScheduledMessageShouldThrowMessageNotFoundException()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
try
{
long nonExistingSequenceNumber = 1000;
await Assert.ThrowsAsync <MessageNotFoundException>(
async() => await sender.CancelScheduledMessageAsync(nonExistingSequenceNumber));
}
finally
{
await sender.CloseAsync();
}
});
}
async Task ReceiveShouldReturnNoLaterThanServerWaitTimeTest(bool partitioned, bool sessionEnabled, int messageCount = 1)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
try
{
await this.ReceiveShouldReturnNoLaterThanServerWaitTimeTestCase(sender, receiver, messageCount);
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await receiver.CloseAsync().ConfigureAwait(false);
}
});
}
public async Task Unregistering_plugin_should_complete_with_plugin_set()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var messageReceiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
try
{
var firstPlugin = new FirstSendPlugin();
messageReceiver.RegisterPlugin(firstPlugin);
messageReceiver.UnregisterPlugin(firstPlugin.Name);
}
finally
{
await messageReceiver.CloseAsync();
}
});
}
public async Task PeekAsyncTest(bool partitioned, bool sessionEnabled, int messageCount = 10)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
try
{
await this.PeekAsyncTestCase(sender, receiver, messageCount);
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
}
});
}
async Task MessageReceiverAndMessageSenderCreationWorksAsExpected(bool partitioned, bool sessionEnabled, int messageCount = 10)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.PeekLock);
try
{
await this.PeekLockTestCase(sender, receiver, messageCount);
}
finally
{
await sender.CloseAsync();
await receiver.CloseAsync();
}
});
}
public async Task OperationsOnMessageSessionAfterCloseShouldThrowObjectDisposedExceptionTest()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : true, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName);
IMessageSession sessionReceiver = null;
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}");
sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
await sessionReceiver.CloseAsync();
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.ReceiveAsync());
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.GetStateAsync());
await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.SetStateAsync(null));
sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Reaccept Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
var message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
});
}