Merge from dev

Author: nemakam

src/Microsoft.Azure.ServiceBus/Core/MessageSender.cs

@@ -153,6 +153,7 @@ internal MessageSender(
 
             this.ServiceBusConnection = serviceBusConnection ?? throw new ArgumentNullException(nameof(serviceBusConnection));
             this.Path = entityPath;
+            this.TransferDestinationPath = transferDestinationPath;
             this.EntityType = entityType;
 
             if (cbsTokenProvider != null)
@@ -193,6 +194,11 @@ internal MessageSender(
         /// </summary>
         public override string Path { get; }
 
+        /// <summary>
+        /// Gets the transfer destination path (send-via) of the MessageSender.
+        /// </summary>
+        public string TransferDestinationPath { get; }
+
         /// <summary>
         /// Duration after which individual operations will timeout.
         /// </summary>

test/Microsoft.Azure.ServiceBus.UnitTests/API/ApiApprovals.ApproveAzureServiceBus.approved.txt

@@ -541,6 +541,7 @@ namespace Microsoft.Azure.ServiceBus.Core
         public override string Path { get; }
         public override System.Collections.Generic.IList<Microsoft.Azure.ServiceBus.Core.ServiceBusPlugin> RegisteredPlugins { get; }
         public override Microsoft.Azure.ServiceBus.ServiceBusConnection ServiceBusConnection { get; }
+        public string TransferDestinationPath { get; }
         public System.Threading.Tasks.Task CancelScheduledMessageAsync(long sequenceNumber) { }
         protected override System.Threading.Tasks.Task OnClosingAsync() { }
         public override void RegisterPlugin(Microsoft.Azure.ServiceBus.Core.ServiceBusPlugin serviceBusPlugin) { }

test/Microsoft.Azure.ServiceBus.UnitTests/TransactionTests.cs

@@ -77,6 +77,10 @@ public async Task TransactionalSendRollbackTest(string queueName)
                     ts.Dispose();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 var receivedMessage = await receiver.ReceiveAsync(ReceiveTimeout);
                 Assert.Null(receivedMessage);
             }
@@ -148,6 +152,10 @@ public async Task TransactionalCompleteRollbackTest(string queueName)
                     ts.Dispose();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);
             }
             finally
@@ -197,6 +205,8 @@ public async Task TransactionalSessionDispositionTest(string queueName)
                     ts.Complete();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
                 await Task.Delay(TimeSpan.FromSeconds(2));
 
                 await Assert.ThrowsAsync<SessionLockLostException>(async () => await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken));
@@ -240,12 +250,20 @@ public async Task TransactionalRequestResponseDispositionTest(string queueName)
                     ts.Dispose();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                 {
                     await receiver.CompleteAsync(deferredMessage.SystemProperties.LockToken);
                     ts.Complete();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 await Assert.ThrowsAsync<MessageLockLostException>(async () => await receiver.CompleteAsync(deferredMessage.SystemProperties.LockToken));
             }
             finally
@@ -285,7 +303,12 @@ await Assert.ThrowsAsync<InvalidOperationException>(
                         async () => await sender.SendAsync(message2));
                     ts.Complete();
                 }
+
                 transaction.Rollback();
+                
+                // 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));
 
                 // Two complete operations to different partitions.
                 await sender.SendAsync(message1);
@@ -308,6 +331,10 @@ await Assert.ThrowsAsync<InvalidOperationException>(
 
                 transaction.Rollback();
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 await receiver.CompleteAsync(receivedMessage1.SystemProperties.LockToken);
                 await receiver.CompleteAsync(receivedMessage2.SystemProperties.LockToken);
             }
@@ -349,6 +376,10 @@ public async Task TransactionCommitWorksAcrossClientsUsingSameConnectionToSameEn
                     ts.Complete();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 // Assert that complete did succeed
                 await Assert.ThrowsAsync<MessageLockLostException>(async () => await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken));
 
@@ -393,6 +424,10 @@ public async Task TransactionRollbackWorksAcrossClientsUsingSameConnectionToSame
                     ts.Dispose();
                 }
 
+                // Adding delay since transaction Commit/Rollback is an asynchronous operation.
+                // Operating on the same message should not be done.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
                 // Following should succeed without exceptions
                 await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken);