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