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