Fix backup service to have multiple backup instances (#396)

* Allow multiple backups per backup service instance

* Add test to run multiple backups

* Update backup cancelTask method signature

* Fix to have multiple backup instances and add more tests

* Address PR comments

* Remove double new lines

* Add Azure check for backup operations

test/Microsoft.SqlTools.ServiceLayer.UnitTests/DisasterRecovery/BackupOperationStub.cs

@@ -3,6 +3,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using Microsoft.SqlServer.Management.Smo;
 using Microsoft.SqlTools.ServiceLayer.Admin;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
@@ -12,9 +13,9 @@ using System.Threading;
 namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 {
     /// <summary>
-    /// Stub class that implements IBackupUtilities
+    /// Stub class that implements IBackupOperation
     /// </summary>
-    public class BackupUtilitiesStub : IBackupUtilities
+    public class BackupOperationStub : IBackupOperation
     {
         /// <summary>
         /// Initialize 

test/Microsoft.SqlTools.ServiceLayer.UnitTests/DisasterRecovery/BackupTests.cs

@@ -21,14 +21,20 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             IsCancelable = true
         };
 
+        /// <summary>
+        /// Create and run a backup task
+        /// </summary>
+        /// <returns></returns>
         [Fact]
-        public async Task VerifyCreateAndRunningBackupTask()
+        public async Task VerifyRunningBackupTask()
         {
             using (SqlTaskManager manager = new SqlTaskManager())
             {
-                var mockUtility = new Mock<IBackupUtilities>();
-                DisasterRecoveryService service = new DisasterRecoveryService(mockUtility.Object);
-                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTask);
+                DisasterRecoveryService service = new DisasterRecoveryService();
+                var mockBackupOperation = new Mock<IBackupOperation>();
+                this.taskMetaData.Data = mockBackupOperation.Object;
+                
+                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
                 Assert.NotNull(sqlTask);
                 Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task =>
                 {
@@ -38,15 +44,52 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
                 await taskToVerify;
             }
         }
-
+        
+        /// <summary>
+        /// Create and run multiple backup tasks
+        /// </summary>
+        /// <returns></returns>
         [Fact]
-        public async Task CancelBackupTask()
+        public async Task VerifyRunningMultipleBackupTasks()
+        {
+            using (SqlTaskManager manager = new SqlTaskManager())
+            {   
+                DisasterRecoveryService service = new DisasterRecoveryService();
+                var mockUtility = new Mock<IBackupOperation>();
+                this.taskMetaData.Data = mockUtility.Object;
+
+                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                SqlTask sqlTask2 = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                Assert.NotNull(sqlTask);
+                Assert.NotNull(sqlTask2);
+
+                Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Succeeded, sqlTask.TaskStatus);
+                });
+
+                Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Succeeded, sqlTask2.TaskStatus);
+                });
+
+                await Task.WhenAll(taskToVerify, taskToVerify2);
+            }
+        }
+
+        /// <summary>
+        /// Cancel a backup task
+        /// </summary>
+        /// <returns></returns>
+        [Fact]
+        public async Task VerifyCancelBackupTask()
         {
             using (SqlTaskManager manager = new SqlTaskManager())
             {
-                IBackupUtilities backupUtility = new BackupUtilitiesStub();                
-                DisasterRecoveryService service = new DisasterRecoveryService(backupUtility);
-                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTask);
+                IBackupOperation backupOperation = new BackupOperationStub();                
+                DisasterRecoveryService service = new DisasterRecoveryService();
+                this.taskMetaData.Data = backupOperation;
+                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
                 Assert.NotNull(sqlTask);
                 Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task =>
                 {
@@ -59,5 +102,77 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
                 await taskToVerify;
             }
         }
+
+        /// <summary>
+        /// Cancel multiple backup tasks
+        /// </summary>
+        /// <returns></returns>
+        [Fact]
+        public async Task VerifyCancelMultipleBackupTasks()
+        {
+            using (SqlTaskManager manager = new SqlTaskManager())
+            {
+                IBackupOperation backupOperation = new BackupOperationStub();
+                DisasterRecoveryService service = new DisasterRecoveryService();
+                this.taskMetaData.Data = backupOperation;
+                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                SqlTask sqlTask2 = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                Assert.NotNull(sqlTask);
+                Assert.NotNull(sqlTask2);
+
+                Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Canceled, sqlTask.TaskStatus);
+                    Assert.Equal(sqlTask.IsCancelRequested, true);
+                    manager.Reset();
+                });
+
+                Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Canceled, sqlTask2.TaskStatus);
+                    Assert.Equal(sqlTask2.IsCancelRequested, true);
+                    manager.Reset();
+                });
+
+                manager.CancelTask(sqlTask.TaskId);
+                manager.CancelTask(sqlTask2.TaskId);
+
+                await Task.WhenAll(taskToVerify, taskToVerify2);
+            }
+        }
+
+        /// <summary>
+        /// Create two backup tasks and cancel one task
+        /// </summary>
+        /// <returns></returns>
+        [Fact]
+        public async Task VerifyCombinationRunAndCancelBackupTasks()
+        {
+            using (SqlTaskManager manager = new SqlTaskManager())
+            {
+                IBackupOperation backupOperation = new BackupOperationStub();
+                DisasterRecoveryService service = new DisasterRecoveryService();
+                this.taskMetaData.Data = backupOperation;
+                SqlTask sqlTask = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                SqlTask sqlTask2 = manager.CreateTask(this.taskMetaData, service.BackupTaskAsync);
+                Assert.NotNull(sqlTask);
+                Assert.NotNull(sqlTask2);
+
+                Task taskToVerify = sqlTask.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Canceled, sqlTask.TaskStatus);
+                    Assert.Equal(sqlTask.IsCancelRequested, true);
+                    manager.Reset();
+                });
+
+                Task taskToVerify2 = sqlTask2.RunAsync().ContinueWith(Task =>
+                {
+                    Assert.Equal(SqlTaskStatus.Succeeded, sqlTask2.TaskStatus);
+                });
+
+                manager.CancelTask(sqlTask.TaskId);
+                await Task.WhenAll(taskToVerify, taskToVerify2);
+            }
+        }
     }
 }