Open dacfx deploy script instead of saving to file path (#822)

* open dacfx deploy script

* moving test db cleanups into finally blocks

src/Microsoft.SqlTools.ServiceLayer/DacFx/Contracts/GenerateDeployScriptRequest.cs

@@ -13,11 +13,6 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx.Contracts
     /// </summary>
     public class GenerateDeployScriptParams : DacFxParams
     {
-        /// <summary>
-        /// Gets or sets the filepath where to save the generated script
-        /// </summary>
-        public string ScriptFilePath { get; set; }
-
         /// <summary>
         /// Gets or sets whether a Deployment Report should be generated during deploy.
         /// </summary>

src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs

@@ -164,11 +164,12 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
                 {
                     GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
                     SqlTask sqlTask = null;
-                    TaskMetadata metadata = TaskMetadata.Create(parameters, SR.GenerateScriptTaskName, operation, ConnectionServiceInstance);
+                    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 = connInfo.ConnectionDetails.ServerName;
-                    metadata.DatabaseName = string.Empty;
+                    metadata.DatabaseName = parameters.DatabaseName;
+                    metadata.Name = SR.GenerateScriptTaskName;
 
                     sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
 
@@ -275,9 +276,9 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
         /// For testing purpose only
         /// </summary>
         /// <param name="operation"></param>
-        internal void PerformOperation(DacFxOperation operation)
+        internal void PerformOperation(DacFxOperation operation, TaskExecutionMode taskExecutionMode)
         {
-            operation.Execute(TaskExecutionMode.Execute);
+            operation.Execute(taskExecutionMode);
         }
     }
 }

src/Microsoft.SqlTools.ServiceLayer/DacFx/GenerateDeployScriptOperation.cs

@@ -21,6 +21,8 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
     {
         public GenerateDeployScriptParams Parameters { get; }
 
+        public PublishResult Result { get; set; }
+
         public GenerateDeployScriptOperation(GenerateDeployScriptParams parameters, ConnectionInfo connInfo) : base(connInfo)
         {
             Validate.IsNotNull("parameters", parameters);
@@ -34,15 +36,23 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
             publishOptions.GenerateDeploymentReport = this.Parameters.GenerateDeploymentReport;
             publishOptions.CancelToken = this.CancellationToken;
             publishOptions.DeployOptions = this.GetDefaultDeployOptions();
-            publishOptions.DatabaseScriptPath = this.Parameters.ScriptFilePath;
-            // 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
-            publishOptions.MasterDbScriptPath = Path.Combine(Path.GetDirectoryName(this.Parameters.ScriptFilePath), string.Concat("master_", Path.GetFileName(this.Parameters.ScriptFilePath)));
 
-            PublishResult result = this.DacServices.Script(dacpac, this.Parameters.DatabaseName, publishOptions);
+            this.Result = this.DacServices.Script(dacpac, this.Parameters.DatabaseName, publishOptions);
 
-            if(this.Parameters.GenerateDeploymentReport && !string.IsNullOrEmpty(this.Parameters.DeploymentReportFilePath))
+            // tests don't create a SqlTask, so only add the script when the SqlTask isn't null
+            if (this.SqlTask != null)
             {
-                File.WriteAllText(this.Parameters.DeploymentReportFilePath, result.DeploymentReport);
+                this.SqlTask.AddScript(SqlTaskStatus.Succeeded, Result.DatabaseScript);
+                if (!string.IsNullOrEmpty(this.Result.MasterDbScript))
+                {
+                    // 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, this.Result.MasterDbScript);
+                }
+            }
+
+            if (this.Parameters.GenerateDeploymentReport && !string.IsNullOrEmpty(this.Parameters.DeploymentReportFilePath))
+            {
+                File.WriteAllText(this.Parameters.DeploymentReportFilePath, this.Result.DeploymentReport);
             }
         }
     }

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

@@ -49,12 +49,6 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
         }
 
         public void Execute(TaskExecutionMode mode)
-        {
-            Execute();
-            AddScriptToTask();
-        }
-
-        public void Execute()
         {
             if (this.CancellationToken.IsCancellationRequested)
             {
@@ -64,6 +58,17 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
             try
             {
                 this.ScriptGenerationResult = this.ComparisonResult.GenerateScript(this.Parameters.TargetDatabaseName);
+
+                // tests don't create a SqlTask, so only add the script when the SqlTask isn't null
+                if (this.SqlTask != null)
+                {
+                    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);
+                    }
+                }
             }
             catch (Exception e)
             {
@@ -73,17 +78,6 @@ 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()
         {

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DacFx/DacFxserviceTests.cs

@@ -57,19 +57,24 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
-            var exportParams = new ExportParams
+            try
             {
-                DatabaseName = testdb.DatabaseName,
+                var exportParams = new ExportParams
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
+                {
-            };
+                    DatabaseName = testdb.DatabaseName,
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
+                };
 
-            DacFxService service = new DacFxService();
+                DacFxService service = new DacFxService();
-            ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
+                ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
-            service.PerformOperation(operation);
+                service.PerformOperation(operation, TaskExecutionMode.Execute);
 
-            // cleanup
+                VerifyAndCleanup(exportParams.PackageFilePath);
-            VerifyAndCleanup(exportParams.PackageFilePath);
+            }
-            testdb.Cleanup();
+            finally
+            {
+                testdb.Cleanup();
+            }
 
             return requestContext;
         }
@@ -78,42 +83,47 @@ CREATE TABLE [dbo].[table3]
         {
             // first export a bacpac
             var result = GetLiveAutoCompleteTestObjects();
-            var exportRequestContext = new Mock<RequestContext<DacFxResult>>();
-            exportRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
-
-            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxImportTest");
-            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
-            Directory.CreateDirectory(folderPath);
-
-            var exportParams = new ExportParams
-            {
-                DatabaseName = sourceDb.DatabaseName,
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", sourceDb.DatabaseName))
-            };
-
-            DacFxService service = new DacFxService();
-            ExportOperation exportOperation = new ExportOperation(exportParams, result.ConnectionInfo);
-            service.PerformOperation(exportOperation);
-
-            // import the created bacpac
             var importRequestContext = new Mock<RequestContext<DacFxResult>>();
             importRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
-            var importParams = new ImportParams
+            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxImportTest");
+            SqlTestDb targetDb = null;
+            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
+            Directory.CreateDirectory(folderPath);
+
+            try
             {
-                PackageFilePath = exportParams.PackageFilePath,
+                var exportParams = new ExportParams
-                DatabaseName = string.Concat(sourceDb.DatabaseName, "-imported")
+                {
-            };
+                    DatabaseName = sourceDb.DatabaseName,
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", sourceDb.DatabaseName))
+                };
 
-            ImportOperation importOperation = new ImportOperation(importParams, result.ConnectionInfo);
+                DacFxService service = new DacFxService();
-            service.PerformOperation(importOperation);
+                ExportOperation exportOperation = new ExportOperation(exportParams, result.ConnectionInfo);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
+                service.PerformOperation(exportOperation, TaskExecutionMode.Execute);
 
-            // cleanup
+                // import the created bacpac
-            VerifyAndCleanup(exportParams.PackageFilePath);
+                var importParams = new ImportParams
-            sourceDb.Cleanup();
+                {
-            targetDb.Cleanup();
+                    PackageFilePath = exportParams.PackageFilePath,
+                    DatabaseName = string.Concat(sourceDb.DatabaseName, "-imported")
+                };
 
+                ImportOperation importOperation = new ImportOperation(importParams, result.ConnectionInfo);
+                service.PerformOperation(importOperation, TaskExecutionMode.Execute);
+                targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
+
+                VerifyAndCleanup(exportParams.PackageFilePath);
+            }
+            finally
+            {
+                sourceDb.Cleanup();
+                if (targetDb != null)
+                {
+                    targetDb.Cleanup();
+                }
+            }
             return importRequestContext;
         }
 
@@ -127,22 +137,26 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
-            var extractParams = new ExtractParams
+            try
             {
-                DatabaseName = testdb.DatabaseName,
+                var extractParams = new ExtractParams
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", testdb.DatabaseName)),
+                {
-                ApplicationName = "test",
+                    DatabaseName = testdb.DatabaseName,
-                ApplicationVersion = "1.0.0.0"
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", testdb.DatabaseName)),
-            };
+                    ApplicationName = "test",
+                    ApplicationVersion = "1.0.0.0"
+                };
 
-            DacFxService service = new DacFxService();
+                DacFxService service = new DacFxService();
-            ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
+                ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(operation);
+                service.PerformOperation(operation, TaskExecutionMode.Execute);
-
-            // cleanup
-            VerifyAndCleanup(extractParams.PackageFilePath);
-            testdb.Cleanup();
 
+                VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
+                testdb.Cleanup();
+            }
             return requestContext;
         }
 
@@ -150,46 +164,50 @@ CREATE TABLE [dbo].[table3]
         {
             // first extract a db to have a dacpac to import later
             var result = GetLiveAutoCompleteTestObjects();
-            var extractRequestContext = new Mock<RequestContext<DacFxResult>>();
-            extractRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
-
-            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxDeployTest");
-            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
-            Directory.CreateDirectory(folderPath);
-
-            var extractParams = new ExtractParams
-            {
-                DatabaseName = sourceDb.DatabaseName,
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
-                ApplicationName = "test",
-                ApplicationVersion = "1.0.0.0"
-            };
-
-            DacFxService service = new DacFxService();
-            ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
-
-            // deploy the created dacpac
             var deployRequestContext = new Mock<RequestContext<DacFxResult>>();
             deployRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
+            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxDeployTest");
+            SqlTestDb targetDb = null;
+            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
+            Directory.CreateDirectory(folderPath);
 
-            var deployParams = new DeployParams
+            try
             {
-                PackageFilePath = extractParams.PackageFilePath,
+                var extractParams = new ExtractParams
-                DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
+                {
-                UpgradeExisting = false
+                    DatabaseName = sourceDb.DatabaseName,
-            };
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
+                    ApplicationName = "test",
+                    ApplicationVersion = "1.0.0.0"
+                };
 
-            DeployOperation deployOperation = new DeployOperation(deployParams, result.ConnectionInfo);
+                DacFxService service = new DacFxService();
-            service.PerformOperation(deployOperation);
+                ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
-            // cleanup
+                // deploy the created dacpac
-            VerifyAndCleanup(extractParams.PackageFilePath);
+                var deployParams = new DeployParams
-            sourceDb.Cleanup();
+                {
-            targetDb.Cleanup();
+                    PackageFilePath = extractParams.PackageFilePath,
+                    DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
+                    UpgradeExisting = false
+                };
 
+                DeployOperation deployOperation = new DeployOperation(deployParams, result.ConnectionInfo);
+                service.PerformOperation(deployOperation, TaskExecutionMode.Execute);
+                targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
+
+                VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
+                sourceDb.Cleanup();
+                if (targetDb != null)
+                {
+                    targetDb.Cleanup();
+                }
+            }
             return deployRequestContext;
         }
 
@@ -203,33 +221,36 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
-            var exportParams = new ExportParams
-            {
-                DatabaseName = testdb.DatabaseName,
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
-            };
-
-            DacFxService service = new DacFxService();
-            ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
-
-            // set cancellation token to cancel
-            operation.Cancel();
-            OperationCanceledException expectedException = null;
-
             try
             {
-                service.PerformOperation(operation);
+                var exportParams = new ExportParams
+                {
+                    DatabaseName = testdb.DatabaseName,
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
+                };
+
+                DacFxService service = new DacFxService();
+                ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
+
+                // set cancellation token to cancel
+                operation.Cancel();
+                OperationCanceledException expectedException = null;
+
+                try
+                {
+                    service.PerformOperation(operation, TaskExecutionMode.Execute);
+                }
+                catch (OperationCanceledException canceledException)
+                {
+                    expectedException = canceledException;
+                }
+
+                Assert.NotNull(expectedException);
             }
-            catch (OperationCanceledException canceledException)
+            finally
             {
-                expectedException = canceledException;
+                testdb.Cleanup();
             }
-
-            Assert.NotNull(expectedException);
-
-            // cleanup
-            testdb.Cleanup();
-
             return requestContext;
         }
 
@@ -239,95 +260,106 @@ CREATE TABLE [dbo].[table3]
         {
             // first extract a dacpac
             var result = GetLiveAutoCompleteTestObjects();
-            var extractRequestContext = new Mock<RequestContext<DacFxResult>>();
-            extractRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
-
-            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");
-            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
-            Directory.CreateDirectory(folderPath);
-
-            var extractParams = new ExtractParams
-            {
-                DatabaseName = sourceDb.DatabaseName,
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
-                ApplicationName = "test",
-                ApplicationVersion = "1.0.0.0"
-            };
-
-            DacFxService service = new DacFxService();
-            ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
-
-            // generate script
             var generateScriptRequestContext = new Mock<RequestContext<DacFxResult>>();
             generateScriptRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
+            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateScriptTest");
+            SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");
 
-            var generateScriptParams = new GenerateDeployScriptParams
+            string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
+            Directory.CreateDirectory(folderPath);
+
+            try
             {
-                PackageFilePath = extractParams.PackageFilePath,
+                var extractParams = new ExtractParams
-                DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
+                {
-                ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "UpgradeDACScript.sql"))
+                    DatabaseName = sourceDb.DatabaseName,
-            };
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
+                    ApplicationName = "test",
+                    ApplicationVersion = "1.0.0.0"
+                };
 
-            GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
+                DacFxService service = new DacFxService();
-            service.PerformOperation(generateScriptOperation);
+                ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(generateScriptParams.DatabaseName);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
-            // cleanup
+                // generate script
-            VerifyAndCleanup(generateScriptParams.ScriptFilePath);
+                var generateScriptParams = new GenerateDeployScriptParams
-            VerifyAndCleanup(extractParams.PackageFilePath);
+                {
-            sourceDb.Cleanup();
+                    PackageFilePath = extractParams.PackageFilePath,
-            targetDb.Cleanup();
+                    DatabaseName = targetDb.DatabaseName
+                };
 
+                // Generate script for deploying source dacpac to target db
+                GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
+                service.PerformOperation(generateScriptOperation, TaskExecutionMode.Script);
+
+                // Verify script was generated
+                Assert.NotEmpty(generateScriptOperation.Result.DatabaseScript);
+                Assert.Contains("CREATE TABLE", generateScriptOperation.Result.DatabaseScript);
+
+                VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
+                sourceDb.Cleanup();
+                targetDb.Cleanup();
+            }
             return generateScriptRequestContext;
         }
 
         private async Task<Mock<RequestContext<DacFxResult>>> SendAndValidateGenerateDeployPlanRequest()
         {
             var result = GetLiveAutoCompleteTestObjects();
-            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateDeployPlanTest");
+            var generateDeployPlanRequestContext = new Mock<RequestContext<DacFxResult>>();
+            generateDeployPlanRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
+            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateDeployPlanTest");
+            SqlTestDb targetDb = null;
             DacFxService service = new DacFxService();
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
-            var extractParams = new ExtractParams
+            try
             {
-                DatabaseName = sourceDb.DatabaseName,
+                var extractParams = new ExtractParams
-                PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
+                {
-                ApplicationName = "test",
+                    DatabaseName = sourceDb.DatabaseName,
-                ApplicationVersion = "1.0.0.0"
+                    PackageFilePath = Path.Combine(folderPath, string.Format("{0}.dacpac", sourceDb.DatabaseName)),
-            };
+                    ApplicationName = "test",
+                    ApplicationVersion = "1.0.0.0"
+                };
 
-            ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
+                ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
-            // generate deploy plan for deploying dacpac to targetDb
+                // generate deploy plan for deploying dacpac to targetDb
-            var generateDeployPlanRequestContext = new Mock<RequestContext<DacFxResult>>();
+                targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "DacFxGenerateDeployPlanTestTarget");
-            generateDeployPlanRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
-            SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "DacFxGenerateDeployPlanTestTarget");
+                var generateDeployPlanParams = new GenerateDeployPlanParams
+                {
+                    PackageFilePath = extractParams.PackageFilePath,
+                    DatabaseName = targetDb.DatabaseName,
+                };
 
-            var generateDeployPlanParams = new GenerateDeployPlanParams
+                GenerateDeployPlanOperation generateDeployPlanOperation = new GenerateDeployPlanOperation(generateDeployPlanParams, result.ConnectionInfo);
+                service.PerformOperation(generateDeployPlanOperation, TaskExecutionMode.Execute);
+                string report = generateDeployPlanOperation.DeployReport;
+                Assert.NotNull(report);
+                Assert.Contains("Create", report);
+                Assert.Contains("Drop", report);
+                Assert.Contains("Alter", report);
+
+                VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
             {
-                PackageFilePath = extractParams.PackageFilePath,
+                sourceDb.Cleanup();
-                DatabaseName = targetDb.DatabaseName,
+                if (targetDb != null)
-            };
+                {
-
+                    targetDb.Cleanup();
-            GenerateDeployPlanOperation generateDeployPlanOperation = new GenerateDeployPlanOperation(generateDeployPlanParams, result.ConnectionInfo);
+                }
-            service.PerformOperation(generateDeployPlanOperation);
+            }
-            string report = generateDeployPlanOperation.DeployReport;
-            Assert.NotNull(report);
-            Assert.Contains("Create", report);
-            Assert.Contains("Drop", report);
-            Assert.Contains("Alter", report);
-
-            // cleanup
-            VerifyAndCleanup(extractParams.PackageFilePath);
-            sourceDb.Cleanup();
-            targetDb.Cleanup();
-
             return generateDeployPlanRequestContext;
         }
 

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

@@ -266,7 +266,7 @@ END
                 };
 
                 SchemaCompareGenerateScriptOperation generateScriptOperation1 = new SchemaCompareGenerateScriptOperation(generateScriptParams1, schemaCompareOperation1.ComparisonResult);
-                generateScriptOperation1.Execute();
+                generateScriptOperation1.Execute(TaskExecutionMode.Script);
 
                 // validate script generation failed because there were no differences
                 Assert.False(generateScriptOperation1.ScriptGenerationResult.Success);
@@ -293,7 +293,7 @@ END
                 };
 
                 SchemaCompareGenerateScriptOperation generateScriptOperation2 = new SchemaCompareGenerateScriptOperation(generateScriptParams2, schemaCompareOperation2.ComparisonResult);
-                generateScriptOperation2.Execute();
+                generateScriptOperation2.Execute(TaskExecutionMode.Script);
 
                 // validate script generation succeeded
                 Assert.True(generateScriptOperation2.ScriptGenerationResult.Success);

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

@@ -448,7 +448,7 @@ CREATE TABLE [dbo].[table3]
             Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences);
 
             SchemaCompareGenerateScriptOperation generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult);
-            generateScriptOperation.Execute();
+            generateScriptOperation.Execute(TaskExecutionMode.Script);
 
             Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
             string initialScript = generateScriptOperation.ScriptGenerationResult.Script;
@@ -472,7 +472,7 @@ 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();
+            generateScriptOperation.Execute(TaskExecutionMode.Script);
 
             Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
             string afterExcludeScript = generateScriptOperation.ScriptGenerationResult.Script;
@@ -493,7 +493,7 @@ 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();
+            generateScriptOperation.Execute(TaskExecutionMode.Script);
 
             Assert.True(generateScriptOperation.ScriptGenerationResult.Success);
             string afterIncludeScript = generateScriptOperation.ScriptGenerationResult.Script;

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

@@ -6,6 +6,7 @@
 using Microsoft.SqlTools.ServiceLayer.DacFx;
 using Microsoft.SqlTools.ServiceLayer.DacFx.Contracts;
 using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
+using Microsoft.SqlTools.ServiceLayer.TaskServices;
 using Microsoft.SqlTools.ServiceLayer.Test.Common;
 using NUnit.Framework;
 using System;
@@ -44,7 +45,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.SchemaCompare
 
             DacFxService service = new DacFxService();
             ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(operation);
+            service.PerformOperation(operation, TaskExecutionMode.Execute);
 
             return extractParams.PackageFilePath;
         }