Ejemplo n.º 1
0
        private async Task VerifyMetadataList(string query, List <ObjectMetadata> expectedMetadataList)
        {
            var testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, "MetadataTests");

            try
            {
                var requestContext = new Mock <RequestContext <MetadataQueryResult> >();
                requestContext.Setup(x => x.SendResult(It.IsAny <MetadataQueryResult>())).Returns(Task.FromResult(new object()));
                ConnectionService connectionService = LiveConnectionHelper.GetLiveTestConnectionService();
                using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
                {
                    //Opening a connection to db to lock the db
                    TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync(testDb.DatabaseName, queryTempFile.FilePath, ConnectionType.Default);

                    MetadataService service = new MetadataService();
                    await service.HandleMetadataListRequest(new MetadataQueryParams
                    {
                        OwnerUri = queryTempFile.FilePath
                    }, requestContext.Object);

                    Thread.Sleep(2000);
                    await service.MetadataListTask;

                    requestContext.Verify(x => x.SendResult(It.Is <MetadataQueryResult>(r => VerifyResult(r, expectedMetadataList))));
                    connectionService.Disconnect(new ServiceLayer.Connection.Contracts.DisconnectParams
                    {
                        OwnerUri = queryTempFile.FilePath
                    });
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                await testDb.CleanupAsync();
            }
        }
Ejemplo n.º 2
0
        public async void RestoreShouldCloseOtherConnectionsBeforeExecuting()
        {
            await GetBackupFilesToRecoverDatabaseCreated();

            var testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "RestoreTest");

            ConnectionService    connectionService = LiveConnectionHelper.GetLiveTestConnectionService();
            TestConnectionResult connectionResult;

            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
            {
                //OE connection will be closed after conneced
                connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync(testDb.DatabaseName, queryTempFile.FilePath, ConnectionType.ObjectExplorer);

                //Opening a connection to db to lock the db

                connectionService.ConnectionQueue.AddConnectionContext(connectionResult.ConnectionInfo, "", true);

                try
                {
                    Dictionary <string, object> options = new Dictionary <string, object>();
                    options.Add(RestoreOptionsHelper.ReplaceDatabase, true);
                    await VerifyRestore(null, databaseNameToRestoreFrom, true, TaskExecutionModeFlag.Execute, testDb.DatabaseName, null, options
                                        , (database) =>
                    {
                        return(database.Tables.Contains("tb1", "test"));
                    });
                }
                finally
                {
                    connectionService.Disconnect(new ServiceLayer.Connection.Contracts.DisconnectParams
                    {
                        OwnerUri = queryTempFile.FilePath,
                        Type     = ConnectionType.Default
                    });
                    testDb.Cleanup();
                }
            }
        }
Ejemplo n.º 3
0
        public void ScriptBackupTest()
        {
            DisasterRecoveryService service = new DisasterRecoveryService();
            string databaseName             = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);

            using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName))
            {
                var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
                using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
                    using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
                    {
                        string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);


                        BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
                                                                        BackupType.Full,
                                                                        new List <string>()
                        {
                            backupPath
                        },
                                                                        new Dictionary <string, int>()
                        {
                            { backupPath, (int)DeviceType.File }
                        });
                        BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);

                        // Generate script for backup
                        service.ScriptBackup(backupOperation);
                        string script = backupOperation.ScriptContent;
                        Assert.True(!string.IsNullOrEmpty(script));

                        // Execute the script
                        testDb.RunQuery(script);

                        VerifyAndCleanBackup(sqlConn, backupPath);
                    }
            }
        }
Ejemplo n.º 4
0
        public void ScriptBackupWithDifferentActionTypesTest()
        {
            string    databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
            SqlTestDb testDb       = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);

            try
            {
                // Create Full backup script
                string script = GenerateScriptForBackupType(BackupType.Full, databaseName);

                // Validate Full backup script
                Assert.Contains("BACKUP DATABASE", script, StringComparison.OrdinalIgnoreCase);
                Assert.DoesNotContain("BACKUP LOG", script, StringComparison.OrdinalIgnoreCase);
                Assert.DoesNotContain("DIFFERENTIAL", script, StringComparison.OrdinalIgnoreCase);

                // Create log backup script
                script = GenerateScriptForBackupType(BackupType.TransactionLog, databaseName);

                // Validate Log backup script
                Assert.Contains("BACKUP LOG", script, StringComparison.OrdinalIgnoreCase);
                Assert.DoesNotContain("BACKUP DATABASE", script, StringComparison.OrdinalIgnoreCase);
                Assert.DoesNotContain("DIFFERENTIAL", script, StringComparison.OrdinalIgnoreCase);

                // Create differential backup script
                script = GenerateScriptForBackupType(BackupType.Differential, databaseName);

                // Validate differential backup script
                Assert.Contains("BACKUP DATABASE", script, StringComparison.OrdinalIgnoreCase);
                Assert.DoesNotContain("BACKUP LOG", script, StringComparison.OrdinalIgnoreCase);
                Assert.Contains("WITH  DIFFERENTIAL", script, StringComparison.OrdinalIgnoreCase);
            }
            finally
            {
                // Clean up the database
                Console.WriteLine("Clean up database..");
                testDb.Cleanup();
            }
        }
Ejemplo n.º 5
0
        public async void GenerateDeployScriptWithSqlCmdVariables()
        {
            var       result   = GetLiveAutoCompleteTestObjects();
            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, query : storedProcScript, dbNamePrefix : "DacFxGenerateScriptSqlCmdVarsTest");

            try
            {
                DacFxService service = new DacFxService();
                // First extract a db to have a dacpac to generate the script for later
                string dacpacPath = InitialExtract(service, sourceDb, result);

                // Generate script for deploying source dacpac to target db with SqlCmdVars
                var generateScriptParams = new GenerateDeployScriptParams
                {
                    PackageFilePath          = dacpacPath,
                    DatabaseName             = string.Concat(sourceDb.DatabaseName, "-generated"),
                    SqlCommandVariableValues = new Dictionary <string, string>()
                    {
                        { databaseRefVarName, "OtherDatabase" },
                        { filterValueVarName, "Employee" }
                    }
                };

                GenerateDeployScriptOperation generateScriptOperation = new GenerateDeployScriptOperation(generateScriptParams, result.ConnectionInfo);
                service.PerformOperation(generateScriptOperation, TaskExecutionMode.Script);

                // Verify the SqlCmdVars were set correctly in the script
                Assert.NotEmpty(generateScriptOperation.Result.DatabaseScript);
                Assert.Contains($":setvar {databaseRefVarName} \"{generateScriptParams.SqlCommandVariableValues[databaseRefVarName]}\"", generateScriptOperation.Result.DatabaseScript);
                Assert.Contains($":setvar {filterValueVarName} \"{generateScriptParams.SqlCommandVariableValues[filterValueVarName]}\"", generateScriptOperation.Result.DatabaseScript);

                VerifyAndCleanup(dacpacPath);
            }
            finally
            {
                sourceDb.Cleanup();
            }
        }
Ejemplo n.º 6
0
        public async void RestorePlanShouldFailOnExistingDatabaseNotGivenReplaceOption()
        {
            SqlTestDb testDb = null;

            try
            {
                testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "RestoreTest");

                //Create a backup from a test db but don't delete the database
                await VerifyBackupFileCreated();

                bool canRestore = true;

                await VerifyRestore(new string[] { fullBackupFilePath }, null, canRestore, TaskExecutionModeFlag.None, testDb.DatabaseName, null, null);
            }
            finally
            {
                if (testDb != null)
                {
                    testDb.Cleanup();
                }
            }
        }
        private async Task RunTest(string databaseName, string query, string testDbPrefix, Func <string, ObjectExplorerSession, Task> test)
        {
            SqlTestDb testDb = null;
            string    uri    = string.Empty;

            try
            {
                testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, testDbPrefix);

                if (databaseName == "#testDb#")
                {
                    databaseName = testDb.DatabaseName;
                }

                var session = await CreateSession(databaseName);

                uri = session.Uri;
                await test(testDb.DatabaseName, session);
            }
            catch (Exception ex)
            {
                string msg = ex.BuildRecursiveErrorMessage();
                Console.WriteLine($"Failed to run OE test. uri:{uri} error:{msg} {ex.StackTrace}");
                Assert.False(true, msg);
            }
            finally
            {
                if (!string.IsNullOrEmpty(uri))
                {
                    CloseSession(uri);
                }
                if (testDb != null)
                {
                    await testDb.CleanupAsync();
                }
            }
        }
Ejemplo n.º 8
0
        public void CreateBackupTest()
        {
            DisasterRecoveryService service = new DisasterRecoveryService();
            string    databaseName          = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
            SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);

            try
            {
                var liveConnection         = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
                DatabaseTaskHelper helper  = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
                SqlConnection      sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);

                string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);

                BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
                                                                BackupType.Full,
                                                                new List <string>()
                {
                    backupPath
                },
                                                                new Dictionary <string, int>()
                {
                    { backupPath, (int)DeviceType.File }
                });
                BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);

                // Backup the database
                service.PerformBackup(backupOperation);

                VerifyAndCleanBackup(backupPath);
                sqlConn.Close();
            }
            finally
            {
                testDb.Cleanup();
            }
        }
Ejemplo n.º 9
0
        public async void GenerateDeployScript()
        {
            // first extract a dacpac
            var       result   = GetLiveAutoCompleteTestObjects();
            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, SourceScript, "DacFxGenerateScriptTest");

            SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateScriptTest");

            try
            {
                DacFxService service    = new DacFxService();
                string       dacpacPath = InitialExtract(service, sourceDb, result);

                // generate script
                var generateScriptParams = new GenerateDeployScriptParams
                {
                    PackageFilePath = dacpacPath,
                    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(dacpacPath);
            }
            finally
            {
                sourceDb.Cleanup();
                targetDb.Cleanup();
            }
        }
Ejemplo n.º 10
0
        //[Fact]
        public async void BackupFileBrowserTest()
        {
            string    databaseName = "testfilebrowser_" + new Random().Next(10000000, 99999999);
            SqlTestDb testDb       = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);

            // Initialize backup service
            var liveConnection              = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
            DatabaseTaskHelper      helper  = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
            SqlConnection           sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
            DisasterRecoveryService disasterRecoveryService = new DisasterRecoveryService();
            BackupConfigInfo        backupConfigInfo        = disasterRecoveryService.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);

            // Create backup file
            string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + ".bak");
            string query      = $"BACKUP DATABASE [{databaseName}] TO  DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
            await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

            FileBrowserService service = new FileBrowserService();

            string[] backupFilters = new string[2] {
                "*.bak", "*.trn"
            };
            var openParams = new FileBrowserOpenParams
            {
                OwnerUri    = liveConnection.ConnectionInfo.OwnerUri,
                ExpandPath  = backupConfigInfo.DefaultBackupFolder,
                FileFilters = backupFilters
            };

            var openBrowserEventFlowValidator = new EventFlowValidator <bool>()
                                                .AddEventValidation(FileBrowserOpenedNotification.Type, eventParams =>
            {
                Assert.True(eventParams.Succeeded);
                Assert.NotNull(eventParams.FileTree);
                Assert.NotNull(eventParams.FileTree.RootNode);
                Assert.NotNull(eventParams.FileTree.RootNode.Children);
                Assert.True(eventParams.FileTree.RootNode.Children.Count > 0);
                Assert.True(ContainsFileInTheFolder(eventParams.FileTree.SelectedNode, backupPath));
            })
                                                .Complete();

            await service.RunFileBrowserOpenTask(openParams, openBrowserEventFlowValidator.Object);

            // Verify complete notification event was fired and the result
            openBrowserEventFlowValidator.Validate();

            var expandParams = new FileBrowserExpandParams
            {
                OwnerUri   = liveConnection.ConnectionInfo.OwnerUri,
                ExpandPath = backupConfigInfo.DefaultBackupFolder
            };


            var expandEventFlowValidator = new EventFlowValidator <bool>()
                                           .AddEventValidation(FileBrowserExpandedNotification.Type, eventParams =>
            {
                Assert.True(eventParams.Succeeded);
                Assert.NotNull(eventParams.Children);
                Assert.True(eventParams.Children.Length > 0);
            })
                                           .Complete();

            // Expand the node in file browser
            await service.RunFileBrowserExpandTask(expandParams, expandEventFlowValidator.Object);

            // Verify result
            expandEventFlowValidator.Validate();

            var validateParams = new FileBrowserValidateParams
            {
                OwnerUri      = liveConnection.ConnectionInfo.OwnerUri,
                ServiceType   = FileValidationServiceConstants.Backup,
                SelectedFiles = new[] { backupPath }
            };

            var validateEventFlowValidator = new EventFlowValidator <bool>()
                                             .AddEventValidation(FileBrowserValidatedNotification.Type, eventParams => Assert.True(eventParams.Succeeded))
                                             .Complete();

            // Validate selected files in the browser
            await service.RunFileBrowserValidateTask(validateParams, validateEventFlowValidator.Object);

            // Verify complete notification event was fired and the result
            validateEventFlowValidator.Validate();

            // Remove the backup file
            if (File.Exists(backupPath))
            {
                File.Delete(backupPath);
            }
        }
        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 override void Before(MethodInfo methodUnderTest)
 {
     SqlTestDb.CreateNew(ServerType, doNotCleanupDb: true, databaseName: Common.PerfTestDatabaseName, query: Scripts.CreateDatabaseObjectsQuery);
 }
Ejemplo n.º 13
0
        private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateGenerateDeployPlanRequest()
        {
            var       result   = GetLiveAutoCompleteTestObjects();
            SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateDeployPlanTest");

            sourceDb.RunQuery(@"CREATE TABLE [dbo].[table1]
(
    [ID] INT NOT NULL PRIMARY KEY,
    [Date] DATE NOT NULL
)
CREATE TABLE [dbo].[table2]
(
    [ID] INT NOT NULL PRIMARY KEY,
    [col1] NCHAR(10) NULL
)");
            DacFxService service    = new DacFxService();
            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 = new Version(1, 0)
            };

            ExtractOperation extractOperation = new ExtractOperation(extractParams, result.ConnectionInfo);

            service.PerformOperation(extractOperation);

            // generate deploy plan for deploying dacpac to targetDb
            var generateDeployPlanRequestContext = new Mock <RequestContext <DacFxResult> >();

            generateDeployPlanRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));

            SqlTestDb targetDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxGenerateDeployPlanTestTarget");

            targetDb.RunQuery(@"CREATE TABLE [dbo].[table2]
(
    [ID] INT NOT NULL PRIMARY KEY,
    [col1] NCHAR(10) NULL,
    [col2] NCHAR(10) NULL
)
CREATE TABLE [dbo].[table3]
(
    [ID] INT NOT NULL PRIMARY KEY,
    [col1] INT NULL,
)");

            var generateDeployPlanParams = new GenerateDeployPlanParams
            {
                PackageFilePath = extractParams.PackageFilePath,
                DatabaseName    = targetDb.DatabaseName,
            };

            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);
        }
Ejemplo n.º 14
0
        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);
        }
Ejemplo n.º 15
0
        public void ScriptBackupWithAdvancedOptionsTest()
        {
            DisasterRecoveryService service = new DisasterRecoveryService();
            string    databaseName          = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
            SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);

            try
            {
                var liveConnection            = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
                DatabaseTaskHelper helper     = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
                SqlConnection      sqlConn    = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
                string             backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);

                string certificateName         = CreateCertificate(testDb);
                string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName);

                BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
                                                                BackupType.Full,
                                                                new List <string>()
                {
                    backupPath
                },
                                                                new Dictionary <string, int>()
                {
                    { backupPath, (int)DeviceType.File }
                });
                backupInfo.FormatMedia         = true;
                backupInfo.SkipTapeHeader      = true;
                backupInfo.Initialize          = true;
                backupInfo.MediaName           = "backup test media";
                backupInfo.MediaDescription    = "backup test";
                backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128;
                backupInfo.EncryptorType       = (int)BackupEncryptorType.ServerCertificate;
                backupInfo.EncryptorName       = certificateName;

                BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);

                // Backup the database
                Console.WriteLine("Generate script for backup operation..");
                service.ScriptBackup(backupOperation);
                string script = backupOperation.ScriptContent;

                // Run the script
                Console.WriteLine("Execute the script..");
                testDb.RunQuery(script);

                // Remove the backup file
                Console.WriteLine("Verify the backup file exists and remove..");
                VerifyAndCleanBackup(backupPath);

                // Delete certificate and master key
                Console.WriteLine("Remove certificate and master key..");
                testDb.RunQuery(cleanupCertificateQuery);
                sqlConn.Close();
            }
            finally
            {
                // Clean up the database
                Console.WriteLine("Clean up database..");
                testDb.Cleanup();
            }
        }
Ejemplo n.º 16
0
        public async Task <string[]> CreateBackupSetsToRecoverDatabase()
        {
            List <string> backupFiles = new List <string>();

            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
            {
                string    query  = $"CREATE SCHEMA [test]";
                SqlTestDb testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, "RestoreTest");

                string databaseName = testDb.DatabaseName;
                // Initialize backup service
                var liveConnection        = LiveConnectionHelper.InitLiveConnectionInfo(databaseName, queryTempFile.FilePath);
                DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
                using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
                {
                    BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);

                    query = $"create table [test].[{tableNames[0]}] (c1 int)";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query);

                    string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_full.bak");
                    query = $"BACKUP DATABASE [{databaseName}] TO  DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

                    backupFiles.Add(backupPath);

                    query = $"create table [test].[{tableNames[1]}] (c1 int)";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query);

                    backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_diff.bak");
                    query      = $"BACKUP DATABASE [{databaseName}] TO  DISK = N'{backupPath}' WITH DIFFERENTIAL, NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

                    backupFiles.Add(backupPath);

                    query = $"create table [test].[{tableNames[2]}] (c1 int)";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query);

                    backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log1.bak");
                    query      = $"BACKUP Log [{databaseName}] TO  DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

                    backupFiles.Add(backupPath);

                    query = $"create table [test].[{tableNames[3]}] (c1 int)";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query);

                    backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log2.bak");
                    query      = $"BACKUP Log [{databaseName}] TO  DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

                    backupFiles.Add(backupPath);

                    query = $"create table [test].[{tableNames[4]}] (c1 int)";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, databaseName, query);

                    backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + "_log3.bak");
                    query      = $"BACKUP Log [{databaseName}] TO  DISK = N'{backupPath}' WITH NOFORMAT, NOINIT, NAME = N'{databaseName}-Full Database Backup', SKIP, NOREWIND, NOUNLOAD,  STATS = 10";
                    await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);

                    backupFiles.Add(backupPath);

                    databaseNameToRestoreFrom = testDb.DatabaseName;
                    // Clean up the database
                    testDb.Cleanup();
                }
            }
            return(backupFiles.ToArray());
        }
Ejemplo n.º 17
0
        private async Task VerifyScriptAsForMultipleObjects(string query, List <ScriptingObject> scriptingObjects, ScriptingOperationType operation, List <string> expectedScripts)
        {
            var testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, query, "ScriptingTests");

            try
            {
                var requestContext = new Mock <RequestContext <ScriptingResult> >();
                requestContext.Setup(x => x.SendResult(It.IsAny <ScriptingResult>())).Returns(Task.FromResult(new object()));
                ConnectionService connectionService = LiveConnectionHelper.GetLiveTestConnectionService();
                using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
                {
                    //Opening a connection to db to lock the db
                    TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync(testDb.DatabaseName, queryTempFile.FilePath, ConnectionType.Default);

                    var scriptingParams = new ScriptingParams
                    {
                        OwnerUri          = queryTempFile.FilePath,
                        ScriptDestination = "ToEditor",
                        Operation         = operation
                    };

                    string scriptCreateOperation = "ScriptCreate";
                    if (operation == ScriptingOperationType.Delete)
                    {
                        scriptCreateOperation = "ScriptDrop";
                    }
                    else
                    {
                        scriptCreateOperation = $"Script{operation}";
                    }

                    scriptingParams.ScriptOptions = new ScriptOptions
                    {
                        ScriptCreateDrop = scriptCreateOperation,
                    };

                    scriptingParams.ScriptingObjects = scriptingObjects;


                    ScriptingService service = new ScriptingService();
                    await service.HandleScriptExecuteRequest(scriptingParams, requestContext.Object);

                    Thread.Sleep(2000);
                    await service.ScriptingTask;

                    requestContext.Verify(x => x.SendResult(It.Is <ScriptingResult>(r => VerifyScriptingResult(r, expectedScripts))));
                    connectionService.Disconnect(new ServiceLayer.Connection.Contracts.DisconnectParams
                    {
                        OwnerUri = queryTempFile.FilePath
                    });
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                await testDb.CleanupAsync();
            }
        }
 public ScriptingFixture()
 {
     this.Database = SqlTestDb.CreateNew(TestServerType.OnPrem);
     this.Database.RunQuery(Scripts.CreateNorthwindSchema, throwOnError: true);
     Console.WriteLine("Northwind setup complete, database name: {0}", this.Database.DatabaseName);
 }
Ejemplo n.º 19
0
        public void CreateBackupWithAdvancedOptionsTest()
        {
            string    databaseName            = "testbackup_" + new Random().Next(10000000, 99999999);
            SqlTestDb testDb                  = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);
            string    certificateName         = "backupcertificate" + new Random().Next(10000000, 99999999);
            string    masterkeyPassword       = Guid.NewGuid().ToString();
            string    createCertificateQuery  = string.Format(CreateCertificateQueryFormat, masterkeyPassword, certificateName);
            string    cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName);

            // create master key and certificate
            Console.WriteLine("Create master key and certificate..");
            testDb.RunQuery(createCertificateQuery);

            var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);

            // Initialize backup service
            DatabaseTaskHelper helper  = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
            SqlConnection      sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);

            // Get default backup path
            Console.WriteLine("Get default backup path..");
            BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
            string           backupPath       = Path.Combine(backupConfigInfo.DefaultBackupFolder, databaseName + ".bak");

            BackupInfo backupInfo = CreateBackupInfo(databaseName,
                                                     BackupType.Full,
                                                     new List <string>()
            {
                backupPath
            },
                                                     new Dictionary <string, int>()
            {
                { backupPath, (int)DeviceType.File }
            });

            // Set advanced options
            backupInfo.ContinueAfterError = true;
            backupInfo.FormatMedia        = true;
            backupInfo.SkipTapeHeader     = true;
            backupInfo.Initialize         = true;
            backupInfo.MediaName          = "backup test media";
            backupInfo.MediaDescription   = "backup test";
            backupInfo.RetainDays         = 90;
            backupInfo.CompressionOption  = (int)BackupCompressionOptions.On;

            // Set encryption
            backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128;
            backupInfo.EncryptorType       = (int)BackupEncryptorType.ServerCertificate;
            backupInfo.EncryptorName       = certificateName;

            var backupParams = new BackupParams
            {
                OwnerUri   = liveConnection.ConnectionInfo.OwnerUri,
                BackupInfo = backupInfo
            };

            // Backup the database
            Console.WriteLine("Perform backup operation..");
            BackupOperation backupOperation = DisasterRecoveryService.Instance.SetBackupInput(helper.DataContainer, sqlConn, backupParams.BackupInfo);

            DisasterRecoveryService.Instance.PerformBackup(backupOperation);

            // Verify backup file is created
            Assert.True(File.Exists(backupPath));

            // Remove the backup file
            Console.WriteLine("Remove backup file..");
            if (File.Exists(backupPath))
            {
                File.Delete(backupPath);
            }

            // Delete certificate and master key
            Console.WriteLine("Remove certificate and master key..");
            testDb.RunQuery(cleanupCertificateQuery);

            // Clean up the database
            Console.WriteLine("Clean up database..");
            testDb.Cleanup();
        }