public async Task SendAndPeekMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusPeek ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync(); #endregion // get the message body as a string string body = Encoding.Default.GetString(peekedMessage.Body.ToArray()); Assert.AreEqual(Encoding.Default.GetBytes("Hello world!"), peekedMessage.Body.ToArray()); } }
public async Task PeekIncrementsSequenceNumber(int messageCt) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId); await sender.SendAsync(messagebatch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); long seq = 0; for (int i = 0; i < messageCt; i++) { ServiceBusReceivedMessage msg = await receiver.PeekAsync(); Assert.IsTrue(msg.SequenceNumber > seq); if (seq > 0) { Assert.IsTrue(msg.SequenceNumber == seq + 1); } seq = msg.SequenceNumber; } } }
public async Task CompleteMessages() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>(); await sender.SendAsync(batch); var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = messages.GetEnumerator(); var remainingMessages = messageCount; while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); await receiver.CompleteAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task TransactionalSendRollback(bool partitioned, bool sessionEnabled) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message = GetMessage( sessionEnabled ? "sessionId" : null, partitioned ? "sessionId" : null); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendAsync(message); // not completing the transaction } ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync( scope.QueueName, new ServiceBusSessionReceiverOptions { SessionId = "sessionId" }) : client.CreateReceiver(scope.QueueName); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); Assert.IsNull(receivedMessage); }; }
public async Task Peek() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); var messageCt = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>(); await sender.SendAsync(batch); await using var receiver = client.CreateReceiver(scope.QueueName); Dictionary <string, string> sentMessageIdToLabel = new Dictionary <string, string>(); foreach (ServiceBusMessage message in sentMessages) { sentMessageIdToLabel.Add(message.MessageId, Encoding.Default.GetString(message.Body.ToArray())); } var ct = 0; while (ct < messageCt) { foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync( maxMessages: messageCt)) { var peekedText = Encoding.Default.GetString(peekedMessage.Body.ToArray()); ct++; } } Assert.AreEqual(messageCt, ct); } }
public async Task AbandonMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusAbandonMessage ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); // abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers await receiver.AbandonAsync(receivedMessage); #endregion Assert.IsNotNull(GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync()); } }
public async Task Peek() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); var messageCt = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>(); await sender.SendAsync(batch); await using var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = sentMessages.GetEnumerator(); var ct = 0; while (ct < messageCt) { foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync( maxMessages: messageCt)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, peekedMessage.MessageId); ct++; } } Assert.AreEqual(messageCt, ct); } }
public async Task TransactionalSendMultipleSessionsRollback() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { var options = new ServiceBusClientOptions(); options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5); options.RetryOptions.MaxRetries = 0; var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message1 = GetMessage("session1"); ServiceBusMessage message2 = GetMessage("session2"); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendAsync(message1); await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1)); } Assert.That( async() => await client.CreateSessionReceiverAsync(scope.QueueName), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.ServiceTimeout)); }; }
public async Task TransactionalSendCommit(bool partitioned, bool sessionEnabled) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message = GetMessage( sessionEnabled ? "sessionId" : null, partitioned ? "sessionId" : null); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendAsync(message); ts.Complete(); } ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message.Body.ToArray(), receivedMessage.Body.ToArray()); await receiver.CompleteAsync(receivedMessage); }; }
public async Task LockSameSessionShouldThrow() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); int messageCt = 10; var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId); await sender.SendAsync(messageBatch); var options = new ServiceBusSessionReceiverOptions { SessionId = sessionId }; ServiceBusReceiver receiver1 = await client.CreateSessionReceiverAsync( scope.QueueName, options); Assert.That( async() => await GetNoRetryClient().CreateSessionReceiverAsync( scope.QueueName, options), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.SessionCannotBeLocked)); } }
public async Task TransactionalSendMultipleSessions() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message1 = GetMessage("session1"); ServiceBusMessage message2 = GetMessage("session2"); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendAsync(message1); await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow); ts.Complete(); } ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToArray(), receivedMessage.Body.ToArray()); await receiver.CompleteAsync(receivedMessage); receiver = await client.CreateSessionReceiverAsync(scope.QueueName); receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message2.Body.ToArray(), receivedMessage.Body.ToArray()); await receiver.CompleteAsync(receivedMessage); }; }
public async Task SendAndReceiveMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; #region Snippet:ServiceBusSendAndReceive //@@ string connectionString = "<connection_string>"; //@@ string queueName = "<queue_name>"; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); // get the message body as a string string body = Encoding.Default.GetString(receivedMessage.Body.ToArray()); Console.WriteLine(body); #endregion Assert.AreEqual(Encoding.Default.GetBytes("Hello world!"), receivedMessage.Body.ToArray()); } }
public async Task RenewMessageLock() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCount = 1; ServiceBusMessage message = GetMessage(); await sender.SendAsync(message); var receiver = client.CreateReceiver(scope.QueueName); ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = receivedMessage.LockedUntil; // Sleeping for 10 seconds... await Task.Delay(10000); await receiver.RenewMessageLockAsync(receivedMessage); Assert.True(receivedMessage.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages await receiver.CompleteAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); Assert.AreEqual(message.MessageId, receivedMessage.MessageId); var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task CanPeekADeferredMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); await sender.SendAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); var receivedMsg = await receiver.ReceiveAsync(); await receiver.DeferAsync(receivedMsg); var peekedMsg = await receiver.PeekAsync(); Assert.AreEqual(receivedMsg.MessageId, peekedMsg.MessageId); Assert.AreEqual(receivedMsg.SequenceNumber, peekedMsg.SequenceNumber); var deferredMsg = await receiver.ReceiveDeferredMessageAsync(peekedMsg.SequenceNumber); Assert.AreEqual(peekedMsg.MessageId, deferredMsg.MessageId); Assert.AreEqual(peekedMsg.SequenceNumber, deferredMsg.SequenceNumber); } }
public void SendMessageExceptionLogsEvents() { var mockLogger = new Mock <ServiceBusEventSource>(); var mockTransportSender = new Mock <TransportSender>(); var mockConnection = GetMockConnection(mockTransportSender); var sender = new ServiceBusSender( "queueName", mockConnection.Object) { Logger = mockLogger.Object }; mockTransportSender.Setup( sender => sender.SendAsync( It.IsAny <IReadOnlyList <ServiceBusMessage> >(), It.IsAny <CancellationToken>())) .Throws(new Exception()); Assert.That( async() => await sender.SendMessageAsync(ServiceBusTestUtilities.GetMessage()), Throws.InstanceOf <Exception>()); mockLogger .Verify( log => log.SendMessageStart( sender.Identifier, 1), Times.Once); mockLogger .Verify( log => log.SendMessageException( sender.Identifier, It.IsAny <string>()), Times.Once); }
public async Task CompleteMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; #region Snippet:ServiceBusCompleteMessage //@@ string connectionString = "<connection_string>"; //@@ string queueName = "<queue_name>"; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); // complete the message, thereby deleting it from the service await receiver.CompleteAsync(receivedMessage); #endregion Assert.IsNull(await GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync()); } }
public async Task DeadLetterMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusDeadLetterMessage ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); // deadletter the message, thereby preventing the message from being received again without receiving from the dead letter queue. await receiver.DeadLetterAsync(receivedMessage); // receive the dead lettered message with receiver scoped to the dead letter queue. ServiceBusReceiver dlqReceiver = client.CreateDeadLetterReceiver(queueName); ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveAsync(); #endregion Assert.IsNotNull(dlqMessage); } }
public async Task SessionProcessorActivities() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { using var listener = new TestDiagnosticListener(EntityScopeFactory.DiagnosticNamespace); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCt = 2; var msgs = GetMessages(messageCt, "sessionId"); await sender.SendAsync(msgs); Activity[] sendActivities = AssertSendActivities(false, sender, msgs, listener); ServiceBusSessionProcessor processor = client.CreateSessionProcessor(scope.QueueName, new ServiceBusSessionProcessorOptions { AutoComplete = false, MaxReceiveWaitTime = TimeSpan.FromSeconds(10), MaxConcurrentCalls = 1 }); TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(); int processedMsgCt = 0; processor.ProcessMessageAsync += args => { processedMsgCt++; if (processedMsgCt == messageCt) { tcs.SetResult(true); } return(Task.CompletedTask); }; processor.ProcessErrorAsync += ExceptionHandler; await processor.StartProcessingAsync(); await tcs.Task; await processor.StopProcessingAsync(); for (int i = 0; i < messageCt; i++) { (string Key, object Value, DiagnosticListener)receiveStart = listener.Events.Dequeue(); (string Key, object Value, DiagnosticListener)receiveStop = listener.Events.Dequeue(); (string Key, object Value, DiagnosticListener)processStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.ProcessSessionMessageActivityName + ".Start", processStart.Key); Activity processActivity = (Activity)processStart.Value; AssertCommonTags(processActivity, processor.EntityPath, processor.FullyQualifiedNamespace); CollectionAssert.Contains( processActivity.Tags, new KeyValuePair <string, string>( DiagnosticProperty.MessageIdAttribute, msgs[i].MessageId)); CollectionAssert.Contains( processActivity.Tags, new KeyValuePair <string, string>( DiagnosticProperty.SessionIdAttribute, msgs[i].SessionId)); (string Key, object Value, DiagnosticListener)processStop = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.ProcessSessionMessageActivityName + ".Stop", processStop.Key); } }; }
public async Task RenewSessionLock(bool isSessionSpecified) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.GetSender(scope.QueueName); var messageCount = 1; var sessionId1 = "sessionId1"; ServiceBusMessage message = GetMessage(sessionId1); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected await sender.SendAsync(GetMessage("sessionId2")); await sender.SendAsync(message); ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName, sessionId : isSessionSpecified?sessionId1 : null); var session = receiver.GetSessionManager(); if (isSessionSpecified) { Assert.AreEqual(sessionId1, session.SessionId); } ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = session.LockedUntil; // Sleeping for 10 seconds... await Task.Delay(10000); await session.RenewSessionLockAsync(); Assert.True(session.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages await receiver.CompleteAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); if (isSessionSpecified) { Assert.AreEqual(message.MessageId, receivedMessage.MessageId); } var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task TransactionalCompleteRollback(bool partitioned, bool sessionEnabled, bool completeInTransactionAfterRollback) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); string body = Guid.NewGuid().ToString("N"); ServiceBusMessage message = GetMessage( sessionEnabled ? "sessionId" : null, partitioned ? "sessionId" : null); await sender.SendAsync(message); ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName); var receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual( message.Body.ToString(), receivedMessage.Body.ToString()); var sequenceNumber = receivedMessage.SequenceNumber; await receiver.DeferAsync(receivedMessage); ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessageAsync(sequenceNumber); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(deferredMessage); } // 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)); if (completeInTransactionAfterRollback) { using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(deferredMessage); 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)); } else { await receiver.CompleteAsync(deferredMessage); } Assert.That( async() => await receiver.CompleteAsync(deferredMessage), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); } }
public async Task AbandonMessages(bool useSpecificSession) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCount = 10; var sessionId = "sessionId1"; using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendAsync(batch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, new ServiceBusSessionReceiverOptions { SessionId = useSpecificSession ? sessionId : null }); var messageEnum = messages.GetEnumerator(); var remainingMessages = messageCount; IList <ServiceBusReceivedMessage> receivedMessages = new List <ServiceBusReceivedMessage>(); while (remainingMessages > 0) { foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId); receivedMessages.Add(msg); Assert.AreEqual(msg.DeliveryCount, 1); } } Assert.AreEqual(0, remainingMessages); // don't abandon in the receive loop // as this would make the message available to be immediately received again foreach (var msg in receivedMessages) { await receiver.AbandonAsync(msg); } messageEnum.Reset(); var receivedMessageCount = 0; foreach (var item in await receiver.PeekBatchAsync(messageCount)) { receivedMessageCount++; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); } Assert.AreEqual(messageCount, receivedMessageCount); } }
public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); await sender.SendAsync(message1); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(receivedMessage); await sender.SendAsync(message2); 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 Assert.That( async() => await receiver.CompleteAsync(receivedMessage), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); // Assert that send did succeed receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString()); await receiver.CompleteAsync(receivedMessage); } }
public async Task CanStopProcessingFromHandler(int numThreads) { await using (var scope = await ServiceBusScope.CreateWithQueue( enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); int numMessages = 100; using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, numMessages); await sender.SendAsync(messageBatch); var options = new ServiceBusProcessorOptions { MaxConcurrentCalls = numThreads, ReceiveMode = ReceiveMode.ReceiveAndDelete }; var processor = client.CreateProcessor(scope.QueueName, options); int messageProcessedCt = 0; // stop processing halfway through int stopAfterMessagesCt = numMessages / 2; TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); processor.ProcessMessageAsync += ProcessMessage; processor.ProcessErrorAsync += ExceptionHandler; await processor.StartProcessingAsync(); Task ProcessMessage(ProcessMessageEventArgs args) { var currentCt = Interlocked.Increment(ref messageProcessedCt); if (currentCt == stopAfterMessagesCt) { // awaiting here would cause a deadlock _ = processor.StopProcessingAsync(); tcs.SetResult(true); } return(Task.CompletedTask); } await tcs.Task; var receiver = GetNoRetryClient().CreateReceiver(scope.QueueName); var receivedMessages = await receiver.ReceiveBatchAsync(numMessages); // can't assert on the exact amount processed due to threads that // are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages Assert.IsTrue(receivedMessages.Count > 0); Assert.IsTrue(messageProcessedCt < numMessages); } }
public async Task PeekSession(long?sequenceNumber, string partitionKey) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCt = 10; var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt, sessionId, partitionKey).AsEnumerable <ServiceBusMessage>(); await sender.SendAsync(batch); Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>(); foreach (ServiceBusMessage message in sentMessages) { sentMessageIdToMsg.Add(message.MessageId, message); } var receiver = await client.CreateSessionReceiverAsync( scope.QueueName, new ServiceBusSessionReceiverOptions { SessionId = sessionId }); sequenceNumber ??= 1; // verify peeked == send var ct = 0; foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync( sequenceNumber: (long)sequenceNumber, maxMessages: messageCt)) { var peekedText = peekedMessage.Body.AsString(); var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId]; sentMessageIdToMsg.Remove(peekedMessage.MessageId); Assert.AreEqual(sentMsg.Body.AsString(), peekedText); Assert.AreEqual(sentMsg.PartitionKey, peekedMessage.PartitionKey); Assert.IsTrue(peekedMessage.SequenceNumber >= sequenceNumber); ct++; } if (sequenceNumber == 1) { Assert.AreEqual(messageCt, ct); } } }
public async Task DeadLetterMessages() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount); await sender.SendAsync(messages); var receiver = client.CreateReceiver(scope.QueueName); var remainingMessages = messageCount; var messageEnum = messages.GetEnumerator(); while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); await receiver.DeadLetterAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); string deadLetterQueuePath = EntityNameFormatter.FormatDeadLetterPath(scope.QueueName); var deadLetterReceiver = client.CreateReceiver(deadLetterQueuePath); remainingMessages = messageCount; while (remainingMessages > 0) { foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); await deadLetterReceiver.CompleteAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); var deadLetterMessage = deadLetterReceiver.PeekAsync(); Assert.IsNull(deadLetterMessage.Result); } }
public async Task CanSendAnEmptyBodyMessageBatch() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>())); await sender.SendAsync(batch); } }
public async Task CanSendAMessageBatch() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, 3); await sender.SendAsync(messageBatch); } }
public async Task SessionReceiverThrowsWhenUsingNonSessionEntity() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage sentMessage = GetMessage(); await sender.SendAsync(sentMessage); Assert.That( async() => await client.CreateSessionReceiverAsync(scope.QueueName), Throws.InstanceOf <InvalidOperationException>()); } }
public async Task CannotSendLargerThanMaximumSize() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); // Actual limit is 262144 bytes for a single message. ServiceBusMessage message = new ServiceBusMessage(new byte[300000]); Assert.That(async() => await sender.SendAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageSizeExceeded)); } }
public async Task TransactionRollbackWorksAcrossClientsUsingSameConnectionToSameEntity() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); await sender.SendAsync(message1); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(receivedMessage.LockToken); await sender.SendAsync(message2); } // 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)); // Following should succeed without exceptions await receiver.CompleteAsync(receivedMessage.LockToken); // Assert that send failed receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); Assert.Null(receivedMessage); } }