diff --git a/src/Microsoft.SqlTools.ServiceLayer/TaskServices/SqlTask.cs b/src/Microsoft.SqlTools.ServiceLayer/TaskServices/SqlTask.cs
index 54988ec6..100a0222 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/TaskServices/SqlTask.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/TaskServices/SqlTask.cs
@@ -71,12 +71,12 @@ namespace Microsoft.SqlTools.ServiceLayer.TaskServices
         /// <summary>
         /// Starts the task and monitor the task progress
         /// </summary>
-        public async Task Run()
+        public async Task RunAsync()
         {
             TaskStatus = SqlTaskStatus.InProgress;
             await TaskToRun(this).ContinueWith(task =>
             {
-                if (task.IsCompleted)
+                if (task.IsCompleted && !task.IsCanceled && !task.IsFaulted)
                 {
                     TaskResult taskResult = task.Result;
                     TaskStatus = taskResult.TaskStatus;
@@ -96,6 +96,14 @@ namespace Microsoft.SqlTools.ServiceLayer.TaskServices
             });
         }
 
+        //Run Task synchronously 
+        public void Run()
+        {
+            RunAsync().ContinueWith(task =>
+            {
+            });
+        }
+
         /// <summary>
         /// Returns true if task has any messages
         /// </summary>
diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/SqlTaskTests.cs b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/SqlTaskTests.cs
index e35031a3..9f04dfc6 100644
--- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/SqlTaskTests.cs
+++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/SqlTaskTests.cs
@@ -4,6 +4,8 @@
 //
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.TaskServices;
 using Xunit;
 
@@ -30,7 +32,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
         }
 
         [Fact]
-        public void RunShouldRunTheFunctionAndGetTheResult()
+        public async Task RunShouldRunTheFunctionAndGetTheResult()
         {
             SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded;
             DatabaseOperationStub operation = new DatabaseOperationStub();
@@ -41,17 +43,19 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun);
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
 
-            sqlTask.Run().ContinueWith(task => {
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
                 Assert.Equal(sqlTask.TaskStatus, expectedStatus);
                 Assert.Equal(sqlTask.IsCompleted, true);
                 Assert.True(sqlTask.Duration > 0);
             });
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
+            Thread.Sleep(1000);
             operation.Stop();
+            await taskToVerify;
         }
 
         [Fact]
-        public void ToTaskInfoShouldReturnTaskInfo()
+        public async Task ToTaskInfoShouldReturnTaskInfo()
         {
             SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded;
             DatabaseOperationStub operation = new DatabaseOperationStub();
@@ -65,7 +69,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
                 DatabaseName = "database name"
             }, operation.FunctionToRun);
 
-            sqlTask.Run().ContinueWith(task =>
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
             {
                 var taskInfo = sqlTask.ToTaskInfo();
                 Assert.Equal(taskInfo.TaskId, sqlTask.TaskId.ToString());
@@ -73,10 +77,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
                 Assert.Equal(taskInfo.DatabaseName, "database name");
             });
             operation.Stop();
+            await taskToVerify;
         }
 
         [Fact]
-        public void FailedOperationShouldReturnTheFailedResult()
+        public async Task FailedOperationShouldReturnTheFailedResult()
         {
             SqlTaskStatus expectedStatus = SqlTaskStatus.Failed;
             DatabaseOperationStub operation = new DatabaseOperationStub();
@@ -87,17 +92,19 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun);
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
 
-            sqlTask.Run().ContinueWith(task => {
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
                 Assert.Equal(sqlTask.TaskStatus, expectedStatus);
                 Assert.Equal(sqlTask.IsCompleted, true);
-                Assert.True(sqlTask.Duration > 0);
+               // Assert.True(sqlTask.Duration > 0);
             });
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
+            Thread.Sleep(1000);
             operation.Stop();
+            await taskToVerify;
         }
 
         [Fact]
-        public void CancelingTheTaskShouldCancelTheOperation()
+        public async Task CancelingTheTaskShouldCancelTheOperation()
         {
             SqlTaskStatus expectedStatus = SqlTaskStatus.Canceled;
             DatabaseOperationStub operation = new DatabaseOperationStub();
@@ -107,17 +114,19 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun);
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
 
-            sqlTask.Run().ContinueWith(task => {
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
                 Assert.Equal(sqlTask.TaskStatus, expectedStatus);
                 Assert.Equal(sqlTask.IsCancelRequested, true);
                 Assert.True(sqlTask.Duration > 0);
             });
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
+            Thread.Sleep(1000);
             sqlTask.Cancel();
+            await taskToVerify;
         }
 
         [Fact]
-        public void FailedOperationShouldFailTheTask()
+        public async Task FailedOperationShouldFailTheTask()
         {
             SqlTaskStatus expectedStatus = SqlTaskStatus.Failed;
             DatabaseOperationStub operation = new DatabaseOperationStub();
@@ -127,13 +136,14 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun);
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
 
-            sqlTask.Run().ContinueWith(task => {
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
                 Assert.Equal(sqlTask.TaskStatus, expectedStatus);
-                Assert.Equal(sqlTask.IsCancelRequested, true);
                 Assert.True(sqlTask.Duration > 0);
             });
             Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
+            Thread.Sleep(1000);
             operation.FailTheOperation();
+            await taskToVerify;
         }
     }
 }
diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskManagerTests.cs b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskManagerTests.cs
index a64cdc42..896cf38e 100644
--- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskManagerTests.cs
+++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskManagerTests.cs
@@ -4,6 +4,7 @@
 //
 
 using System;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.TaskServices;
 using Xunit;
 
@@ -27,7 +28,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
         }
 
         [Fact]
-        public void VerifyCreateAndRunningTask()
+        public async Task VerifyCreateAndRunningTask()
         {
             using (SqlTaskManager manager = new SqlTaskManager())
             {
@@ -39,13 +40,14 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
                 DatabaseOperationStub operation = new DatabaseOperationStub();
                 operation.TaskResult = new TaskResult
                 {
+                    TaskStatus = SqlTaskStatus.Succeeded
                 };
                 SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun);
                 Assert.NotNull(sqlTask);
                 Assert.True(taskAddedEventRaised);
 
                 Assert.False(manager.HasCompletedTasks());
-                sqlTask.Run().ContinueWith(task =>
+                Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
                 {
                     Assert.True(manager.HasCompletedTasks());
                     manager.RemoveCompletedTask(sqlTask);
@@ -53,12 +55,13 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
 
                 });
                 operation.Stop();
+                await taskToVerify;
             }
 
         }
 
         [Fact]
-        public void CancelTaskShouldCancelTheOperation()
+        public async Task CancelTaskShouldCancelTheOperation()
         {
             using (SqlTaskManager manager = new SqlTaskManager())
             {
@@ -71,7 +74,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
                 SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun);
                 Assert.NotNull(sqlTask);
 
-                sqlTask.Run().ContinueWith(task =>
+                Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
                 {
                     Assert.Equal(sqlTask.TaskStatus, expectedStatus);
                     Assert.Equal(sqlTask.IsCancelRequested, true);
@@ -79,6 +82,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
 
                 });
                 manager.CancelTask(sqlTask.TaskId);
+                await taskToVerify;
             }
 
         }
diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskServiceTests.cs b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskServiceTests.cs
index dcb4ebb2..ea585e99 100644
--- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskServiceTests.cs
+++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/TaskServices/TaskServiceTests.cs
@@ -51,10 +51,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null);
             DatabaseOperationStub operation = new DatabaseOperationStub();
             SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun);
-            sqlTask.Run().ContinueWith(task =>
-            {
-
-            });
+            sqlTask.Run();
            
             serviceHostMock.Verify(x => x.SendEvent(TaskCreatedNotification.Type,
                 It.Is<TaskInfo>(t => t.TaskId == sqlTask.TaskId.ToString() && t.ProviderName == "MSSQL")), Times.Once());
@@ -71,7 +68,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
             serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null);
             DatabaseOperationStub operation = new DatabaseOperationStub();
             SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun);
-            sqlTask.Run().ContinueWith(task =>
+            Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
             {
                 serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type,
                            It.Is<TaskProgressInfo>(t => t.Status == SqlTaskStatus.Canceled)), Times.Once());
@@ -89,6 +86,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.TaskServices
 
             serviceHostMock.Verify(x => x.SendEvent(TaskCreatedNotification.Type,
                 It.Is<TaskInfo>(t => t.TaskId == sqlTask.TaskId.ToString())), Times.Once());
+            await taskToVerify;
         }