Bug/schemacompare publish and script tasks to send back results (#830)

* Fix Schema compare Publish and Script generation task to return back error messages correctly.

* Elaborating test a bit more to cover tasks

* Validate one task at a time for better clarity

* send back only errors not whole messages since task view doesnt have a good way (other than hover text) to show long messages

* Fixing the negative test cases

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareGenerateScriptOperation.cs

@@ -69,6 +69,11 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
                         this.SqlTask.AddScript(SqlTaskStatus.Succeeded, ScriptGenerationResult.MasterScript);
                     }
                 }
+                if (!this.ScriptGenerationResult.Success)
+                {
+                    ErrorMessage = this.ScriptGenerationResult.Message;
+                    throw new Exception(ErrorMessage);
+                }
             }
             catch (Exception e)
             {

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaComparePublishChangesOperation.cs

@@ -9,6 +9,7 @@ using Microsoft.SqlTools.Utility;
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Threading;
 
 namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
@@ -55,6 +56,12 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
             try
             {
                 this.PublishResult = this.ComparisonResult.PublishChangesToTarget(this.CancellationToken);
+                if (!this.PublishResult.Success)
+                {
+                    // Sending only errors and warnings - because overall message might be too big for task view
+                    ErrorMessage = string.Join(Environment.NewLine, this.PublishResult.Errors.Where(x => x.MessageType == SqlServer.Dac.DacMessageType.Error || x.MessageType == SqlServer.Dac.DacMessageType.Warning));
+                    throw new Exception(ErrorMessage);
+                }
             }
             catch (Exception e)
             {

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/SchemaCompare/SchemaCompareServiceOptionsTests.cs

@@ -254,10 +254,19 @@ END
                 };
 
                 SchemaCompareGenerateScriptOperation generateScriptOperation1 = new SchemaCompareGenerateScriptOperation(generateScriptParams1, schemaCompareOperation1.ComparisonResult);
-                generateScriptOperation1.Execute(TaskExecutionMode.Script);
 
+                try
+                {
+                    generateScriptOperation1.Execute(TaskExecutionMode.Script);
+                    Assert.True(false); //fail if it reaches here
+                }
+                catch (Exception ex)
+                {                    
                     // validate script generation failed because there were no differences
                     Assert.False(generateScriptOperation1.ScriptGenerationResult.Success);
+                    Assert.Equal("Performing script generation is not possible for this comparison result.", generateScriptOperation1.ScriptGenerationResult.Message);
+                    Assert.Equal("Performing script generation is not possible for this comparison result.", ex.Message);
+                }
 
                 var schemaCompareParams2 = new SchemaCompareParams
                 {

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/SchemaCompare/SchemaCompareServiceTests.cs

@@ -547,6 +547,7 @@ CREATE TABLE [dbo].[table3]
                 targetInfo.EndpointType = SchemaCompareEndpointType.Database;
                 targetInfo.DatabaseName = targetDb.DatabaseName;
                 targetInfo.OwnerUri = connectionObject.ConnectionInfo.OwnerUri;
+                TaskService.Instance.TaskManager.Reset();
 
                 // Schema compare service call
                 var schemaCompareRequestContext = new Mock<RequestContext<SchemaCompareResult>>();
@@ -595,6 +596,7 @@ CREATE TABLE [dbo].[table3]
                 };
 
                 await SchemaCompareService.Instance.HandleSchemaCompareGenerateScriptRequest(generateScriptParams, generateScriptRequestContext.Object);
+                ValidateTask(SR.GenerateScriptTaskName);
 
                 // Publish service call
                 var publishRequestContext = new Mock<RequestContext<ResultStatus>>();
@@ -602,14 +604,15 @@ CREATE TABLE [dbo].[table3]
 
 
                 SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(targetDb.ConnectionString);
-                var publishParams = new SchemaCompareGenerateScriptParams
+                var publishParams = new SchemaComparePublishChangesParams
                 {
                     OperationId = operationId,
                     TargetDatabaseName = targetDb.DatabaseName,
                     TargetServerName = builder.DataSource,
                 };
 
-                await SchemaCompareService.Instance.HandleSchemaCompareGenerateScriptRequest(publishParams, publishRequestContext.Object);
+                await SchemaCompareService.Instance.HandleSchemaComparePublishChangesRequest(publishParams, publishRequestContext.Object);
+                ValidateTask(SR.PublishChangesTaskName);
 
                 // Include/Exclude service call
                 var excludeRequestContext = new Mock<RequestContext<ResultStatus>>();
@@ -1021,7 +1024,6 @@ CREATE TABLE [dbo].[table3]
             return true;
         }
 
-
         private bool ValidateScmpRoundtrip(SchemaCompareOpenScmpResult result, string sourceName, string targetName)
         {
             Assert.True(true == result.Success, "Result Success is false");
@@ -1031,5 +1033,33 @@ CREATE TABLE [dbo].[table3]
             Assert.True(targetName == result.TargetEndpointInfo.DatabaseName, $"Source Endpoint name does not match. Expected {targetName}, Actual {result.TargetEndpointInfo.DatabaseName}");
             return true;
         }
+
+        private void ValidateTask(string expectedTaskName)
+        {
+            int retry = 5;
+            Assert.True(TaskService.Instance.TaskManager.Tasks.Count == 1, $"Expected 1 task but found {TaskService.Instance.TaskManager.Tasks.Count} tasks");
+            while (TaskService.Instance.TaskManager.Tasks.Any() && retry > 0)
+            {
+                if (!TaskService.Instance.TaskManager.HasCompletedTasks())
+                {
+                    System.Threading.Thread.Sleep(2000);
+                }
+                else
+                {
+                    foreach (SqlTask sqlTask in TaskService.Instance.TaskManager.Tasks)
+                    {
+                        if (sqlTask.IsCompleted)
+                        {
+                            Assert.True(sqlTask.TaskStatus == SqlTaskStatus.Succeeded, $"Task {sqlTask.TaskMetadata.Name} expected to succeed but failed with {sqlTask.TaskStatus.ToString()}");
+                            Assert.True(sqlTask.TaskMetadata.Name.Equals(expectedTaskName), $"Unexpected Schema compare task name. Expected : {expectedTaskName}, Actual : {sqlTask.TaskMetadata.Name}");
+                            TaskService.Instance.TaskManager.RemoveCompletedTask(sqlTask);
+                        }
+                    }
+                }
+                retry--;
+            }
+            Assert.Equal(false, TaskService.Instance.TaskManager.Tasks.Any());
+            TaskService.Instance.TaskManager.Reset();
+        }
     }
 }