private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareRequestDacpacToDacpacWithOptions(string sourceScript, string targetScript, DeploymentOptions nodiffOption, DeploymentOptions shouldDiffOption)
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
// create dacpacs from databases
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, sourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, targetScript, "SchemaCompareTarget");
try
{
string sourceDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(sourceDb);
string targetDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(targetDb);
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
sourceInfo.PackageFilePath = sourceDacpacFilePath;
targetInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
targetInfo.PackageFilePath = targetDacpacFilePath;
var schemaCompareParams1 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = nodiffOption
};
SchemaCompareOperation schemaCompareOperation1 = new SchemaCompareOperation(schemaCompareParams1, null, null);
schemaCompareOperation1.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation1.ComparisonResult.IsEqual);
var schemaCompareParams2 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = shouldDiffOption,
};
SchemaCompareOperation schemaCompareOperation2 = new SchemaCompareOperation(schemaCompareParams2, null, null);
schemaCompareOperation2.Execute(TaskExecutionMode.Execute);
Assert.False(schemaCompareOperation2.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation2.ComparisonResult.Differences);
// cleanup
SchemaCompareTestUtils.VerifyAndCleanup(sourceDacpacFilePath);
SchemaCompareTestUtils.VerifyAndCleanup(targetDacpacFilePath);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareRequestDatabaseToDatabaseWithOptions(string sourceScript, string targetScript, DeploymentOptions nodiffOption, DeploymentOptions shouldDiffOption)
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
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
{
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Database;
sourceInfo.DatabaseName = sourceDb.DatabaseName;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams1 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = nodiffOption
};
SchemaCompareOperation schemaCompareOperation1 = new SchemaCompareOperation(schemaCompareParams1, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation1.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation1.ComparisonResult.IsValid);
Assert.True(schemaCompareOperation1.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation1.ComparisonResult.Differences);
var schemaCompareParams2 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = shouldDiffOption,
};
SchemaCompareOperation schemaCompareOperation2 = new SchemaCompareOperation(schemaCompareParams2, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation2.Execute(TaskExecutionMode.Execute);
Assert.False(schemaCompareOperation2.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation2.ComparisonResult.Differences);
}
finally
{
// cleanup
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareGenerateScriptRequestDacpacToDatabase()
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
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
{
string sourceDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(sourceDb);
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
sourceInfo.PackageFilePath = sourceDacpacFilePath;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
// generate script
var generateScriptParams = new SchemaCompareGenerateScriptParams
{
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
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
public void ValidateSchemaCompareOptionsDefaultAgainstDacFx()
{
DeploymentOptions deployOptions = new DeploymentOptions();
DacDeployOptions dacOptions = new DacDeployOptions();
// Changes to match new defaults
dacOptions.AllowDropBlockingAssemblies = true;
dacOptions.AllowIncompatiblePlatform = true;
dacOptions.DropObjectsNotInSource = true;
dacOptions.DropPermissionsNotInSource = true;
dacOptions.DropRoleMembersNotInSource = true;
dacOptions.IgnoreKeywordCasing = false;
dacOptions.IgnoreSemicolonBetweenStatements = false;
SchemaCompareTestUtils.CompareOptions(deployOptions, dacOptions);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareRequestDacpacToDacpac()
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
// create dacpacs from databases
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "SchemaCompareTarget");
try
{
string sourceDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(sourceDb);
string targetDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(targetDb);
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
sourceInfo.PackageFilePath = sourceDacpacFilePath;
targetInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
targetInfo.PackageFilePath = targetDacpacFilePath;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, null, null);
ValidateSchemaCompareWithExcludeIncludeResults(schemaCompareOperation);
// cleanup
SchemaCompareTestUtils.VerifyAndCleanup(sourceDacpacFilePath);
SchemaCompareTestUtils.VerifyAndCleanup(targetDacpacFilePath);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareGenerateScriptRequestDatabaseToDatabase()
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, TargetScript, "SchemaCompareTarget");
try
{
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Database;
sourceInfo.DatabaseName = sourceDb.DatabaseName;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
// generate script params
var generateScriptParams = new SchemaCompareGenerateScriptParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation.OperationId,
};
ValidateSchemaCompareScriptGenerationWithExcludeIncludeResults(schemaCompareOperation, generateScriptParams);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareRequestDatabaseToDatabase()
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
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
{
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Database;
sourceInfo.DatabaseName = sourceDb.DatabaseName;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
ValidateSchemaCompareWithExcludeIncludeResults(schemaCompareOperation);
}
finally
{
// cleanup
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaComparePublishChangesRequestDatabaseToDatabase()
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "SchemaCompareSource");
SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "SchemaCompareTarget");
try
{
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Database;
sourceInfo.DatabaseName = sourceDb.DatabaseName;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo
};
SchemaCompareOperation schemaCompareOperation = new SchemaCompareOperation(schemaCompareParams, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.False(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences);
var enumerator = schemaCompareOperation.ComparisonResult.Differences.GetEnumerator();
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table1]"));
enumerator.MoveNext();
Assert.True(enumerator.Current.SourceObject.Name.ToString().Equals("[dbo].[table2]"));
// update target
var publishChangesParams = new SchemaComparePublishChangesParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation.OperationId,
};
SchemaComparePublishChangesOperation publishChangesOperation = new SchemaComparePublishChangesOperation(publishChangesParams, schemaCompareOperation.ComparisonResult);
publishChangesOperation.Execute(TaskExecutionMode.Execute);
Assert.True(publishChangesOperation.PublishResult.Success);
Assert.Empty(publishChangesOperation.PublishResult.Errors);
// Verify that there are no differences after the publish by running the comparison again
schemaCompareOperation.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation.ComparisonResult.IsValid);
Assert.True(schemaCompareOperation.ComparisonResult.IsEqual);
Assert.Empty(schemaCompareOperation.ComparisonResult.Differences);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
private async Task <Mock <RequestContext <SchemaCompareResult> > > SendAndValidateSchemaCompareGenerateScriptRequestDacpacToDatabaseWithOptions(string sourceScript, string targetScript, DeploymentOptions nodiffOption, DeploymentOptions shouldDiffOption)
{
var result = SchemaCompareTestUtils.GetLiveAutoCompleteTestObjects();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareResult>())).Returns(Task.FromResult(new object()));
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
{
string sourceDacpacFilePath = SchemaCompareTestUtils.CreateDacpac(sourceDb);
SchemaCompareEndpointInfo sourceInfo = new SchemaCompareEndpointInfo();
SchemaCompareEndpointInfo targetInfo = new SchemaCompareEndpointInfo();
sourceInfo.EndpointType = SchemaCompareEndpointType.Dacpac;
sourceInfo.PackageFilePath = sourceDacpacFilePath;
targetInfo.EndpointType = SchemaCompareEndpointType.Database;
targetInfo.DatabaseName = targetDb.DatabaseName;
var schemaCompareParams1 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = nodiffOption,
};
SchemaCompareOperation schemaCompareOperation1 = new SchemaCompareOperation(schemaCompareParams1, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation1.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation1.ComparisonResult.IsValid);
Assert.True(schemaCompareOperation1.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation1.ComparisonResult.Differences);
// generate script
var generateScriptParams1 = new SchemaCompareGenerateScriptParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation1.OperationId,
};
SchemaCompareGenerateScriptOperation generateScriptOperation1 = new SchemaCompareGenerateScriptOperation(generateScriptParams1, schemaCompareOperation1.ComparisonResult);
generateScriptOperation1.Execute();
// validate script generation failed because there were no differences
Assert.False(generateScriptOperation1.ScriptGenerationResult.Success);
var schemaCompareParams2 = new SchemaCompareParams
{
SourceEndpointInfo = sourceInfo,
TargetEndpointInfo = targetInfo,
DeploymentOptions = shouldDiffOption,
};
SchemaCompareOperation schemaCompareOperation2 = new SchemaCompareOperation(schemaCompareParams2, result.ConnectionInfo, result.ConnectionInfo);
schemaCompareOperation2.Execute(TaskExecutionMode.Execute);
Assert.True(schemaCompareOperation2.ComparisonResult.IsValid);
Assert.False(schemaCompareOperation2.ComparisonResult.IsEqual);
Assert.NotNull(schemaCompareOperation2.ComparisonResult.Differences);
// generate script
var generateScriptParams2 = new SchemaCompareGenerateScriptParams
{
TargetDatabaseName = targetDb.DatabaseName,
OperationId = schemaCompareOperation1.OperationId,
};
SchemaCompareGenerateScriptOperation generateScriptOperation2 = new SchemaCompareGenerateScriptOperation(generateScriptParams2, schemaCompareOperation2.ComparisonResult);
generateScriptOperation2.Execute();
// validate script generation succeeded
Assert.True(generateScriptOperation2.ScriptGenerationResult.Success);
Assert.True(!string.IsNullOrEmpty(generateScriptOperation2.ScriptGenerationResult.Script), "Should have differences");
// cleanup
SchemaCompareTestUtils.VerifyAndCleanup(sourceDacpacFilePath);
}
finally
{
sourceDb.Cleanup();
targetDb.Cleanup();
}
return(schemaCompareRequestContext);
}
public async void ValidateSchemaCompareGetDefaultOptionsCallFromService()
{
DeploymentOptions deployOptions = new DeploymentOptions();
var schemaCompareRequestContext = new Mock <RequestContext <SchemaCompareOptionsResult> >();
schemaCompareRequestContext.Setup(x => x.SendResult(It.IsAny <SchemaCompareOptionsResult>())).Returns(Task.FromResult(new object()));
schemaCompareRequestContext.Setup((RequestContext <SchemaCompareOptionsResult> x) => x.SendResult(It.Is <SchemaCompareOptionsResult>((options) => SchemaCompareTestUtils.ValidateOptionsEqualsDefault(options) == true))).Returns(Task.FromResult(new object()));
SchemaCompareGetOptionsParams p = new SchemaCompareGetOptionsParams();
await SchemaCompareService.Instance.HandleSchemaCompareGetDefaultOptionsRequest(p, schemaCompareRequestContext.Object);
}
