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,17 +58,9 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
             try
             {
                 this.ScriptGenerationResult = this.ComparisonResult.GenerateScript(this.Parameters.TargetDatabaseName);
-            }
-            catch (Exception e)
-            {
-                ErrorMessage = e.Message;
-                Logger.Write(TraceEventType.Error, string.Format("Schema compare generate script operation {0} failed with exception {1}", this.OperationId, e.Message));
-                throw;
-            }
-        }
 
-        // Separated from Execute() since tests don't create SqlTasks
+                // tests don't create a SqlTask, so only add the script when the SqlTask isn't null
-        public void AddScriptToTask()
+                if (this.SqlTask != null)
                 {
                     this.SqlTask.AddScript(SqlTaskStatus.Succeeded, this.ScriptGenerationResult.Script);
                     if (!string.IsNullOrEmpty(this.ScriptGenerationResult.MasterScript))
@@ -83,6 +69,14 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
                         this.SqlTask.AddScript(SqlTaskStatus.Succeeded, ScriptGenerationResult.MasterScript);
                     }
                 }
+            }
+            catch (Exception e)
+            {
+                ErrorMessage = e.Message;
+                Logger.Write(TraceEventType.Error, string.Format("Schema compare generate script operation {0} failed with exception {1}", this.OperationId, e.Message));
+                throw;
+            }
+        }
 
         // 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,6 +57,8 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
+            try
+            {
                 var exportParams = new ExportParams
                 {
                     DatabaseName = testdb.DatabaseName,
@@ -65,11 +67,14 @@ CREATE TABLE [dbo].[table3]
 
                 DacFxService service = new DacFxService();
                 ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
-            service.PerformOperation(operation);
+                service.PerformOperation(operation, TaskExecutionMode.Execute);
 
-            // cleanup
                 VerifyAndCleanup(exportParams.PackageFilePath);
+            }
+            finally
+            {
                 testdb.Cleanup();
+            }
 
             return requestContext;
         }
@@ -78,13 +83,16 @@ CREATE TABLE [dbo].[table3]
         {
             // first export a bacpac
             var result = GetLiveAutoCompleteTestObjects();
-            var exportRequestContext = new Mock<RequestContext<DacFxResult>>();
+            var importRequestContext = new Mock<RequestContext<DacFxResult>>();
-            exportRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
+            importRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
 
             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
+            {
                 var exportParams = new ExportParams
                 {
                     DatabaseName = sourceDb.DatabaseName,
@@ -93,12 +101,9 @@ CREATE TABLE [dbo].[table3]
 
                 DacFxService service = new DacFxService();
                 ExportOperation exportOperation = new ExportOperation(exportParams, result.ConnectionInfo);
-            service.PerformOperation(exportOperation);
+                service.PerformOperation(exportOperation, TaskExecutionMode.Execute);
 
                 // 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
                 {
                     PackageFilePath = exportParams.PackageFilePath,
@@ -106,14 +111,19 @@ CREATE TABLE [dbo].[table3]
                 };
 
                 ImportOperation importOperation = new ImportOperation(importParams, result.ConnectionInfo);
-            service.PerformOperation(importOperation);
+                service.PerformOperation(importOperation, TaskExecutionMode.Execute);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
+                targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
 
-            // cleanup
                 VerifyAndCleanup(exportParams.PackageFilePath);
+            }
+            finally
+            {
                 sourceDb.Cleanup();
+                if (targetDb != null)
+                {
                     targetDb.Cleanup();
-
+                }
+            }
             return importRequestContext;
         }
 
@@ -127,6 +137,8 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
+            try
+            {
                 var extractParams = new ExtractParams
                 {
                     DatabaseName = testdb.DatabaseName,
@@ -137,12 +149,14 @@ CREATE TABLE [dbo].[table3]
 
                 DacFxService service = new DacFxService();
                 ExtractOperation operation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(operation);
+                service.PerformOperation(operation, TaskExecutionMode.Execute);
 
-            // cleanup
                 VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
                 testdb.Cleanup();
-
+            }
             return requestContext;
         }
 
@@ -150,13 +164,16 @@ CREATE TABLE [dbo].[table3]
         {
             // first extract a db to have a dacpac to import later
             var result = GetLiveAutoCompleteTestObjects();
-            var extractRequestContext = new Mock<RequestContext<DacFxResult>>();
+            var deployRequestContext = new Mock<RequestContext<DacFxResult>>();
-            extractRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
+            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);
 
+            try
+            {
                 var extractParams = new ExtractParams
                 {
                     DatabaseName = sourceDb.DatabaseName,
@@ -167,13 +184,9 @@ CREATE TABLE [dbo].[table3]
 
                 DacFxService service = new DacFxService();
                 ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
                 // deploy the created dacpac
-            var deployRequestContext = new Mock<RequestContext<DacFxResult>>();
-            deployRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
-
-
                 var deployParams = new DeployParams
                 {
                     PackageFilePath = extractParams.PackageFilePath,
@@ -182,14 +195,19 @@ CREATE TABLE [dbo].[table3]
                 };
 
                 DeployOperation deployOperation = new DeployOperation(deployParams, result.ConnectionInfo);
-            service.PerformOperation(deployOperation);
+                service.PerformOperation(deployOperation, TaskExecutionMode.Execute);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
+                targetDb = SqlTestDb.CreateFromExisting(deployParams.DatabaseName);
 
-            // cleanup
                 VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
                 sourceDb.Cleanup();
+                if (targetDb != null)
+                {
                     targetDb.Cleanup();
-
+                }
+            }
             return deployRequestContext;
         }
 
@@ -203,6 +221,8 @@ CREATE TABLE [dbo].[table3]
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
+            try
+            {
                 var exportParams = new ExportParams
                 {
                     DatabaseName = testdb.DatabaseName,
@@ -218,7 +238,7 @@ CREATE TABLE [dbo].[table3]
 
                 try
                 {
-                service.PerformOperation(operation);
+                    service.PerformOperation(operation, TaskExecutionMode.Execute);
                 }
                 catch (OperationCanceledException canceledException)
                 {
@@ -226,10 +246,11 @@ CREATE TABLE [dbo].[table3]
                 }
 
                 Assert.NotNull(expectedException);
-
+            }
-            // cleanup
+            finally
+            {
                 testdb.Cleanup();
-
+            }
             return requestContext;
         }
 
@@ -239,13 +260,17 @@ CREATE TABLE [dbo].[table3]
         {
             // first extract a dacpac
             var result = GetLiveAutoCompleteTestObjects();
-            var extractRequestContext = new Mock<RequestContext<DacFxResult>>();
+            var generateScriptRequestContext = new Mock<RequestContext<DacFxResult>>();
-            extractRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
+            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");
 
-            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");
             string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
             Directory.CreateDirectory(folderPath);
 
+            try
+            {
                 var extractParams = new ExtractParams
                 {
                     DatabaseName = sourceDb.DatabaseName,
@@ -256,42 +281,47 @@ CREATE TABLE [dbo].[table3]
 
                 DacFxService service = new DacFxService();
                 ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
                 // generate script
-            var generateScriptRequestContext = new Mock<RequestContext<DacFxResult>>();
-            generateScriptRequestContext.Setup(x => x.SendResult(It.IsAny<DacFxResult>())).Returns(Task.FromResult(new object()));
-
-
                 var generateScriptParams = new GenerateDeployScriptParams
                 {
                     PackageFilePath = extractParams.PackageFilePath,
-                DatabaseName = string.Concat(sourceDb.DatabaseName, "-deployed"),
+                    DatabaseName = targetDb.DatabaseName
-                ScriptFilePath = Path.Combine(folderPath, string.Concat(sourceDb.DatabaseName, "_", "UpgradeDACScript.sql"))
                 };
 
+                // Generate script for deploying source dacpac to target db
                 GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
-            service.PerformOperation(generateScriptOperation);
+                service.PerformOperation(generateScriptOperation, TaskExecutionMode.Script);
-            SqlTestDb targetDb = SqlTestDb.CreateFromExisting(generateScriptParams.DatabaseName);
+
+                // Verify script was generated
+                Assert.NotEmpty(generateScriptOperation.Result.DatabaseScript);
+                Assert.Contains("CREATE TABLE", generateScriptOperation.Result.DatabaseScript);
 
-            // cleanup
-            VerifyAndCleanup(generateScriptParams.ScriptFilePath);
                 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);
 
+            try
+            {
                 var extractParams = new ExtractParams
                 {
                     DatabaseName = sourceDb.DatabaseName,
@@ -301,13 +331,10 @@ CREATE TABLE [dbo].[table3]
                 };
 
                 ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);
-            service.PerformOperation(extractOperation);
+                service.PerformOperation(extractOperation, TaskExecutionMode.Execute);
 
                 // 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
                 {
@@ -316,18 +343,23 @@ CREATE TABLE [dbo].[table3]
                 };
 
                 GenerateDeployPlanOperation generateDeployPlanOperation = new GenerateDeployPlanOperation(generateDeployPlanParams, result.ConnectionInfo);
-            service.PerformOperation(generateDeployPlanOperation);
+                service.PerformOperation(generateDeployPlanOperation, TaskExecutionMode.Execute);
                 string report = generateDeployPlanOperation.DeployReport;
                 Assert.NotNull(report);
                 Assert.Contains("Create", report);
                 Assert.Contains("Drop", report);
                 Assert.Contains("Alter", report);
 
-            // cleanup
                 VerifyAndCleanup(extractParams.PackageFilePath);
+            }
+            finally
+            {
                 sourceDb.Cleanup();
+                if (targetDb != null)
+                {
                     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;
         }