Open schema compare generated script (#813)

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/Contracts/SchemaCompareGenerateScriptRequest.cs

@@ -15,10 +15,6 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts
     /// </summary>
     public class SchemaCompareGenerateScriptParams : SchemaComparePublishChangesParams
     {
-        /// <summary>
-        /// Gets or sets the filepath where to save the generated script
-        /// </summary>
-        public string ScriptFilePath { get; set; }
     }
 
     /// <summary>

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

@@ -38,16 +38,23 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
 
         public SchemaComparisonResult ComparisonResult { get; set; }
 
+        public SchemaCompareScriptGenerationResult ScriptGenerationResult { get; set; }
+
         public SchemaCompareGenerateScriptOperation(SchemaCompareGenerateScriptParams parameters, SchemaComparisonResult comparisonResult)
         {
             Validate.IsNotNull("parameters", parameters);
-            Validate.IsNotNull("scriptFilePath", parameters.ScriptFilePath);
             this.Parameters = parameters;
             Validate.IsNotNull("comparisonResult", comparisonResult);
             this.ComparisonResult = comparisonResult;
         }
 
         public void Execute(TaskExecutionMode mode)
+        {
+            Execute();
+            AddScriptToTask();
+        }
+
+        public void Execute()
         {
             if (this.CancellationToken.IsCancellationRequested)
             {
@@ -56,15 +63,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
 
             try
             {
-                SchemaCompareScriptGenerationResult result = this.ComparisonResult.GenerateScript(this.Parameters.TargetDatabaseName);
+                this.ScriptGenerationResult = this.ComparisonResult.GenerateScript(this.Parameters.TargetDatabaseName);
-                File.WriteAllText(this.Parameters.ScriptFilePath, result.Script);
-
-                if (!string.IsNullOrEmpty(result.MasterScript))
-                {
-                    // master script is only used if the target is Azure SQL db and the script contains all operations that must be done against the master database
-                    string masterScriptPath = Path.Combine(Path.GetDirectoryName(this.Parameters.ScriptFilePath), string.Concat("master_", Path.GetFileName(this.Parameters.ScriptFilePath)));
-                    File.WriteAllText(masterScriptPath, result.MasterScript);
-                }
             }
             catch (Exception e)
             {
@@ -74,6 +73,17 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
             }
         }
 
+        // Separated from Execute() since tests don't create SqlTasks
+        public void AddScriptToTask()
+        {
+            this.SqlTask.AddScript(SqlTaskStatus.Succeeded, this.ScriptGenerationResult.Script);
+            if (!string.IsNullOrEmpty(this.ScriptGenerationResult.MasterScript))
+            {
+                // master script is only used if the target is Azure SQL db and the script contains all operations that must be done against the master database
+                this.SqlTask.AddScript(SqlTaskStatus.Succeeded, ScriptGenerationResult.MasterScript);
+            }
+        }
+
         // The schema compare public api doesn't currently take a cancellation token so the operation can't be cancelled
         public void Cancel()
         {

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

@@ -117,9 +117,9 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCopmare
                 SqlTask sqlTask = null;
                 TaskMetadata metadata = new TaskMetadata();
                 metadata.TaskOperation = operation;
-                // want to show filepath in task history instead of server and database
+                metadata.TaskExecutionMode = parameters.TaskExecutionMode;
-                metadata.ServerName = parameters.ScriptFilePath;
+                metadata.ServerName = parameters.TargetServerName;
-                metadata.DatabaseName = string.Empty;
+                metadata.DatabaseName = parameters.TargetDatabaseName;
                 metadata.Name = SR.GenerateScriptTaskName;
 
                 sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);

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

@@ -263,15 +263,13 @@ END
                 {
                     TargetDatabaseName = targetDb.DatabaseName,
                     OperationId = schemaCompareOperation1.OperationId,
-                    ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish1.sql"))
                 };
 
                 SchemaCompareGenerateScriptOperation generateScriptOperation1 = new SchemaCompareGenerateScriptOperation(generateScriptParams1, schemaCompareOperation1.ComparisonResult);
-                generateScriptOperation1.Execute(TaskExecutionMode.Execute);
+                generateScriptOperation1.Execute();
 
-                // validate script
+                // validate script generation failed because there were no differences
-                var filePath1 = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish1.sql"));
+                Assert.False(generateScriptOperation1.ScriptGenerationResult.Success);
-                Assert.True(File.Exists(filePath1) && string.IsNullOrEmpty(File.ReadAllText(filePath1)), "Should not be any differences");
 
                 var schemaCompareParams2 = new SchemaCompareParams
                 {
@@ -292,19 +290,15 @@ END
                 {
                     TargetDatabaseName = targetDb.DatabaseName,
                     OperationId = schemaCompareOperation1.OperationId,
-                    ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish2.sql"))
                 };
 
                 SchemaCompareGenerateScriptOperation generateScriptOperation2 = new SchemaCompareGenerateScriptOperation(generateScriptParams2, schemaCompareOperation2.ComparisonResult);
-                generateScriptOperation2.Execute(TaskExecutionMode.Execute);
+                generateScriptOperation2.Execute();
-
-                // validate script
-                var filePath2 = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish2.sql"));
-                Assert.True(File.Exists(filePath2) && !string.IsNullOrEmpty(File.ReadAllText(filePath2)), "Should have differences differences");
 
+                // validate script generation succeeded
+                Assert.True(generateScriptOperation2.ScriptGenerationResult.Success);
+                Assert.True(!string.IsNullOrEmpty(generateScriptOperation2.ScriptGenerationResult.Script), "Should have differences");
                 // cleanup
-                SchemaCompareTestUtils.VerifyAndCleanup(generateScriptParams1.ScriptFilePath);
-                SchemaCompareTestUtils.VerifyAndCleanup(generateScriptParams2.ScriptFilePath);
                 SchemaCompareTestUtils.VerifyAndCleanup(sourceDacpacFilePath);
             }
             finally

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

@@ -174,8 +174,6 @@ CREATE TABLE [dbo].[table3]
 
             SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
             SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "SchemaCompareTarget");
-            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "SchemaCompareTest");
-            Directory.CreateDirectory(folderPath);
 
             try
             {
@@ -200,13 +198,9 @@ CREATE TABLE [dbo].[table3]
                 {
                     TargetDatabaseName = targetDb.DatabaseName,
                     OperationId = schemaCompareOperation.OperationId,
-                    ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish.sql"))
                 };
 
                 ValidateSchemaCompareScriptGenerationWithExcludeIncludeResults(schemaCompareOperation, generateScriptParams);
-
-                // cleanup
-                SchemaCompareTestUtils.VerifyAndCleanup(generateScriptParams.ScriptFilePath);
             }
             finally
             {
@@ -252,13 +246,11 @@ CREATE TABLE [dbo].[table3]
                 {
                     TargetDatabaseName = targetDb.DatabaseName,
                     OperationId = schemaCompareOperation.OperationId,
-                    ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "Update.publish.sql"))
                 };
 
                 ValidateSchemaCompareScriptGenerationWithExcludeIncludeResults(schemaCompareOperation, generateScriptParams);
                 
                 // cleanup
-                SchemaCompareTestUtils.VerifyAndCleanup(generateScriptParams.ScriptFilePath);
                 SchemaCompareTestUtils.VerifyAndCleanup(sourceDacpacFilePath);
             }
             finally
@@ -456,9 +448,10 @@ CREATE TABLE [dbo].[table3]
             Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences);
 
             SchemaCompareGenerateScriptOperation generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult);
-            generateScriptOperation.Execute(TaskExecutionMode.Execute);
+            generateScriptOperation.Execute();
 
-            string initialScript = File.ReadAllText(generateScriptParams.ScriptFilePath);
+            Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
+            string initialScript = generateScriptOperation.ScriptGenerationResult.Script;
 
             // create Diff Entry from on Difference
             DiffEntry diff = SchemaCompareOperation.CreateDiffEntry(schemaCompareOperation.ComparisonResult.Differences.First(), null);
@@ -479,9 +472,10 @@ CREATE TABLE [dbo].[table3]
             Assert.True(initial == afterExclude, $"Changes should be same again after excluding/including, before {initial}, now {afterExclude}");
 
             generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult);
-            generateScriptOperation.Execute(TaskExecutionMode.Execute);
+            generateScriptOperation.Execute();
 
-            string afterExcludeScript = File.ReadAllText(generateScriptParams.ScriptFilePath);
+            Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
+            string afterExcludeScript = generateScriptOperation.ScriptGenerationResult.Script;
             Assert.True(initialScript.Length > afterExcludeScript.Length, $"Script should be affected (less statements) exclude operation, before {initialScript}, now {afterExcludeScript}");
 
             SchemaCompareNodeParams schemaCompareincludeNodeParams = new SchemaCompareNodeParams()
@@ -499,9 +493,10 @@ CREATE TABLE [dbo].[table3]
             Assert.True(initial == afterInclude, $"Changes should be same again after excluding/including:{initial}, now {afterInclude}");
 
             generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult);
-            generateScriptOperation.Execute(TaskExecutionMode.Execute);
+            generateScriptOperation.Execute();
 
-            string afterIncludeScript = File.ReadAllText(generateScriptParams.ScriptFilePath);
+            Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
+            string afterIncludeScript = generateScriptOperation.ScriptGenerationResult.Script;
             Assert.True(initialScript.Length == afterIncludeScript.Length, $"Changes should be same as inital since we included what we excluded, before {initialScript}, now {afterIncludeScript}");
         }