internal async Task ScheduleMessagesAppearAfterScheduledTimeAsyncTestCase(IMessageSender messageSender, IMessageReceiver messageReceiver, int messageCount) { var startTime = DateTime.UtcNow; var scheduleTime = new DateTimeOffset(DateTime.UtcNow).AddSeconds(5); TestUtility.Log($"Sending message with schedule time: {scheduleTime.UtcDateTime}"); var sequenceNumber = await messageSender.ScheduleMessageAsync( new Message(Encoding.UTF8.GetBytes("Test")) { MessageId = "randomId", Label = "randomLabel" }, scheduleTime); TestUtility.Log($"Received sequence number: {sequenceNumber}"); Assert.True(sequenceNumber > 0); TestUtility.Log("Sleeping for 5 seconds..."); await Task.Delay(TimeSpan.FromSeconds(5)); var message = await messageReceiver.ReceiveAsync(); // Asserting using Math.Ceiling since TotalSeconds usually ends up being around 4.999 due to precision of // the scheduleTime in requestMessage and responseMessage. Assert.True(Math.Ceiling(message.ScheduledEnqueueTimeUtc.Subtract(startTime).TotalSeconds) >= 5); }
public async Task SendSessionMessages() { await TestUtility.SendSessionMessagesAsync(this.sender, NumberOfSessions, MessagesPerSession); }
public async Task SqlFilterTestCase(bool partitioned, bool sessionEnabled) { await ServiceBusScope.UsingTopicAsync(partitioned, sessionEnabled, async (topicName, subscriptionName) => { var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName); var subscriptionClient = new SubscriptionClient( TestUtility.NamespaceConnectionString, topicName, subscriptionName, ReceiveMode.ReceiveAndDelete); try { try { await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName); } catch (Exception e) { TestUtility.Log($"Remove Default Rule failed with: {e.Message}"); } await subscriptionClient.AddRuleAsync(new RuleDescription { Filter = new SqlFilter("Color = 'RedSql'"), Name = "RedSql" }); var messageId1 = Guid.NewGuid().ToString(); await topicClient.SendAsync(new Message { MessageId = messageId1, Label = "BlueSql", UserProperties = { { "color", "BlueSql" } } }); TestUtility.Log($"Sent Message: {messageId1}"); var messageId2 = Guid.NewGuid().ToString(); await topicClient.SendAsync(new Message { MessageId = messageId2, Label = "RedSql", UserProperties = { { "color", "RedSql" } } }); TestUtility.Log($"Sent Message: {messageId2}"); var messages = await subscriptionClient.InnerSubscriptionClient.InnerReceiver.ReceiveAsync(maxMessageCount: 2); Assert.NotNull(messages); Assert.True(messages.Count == 1); Assert.Equal(messageId2, messages.First().MessageId); } finally { try { await subscriptionClient.RemoveRuleAsync("RedSql"); await subscriptionClient.AddRuleAsync(RuleDescription.DefaultRuleName, new TrueFilter()); } catch (Exception e) { TestUtility.Log($" Cleanup failed with Exception: {e.Message}"); } await subscriptionClient.CloseAsync(); await topicClient.CloseAsync(); } }); }
private Task ExceptionReceivedHandler(ExceptionReceivedEventArgs eventArgs) { TestUtility.Log($"Exception Received: ClientId: {eventArgs.ExceptionReceivedContext.ClientId}, EntityPath: {eventArgs.ExceptionReceivedContext.EntityPath}, Exception: {eventArgs.Exception.Message}"); return(Task.CompletedTask); }
async Task GetAndSetSessionStateTest(string queueName) { var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName); var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName); try { var messageId = "test-message1"; var sessionId = Guid.NewGuid().ToString(); await sender.SendAsync(new Message() { MessageId = messageId, SessionId = sessionId }); TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}"); var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId); Assert.NotNull(sessionReceiver); var message = await sessionReceiver.ReceiveAsync(); TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}"); Assert.True(message.MessageId == messageId); var sessionStateString = "Received Message From Session!"; var sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString)); await sessionReceiver.SetStateAsync(sessionState); TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}"); var returnedSessionState = await sessionReceiver.GetStateAsync(); using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8)) { var returnedSessionStateString = await reader.ReadToEndAsync(); TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}"); Assert.Equal(sessionStateString, returnedSessionStateString); } // Complete message using Session Receiver await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken); TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}"); sessionStateString = "Completed Message On Session!"; sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString)); await sessionReceiver.SetStateAsync(sessionState); TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}"); returnedSessionState = await sessionReceiver.GetStateAsync(); using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8)) { var returnedSessionStateString = await reader.ReadToEndAsync(); TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}"); Assert.Equal(sessionStateString, returnedSessionStateString); } await sessionReceiver.CloseAsync(); } finally { await sender.CloseAsync().ConfigureAwait(false); await sessionClient.CloseAsync().ConfigureAwait(false); } }
async Task GetAndSetSessionStateTest(string topicName) { var entityConnectionString = TestUtility.GetEntityConnectionString(topicName); var topicClient = TopicClient.CreateFromConnectionString(entityConnectionString); var subscriptionClient = SubscriptionClient.CreateFromConnectionString(entityConnectionString, this.SubscriptionName); try { var messageId = "test-message1"; var sessionId = Guid.NewGuid().ToString(); await topicClient.SendAsync(new BrokeredMessage() { MessageId = messageId, SessionId = sessionId }); TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}"); var sessionReceiver = await subscriptionClient.AcceptMessageSessionAsync(sessionId); Assert.NotNull((object)sessionReceiver); var message = await sessionReceiver.ReceiveAsync(); TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}"); Assert.True(message.MessageId == messageId); var sessionStateString = "Received Message From Session!"; var sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString)); await sessionReceiver.SetStateAsync(sessionState); TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}"); var returnedSessionState = await sessionReceiver.GetStateAsync(); using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8)) { var returnedSessionStateString = await reader.ReadToEndAsync(); TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}"); Assert.Equal(sessionStateString, returnedSessionStateString); } // Complete message using Session Receiver await sessionReceiver.CompleteAsync(new Guid[] { message.LockToken }); TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}"); sessionStateString = "Completed Message On Session!"; sessionState = new MemoryStream(Encoding.UTF8.GetBytes(sessionStateString)); await sessionReceiver.SetStateAsync(sessionState); TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}"); returnedSessionState = await sessionReceiver.GetStateAsync(); using (var reader = new StreamReader(returnedSessionState, Encoding.UTF8)) { var returnedSessionStateString = await reader.ReadToEndAsync(); TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}"); Assert.Equal(sessionStateString, returnedSessionStateString); } await sessionReceiver.CloseAsync(); } finally { subscriptionClient.Close(); topicClient.Close(); } }
private async Task OnSessionTestAsync(bool partitioned, bool sessionEnabled, int maxConcurrentCalls, ReceiveMode mode, bool autoComplete) { await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName => { TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}"); var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode); try { var handlerOptions = new SessionHandlerOptions(ExceptionReceivedHandler) { MaxConcurrentSessions = maxConcurrentCalls, MessageWaitTimeout = TimeSpan.FromSeconds(5), AutoComplete = autoComplete }; var testSessionHandler = new TestSessionHandler( queueClient.ReceiveMode, handlerOptions, queueClient.InnerSender, queueClient.SessionPumpHost); // Send messages to Session first await testSessionHandler.SendSessionMessages(); // Register handler testSessionHandler.RegisterSessionHandler(handlerOptions); // Verify messages were received. await testSessionHandler.VerifyRun(); testSessionHandler.ClearData(); } finally { await queueClient.CloseAsync(); } }); // test UnregisterSessionHandler can wait for message handling upto the timeout user defined. await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName => { TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}"); var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode); try { var sessionHandlerOptions = new SessionHandlerOptions(ExceptionReceivedHandler) { MaxConcurrentSessions = maxConcurrentCalls, MessageWaitTimeout = TimeSpan.FromSeconds(5), AutoComplete = autoComplete }; var testSessionHandler = new TestSessionHandler( queueClient.ReceiveMode, sessionHandlerOptions, queueClient.InnerSender, queueClient.SessionPumpHost); // Send messages to Session first await testSessionHandler.SendSessionMessages(); // Register handler testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 8); // Session handler set up has greater latency than message handler. Delay here to enable some processing time of the session pump. await Task.Delay(TimeSpan.FromSeconds(2)); // UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(10)); Assert.True(testSessionHandler.ReceivedMessageCount == maxConcurrentCalls); // Reregister won't have any problems testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 0); await testSessionHandler.WaitForAllMessagesReceived(ExpectedMessageCount); Assert.True(testSessionHandler.ReceivedMessageCount == ExpectedMessageCount); testSessionHandler.ClearData(); } finally { await queueClient.CloseAsync(); } }); // test UnregisterSessionHandler can close down in time when message handling takes longer than wait timeout user defined. await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName => { TestUtility.Log($"Queue: {queueName}, MaxConcurrentCalls: {maxConcurrentCalls}, Receive Mode: {mode.ToString()}, AutoComplete: {autoComplete}"); var queueClient = new QueueClient(TestUtility.NamespaceConnectionString, queueName, mode); try { var sessionHandlerOptions = new SessionHandlerOptions(ExceptionReceivedHandler) { MaxConcurrentSessions = maxConcurrentCalls, MessageWaitTimeout = TimeSpan.FromSeconds(5), AutoComplete = autoComplete }; var testSessionHandler = new TestSessionHandler( queueClient.ReceiveMode, sessionHandlerOptions, queueClient.InnerSender, queueClient.SessionPumpHost); // Send messages to Session first await testSessionHandler.SendSessionMessages(); // Register handler testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 8); // UnregisterSessionHandler should wait up to the provided timeout to finish the message handling tasks await testSessionHandler.UnregisterSessionHandler(TimeSpan.FromSeconds(2)); Assert.True(testSessionHandler.ReceivedMessageCount == 0); // Reregister won't have any problems testSessionHandler.RegisterSessionHandlerAndRecordReceivedMessageCount(queueClient.ReceiveMode == ReceiveMode.PeekLock, 0); await testSessionHandler.WaitForAllMessagesReceived(ExpectedMessageCount); Assert.True(testSessionHandler.ReceivedMessageCount == ExpectedMessageCount); testSessionHandler.ClearData(); } finally { await queueClient.CloseAsync(); } }); }
async Task BrokeredMessageOperationsTest() { // Create QueueClient with ReceiveDelete, // Send and Receive a message, Try to Complete/Abandon/Defer/DeadLetter should throw InvalidOperationException() var queueClient = QueueClient.CreateFromConnectionString( TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName), ReceiveMode.ReceiveAndDelete); await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1); var message = await queueClient.ReceiveAsync(); Assert.NotNull((object)message); await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.CompleteAsync()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.AbandonAsync()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.DeferAsync()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await message.DeadLetterAsync()); // Create a PeekLock queueClient and do rest of the operations // Send a Message, Receive/ Abandon and Complete it using BrokeredMessage methods queueClient = QueueClient.CreateFromConnectionString( TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName), ReceiveMode.PeekLock); await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1); message = await queueClient.ReceiveAsync(); Assert.NotNull((object)message); await message.AbandonAsync(); await Task.Delay(TimeSpan.FromMilliseconds(100)); message = await queueClient.ReceiveAsync(); await message.CompleteAsync(); // Send a Message, Receive / DeadLetter using BrokeredMessage methods await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1); message = await queueClient.ReceiveAsync(); await message.DeadLetterAsync(); var builder = new ServiceBusConnectionStringBuilder(TestUtility.GetEntityConnectionString(Constants.PartitionedQueueName)); builder.EntityPath = EntityNameHelper.FormatDeadLetterPath(queueClient.QueueName); var deadLetterQueueClient = QueueClient.CreateFromConnectionString(builder.ToString()); message = await deadLetterQueueClient.ReceiveAsync(); await message.CompleteAsync(); // Send a Message, Receive/Defer using BrokeredMessage methods await TestUtility.SendMessagesAsync(queueClient.InnerSender, 1); message = await queueClient.ReceiveAsync(); var deferredSequenceNumber = message.SequenceNumber; await message.DeferAsync(); var deferredMessage = await queueClient.ReceiveBySequenceNumberAsync(deferredSequenceNumber); await deferredMessage.CompleteAsync(); await queueClient.CloseAsync(); }
async Task SqlFilterTestCase(string topicName, int messageCount = 10) { var topicClient = new TopicClient(TestUtility.NamespaceConnectionString, topicName); var subscriptionClient = new SubscriptionClient( TestUtility.NamespaceConnectionString, topicName, this.SubscriptionName, ReceiveMode.ReceiveAndDelete); try { try { await subscriptionClient.RemoveRuleAsync(SubscriptionClient.DefaultRule); } catch { // ignored } await subscriptionClient.AddRuleAsync(new RuleDescription { Filter = new SqlFilter("Color = 'RedSql'"), Name = "RedSql" }); var messageId1 = Guid.NewGuid().ToString(); await topicClient.SendAsync(new Message { MessageId = messageId1, Label = "BlueSql", UserProperties = { { "color", "BlueSql" } } }); TestUtility.Log($"Sent Message: {messageId1}"); var messageId2 = Guid.NewGuid().ToString(); await topicClient.SendAsync(new Message { MessageId = messageId2, Label = "RedSql", UserProperties = { { "color", "RedSql" } } }); TestUtility.Log($"Sent Message: {messageId2}"); var messages = await subscriptionClient.InnerSubscriptionClient.InnerReceiver.ReceiveAsync(maxMessageCount : 2); Assert.NotNull(messages); Assert.True(messages.Count == 1); Assert.True(messageId2.Equals(messages.First().MessageId)); } finally { await subscriptionClient.RemoveRuleAsync("RedSql"); await subscriptionClient.AddRuleAsync(SubscriptionClient.DefaultRule, new TrueFilter()); await subscriptionClient.CloseAsync(); await topicClient.CloseAsync(); } }