supporting restore from db (#429)

* supporting restore from db

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DisasterRecovery/RestoreDatabaseServiceTests.cs

@@ -35,6 +35,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
         private DisasterRecoveryService service;
         private string fullBackupFilePath;
         private string[] backupFilesToRecoverDatabase;
+        private string databaseNameToRestoreFrom;
 
         //The table names used in the script to create backup files for a database
         //Each table is created after a backup script to verify recovering to different states
@@ -84,6 +85,27 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
             await VerifyRestoreMultipleBackupSets(backupFiles, indexToDelete, expectedTable);
         }
 
+        [Fact]
+        public async void RestoreShouldRestoreFromAnotherDatabase()
+        {
+            await GetBackupFilesToRecoverDatabaseCreated();
+
+            var testDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "RestoreTest");
+            try
+            {
+                Dictionary<string, object> options = new Dictionary<string, object>();
+                options.Add(RestoreOptionsHelper.ReplaceDatabase, true);
+                await VerifyRestore(null, databaseNameToRestoreFrom, true, true, testDb.DatabaseName, null, options, (database) =>
+                {
+                    return database.Tables.Contains("tb1", "test");
+                });
+            }
+            finally
+            {
+                testDb.Cleanup();
+            }
+        }
+
         [Fact]
         public async void RestoreShouldRestoreTheBackupSetsThatAreSelected()
         {
@@ -114,7 +136,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
             {
                 string targetDbName = testDb.DatabaseName;
                 bool canRestore = true;
-                var response = await VerifyRestore(backupFiles, canRestore, false, targetDbName, null, null);
+                var response = await VerifyRestore(backupFiles, null, canRestore, false, targetDbName, null, null);
                 Assert.True(response.BackupSetsToRestore.Count() >= 2);
                 var allIds = response.BackupSetsToRestore.Select(x => x.Id).ToList();
                 if (backupSetIndexToDelete >= 0)
@@ -124,7 +146,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                 string[] selectedIds = allIds.ToArray();
                 Dictionary<string, object> options = new Dictionary<string, object>();
                 options.Add(RestoreOptionsHelper.ReplaceDatabase, true);
-                response = await VerifyRestore(backupFiles, canRestore, true, targetDbName, selectedIds, options, (database) =>
+                response = await VerifyRestore(backupFiles, null, canRestore, true, targetDbName, selectedIds, options, (database) =>
                 {
                     bool tablesFound = true;
                     for (int i = 0; i < tableNames.Length; i++)
@@ -168,7 +190,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                 Dictionary<string, object> options = new Dictionary<string, object>();
                 options.Add(RestoreOptionsHelper.ReplaceDatabase, true);
 
-                await VerifyRestore(new string[] { fullBackupFilePath }, canRestore, true, testDb.DatabaseName, null, options);
+                await VerifyRestore(new string[] { fullBackupFilePath }, null, canRestore, true, testDb.DatabaseName, null, options);
             }
             finally
             {
@@ -190,7 +212,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                 await VerifyBackupFileCreated();
                 bool canRestore = true;
 
-                await VerifyRestore(new string[] { fullBackupFilePath }, canRestore, false, testDb.DatabaseName, null, null);
+                await VerifyRestore(new string[] { fullBackupFilePath }, null, canRestore, false, testDb.DatabaseName, null, null);
             }
             finally
             {
@@ -207,7 +229,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 
             string[] backupFileNames = new string[] { "FullBackup.bak", "DiffBackup.bak" };
             bool canRestore = true;
-            var response = await VerifyRestore(backupFileNames, canRestore, false, "RestoredFromTwoBackupFile");
+            var response = await VerifyRestore(backupFileNames, null, canRestore, false, "RestoredFromTwoBackupFile");
             Assert.True(response.BackupSetsToRestore.Count() == 2);
         }
 
@@ -217,13 +239,13 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 
             string[] backupFileNames = new string[] { "FullBackup.bak", "DiffBackup.bak" };
             bool canRestore = true;
-            var response = await VerifyRestore(backupFileNames, canRestore, false, "RestoredFromTwoBackupFile");
+            var response = await VerifyRestore(backupFileNames, null, canRestore, false, "RestoredFromTwoBackupFile");
             Assert.True(response.BackupSetsToRestore.Count() == 2);
             var fileInfo = response.BackupSetsToRestore.FirstOrDefault(x => x.GetPropertyValueAsString(BackupSetInfo.BackupTypePropertyName) != RestoreConstants.TypeFull);
             if(fileInfo != null)
             {
                 var selectedBackupSets = new string[] { fileInfo.Id };
-                await VerifyRestore(backupFileNames, true, false, "RestoredFromTwoBackupFile", selectedBackupSets);
+                await VerifyRestore(backupFileNames, null, true, false, "RestoredFromTwoBackupFile", selectedBackupSets);
             }
         }
 
@@ -233,13 +255,13 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 
             string[] backupFileNames = new string[] { "FullBackup.bak", "DiffBackup.bak" };
             bool canRestore = true;
-            var response = await VerifyRestore(backupFileNames, canRestore, false, "RestoredFromTwoBackupFile");
+            var response = await VerifyRestore(backupFileNames, null, canRestore, false, "RestoredFromTwoBackupFile");
             Assert.True(response.BackupSetsToRestore.Count() == 2);
             var fileInfo = response.BackupSetsToRestore.FirstOrDefault(x => x.GetPropertyValueAsString(BackupSetInfo.BackupTypePropertyName) == RestoreConstants.TypeFull);
             if (fileInfo != null)
             {
                 var selectedBackupSets = new string[] { fileInfo.Id };
-                await VerifyRestore(backupFileNames, true, false, "RestoredFromTwoBackupFile2", selectedBackupSets);
+                await VerifyRestore(backupFileNames, null, true, false, "RestoredFromTwoBackupFile2", selectedBackupSets);
             }
         }
 
@@ -306,6 +328,32 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
             }
         }
 
+        [Fact]
+        public async Task RestoreConfigInfoRequestShouldReturnResponse()
+        {
+            await VerifyBackupFileCreated();
+
+            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
+            {
+                TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
+
+                string filePath = GetBackupFilePath(fullBackupFilePath);
+
+                RestoreConfigInfoRequestParams restoreParams = new RestoreConfigInfoRequestParams
+                {
+                    OwnerUri = queryTempFile.FilePath
+                };
+
+                await RunAndVerify<RestoreConfigInfoResponse>(
+                    test: (requestContext) => service.HandleRestoreConfigInfoRequest(restoreParams, requestContext),
+                    verify: ((result) =>
+                    {
+                        Assert.True(result.ConfigInfo.Any());
+                        Assert.True(result.ConfigInfo.ContainsKey(RestoreOptionsHelper.SourceDatabaseNamesWithBackupSets));
+                    }));
+            }
+        }
+
         [Fact]
         public async Task RestoreDatabaseRequestShouldStartTheRestoreTask()
         {
@@ -368,36 +416,53 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 
         private async Task<RestorePlanResponse> VerifyRestore(string backupFileName, bool canRestore, bool execute = false, string targetDatabase = null)
         {
-            return await VerifyRestore(new string[] { backupFileName }, canRestore, execute, targetDatabase);
+            return await VerifyRestore(new string[] { backupFileName }, null, canRestore, execute, targetDatabase);
         }
 
         private async Task<RestorePlanResponse> VerifyRestore(
-            string[] backupFileNames, 
-            bool canRestore, 
+            string[] backupFileNames = null, 
+            string sourceDbName = null,
+            bool canRestore = true, 
             bool execute = false, 
             string targetDatabase = null, 
             string[] selectedBackupSets = null,
             Dictionary<string, object> options = null,
             Func<Database, bool> verifyDatabase = null)
         {
-            var filePaths = backupFileNames.Select(x => GetBackupFilePath(x));
-            string backUpFilePath = filePaths.Aggregate((current, next) => current + " ," + next);
-
+            string backUpFilePath = string.Empty;
+            if (backupFileNames != null)
+            {
+                var filePaths = backupFileNames.Select(x => GetBackupFilePath(x));
+                backUpFilePath = filePaths.Aggregate((current, next) => current + " ," + next);
+            }
 
             using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
             {
                 TestConnectionResult connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
 
                 RestoreDatabaseHelper service = new RestoreDatabaseHelper();
+
+                // If source database is sepecified verfiy it's part of source db list
+                if(!string.IsNullOrEmpty(sourceDbName))
+                {
+                    RestoreConfigInfoResponse configInfoResponse = service.CreateConfigInfoResponse(new RestoreConfigInfoRequestParams
+                    {
+                        OwnerUri = queryTempFile.FilePath
+                    });
+                    IEnumerable<string> dbNames = configInfoResponse.ConfigInfo[RestoreOptionsHelper.SourceDatabaseNamesWithBackupSets] as IEnumerable<string>;
+                    Assert.True(dbNames.Any(x => x == sourceDbName));
+                }
                 var request = new RestoreParams
                 {
                     BackupFilePaths = backUpFilePath,
                     TargetDatabaseName = targetDatabase,
                     OwnerUri = queryTempFile.FilePath,
-                    SelectedBackupSets = selectedBackupSets
+                    SelectedBackupSets = selectedBackupSets,
+                    SourceDatabaseName = sourceDbName
                 };
+                request.Options[RestoreOptionsHelper.ReadHeaderFromMedia] = backupFileNames != null;
 
-                if(options != null)
+                if (options != null)
                 {
                     foreach (var item in options)
                     {
@@ -424,35 +489,45 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                     Assert.Equal(response.DatabaseName, targetDatabase);
                     Assert.NotNull(response.PlanDetails);
                     Assert.True(response.PlanDetails.Any());
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultBackupTailLog]);
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultTailLogBackupFile]);
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultDataFileFolder]);
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultLogFileFolder]);
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultStandbyFile]);
-                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DefaultStandbyFile]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.BackupTailLog]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.TailLogBackupFile]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.DataFileFolder]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.LogFileFolder]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.StandbyFile]);
+                    Assert.NotNull(response.PlanDetails[RestoreOptionsHelper.StandbyFile]);
                    
                     if(execute)
                     {
-                        request.SessionId = response.SessionId;
-                        restoreDataObject = service.CreateRestoreDatabaseTaskDataObject(request);
-                        Assert.Equal(response.SessionId, restoreDataObject.SessionId);
-                        request.RelocateDbFiles = !restoreDataObject.DbFilesLocationAreValid();
-                        service.ExecuteRestore(restoreDataObject);
-                        Assert.True(restoreDataObject.Server.Databases.Contains(targetDatabase));
-
-                        if(verifyDatabase != null)
+                        try
                         {
-                            Assert.True(verifyDatabase(restoreDataObject.Server.Databases[targetDatabase]));
-                        }
+                            request.SessionId = response.SessionId;
+                            restoreDataObject = service.CreateRestoreDatabaseTaskDataObject(request);
+                            Assert.Equal(response.SessionId, restoreDataObject.SessionId);
+                            request.RelocateDbFiles = !restoreDataObject.DbFilesLocationAreValid();
+                            service.ExecuteRestore(restoreDataObject);
+                            Assert.True(restoreDataObject.Server.Databases.Contains(targetDatabase));
+
+                            if (verifyDatabase != null)
+                            {
+                                Assert.True(verifyDatabase(restoreDataObject.Server.Databases[targetDatabase]));
+                            }
+
+                            //To verify the backupset that are restored, verifying the database is a better options.
+                            //Some tests still verify the number of backup sets that are executed which in some cases can be less than the selected list
+                            if (verifyDatabase == null && selectedBackupSets != null)
+                            {
+                                Assert.Equal(selectedBackupSets.Count(), restoreDataObject.RestorePlanToExecute.RestoreOperations.Count());
+                            }
 
-                        //To verify the backupset that are restored, verifying the database is a better options.
-                        //Some tests still verify the number of backup sets that are executed which in some cases can be less than the selected list
-                        if (verifyDatabase == null && selectedBackupSets != null)
-                        {
-                            Assert.Equal(selectedBackupSets.Count(), restoreDataObject.RestorePlanToExecute.RestoreOperations.Count());
                         }
-                     
-                        await DropDatabase(targetDatabase);
+                        catch(Exception ex)
+                        {
+                            Assert.False(true, ex.Message);
+                        }
+                        finally
+                        {
+                            await DropDatabase(targetDatabase);
+                        }
                     }
                 }
 
@@ -514,8 +589,6 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
             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;
@@ -560,6 +633,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                 await TestServiceProvider.Instance.RunQueryAsync(TestServerType.OnPrem, "master", query);
                 backupFiles.Add(backupPath);
 
+                databaseNameToRestoreFrom = testDb.DatabaseName;
                 // Clean up the database
                 testDb.Cleanup();
             }

test/Microsoft.SqlTools.ServiceLayer.UnitTests/DisasterRecovery/RestoreOptionsHelperTests.cs

@@ -0,0 +1,275 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlTools.ServiceLayer.DisasterRecovery;
+using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
+using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
+{
+    public class RestoreOptionsHelperTests
+    {
+        [Fact]
+        public void VerifyOptionsCreatedSuccessfullyIsResponse()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+        }
+
+        [Fact]
+        public void RelocateAllFilesShouldBeReadOnlyGivenNoDbFiles()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options["DbFiles"] = new List<DbFile>();
+            Mock <IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+            Assert.True(result[RestoreOptionsHelper.RelocateDbFiles].IsReadOnly);
+        }
+
+        [Fact]
+        public void BackupTailLogShouldBeReadOnlyTailLogBackupNotPossible()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options["IsTailLogBackupPossible"] = false;
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+            Assert.True(result[RestoreOptionsHelper.BackupTailLog].IsReadOnly);
+            Assert.True(result[RestoreOptionsHelper.TailLogBackupFile].IsReadOnly);
+        }
+
+        [Fact]
+        public void TailLogWithNoRecoveryShouldBeReadOnlyTailLogBackupWithNoRecoveryNotPossible()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options["IsTailLogBackupWithNoRecoveryPossible"] = false;
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+            Assert.True(result[RestoreOptionsHelper.TailLogWithNoRecovery].IsReadOnly);
+        }
+
+        [Fact]
+        public void StandbyFileShouldNotBeReadOnlyGivenRecoveryStateWithStandBy()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithStandBy;
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+            Assert.False(result[RestoreOptionsHelper.StandbyFile].IsReadOnly);
+        }
+
+        [Fact]
+        public void KeepReplicationShouldNotBeReadOnlyGivenRecoveryStateWithNoRecovery()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithNoRecovery;
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+            Assert.NotNull(result);
+            VerifyOptions(result, optionValues);
+            Assert.True(result[RestoreOptionsHelper.KeepReplication].IsReadOnly);
+        }
+
+        [Fact]
+        public void KeepReplicationShouldSetToDefaultValueGivenRecoveryStateWithNoRecovery()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+            restoreParams.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithNoRecovery;
+
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+            Dictionary<string, RestorePlanDetailInfo> options = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+
+            restoreParams.Options[RestoreOptionsHelper.KeepReplication] = true;
+
+            bool actual = RestoreOptionsHelper.GetOptionValue<bool>(RestoreOptionsHelper.KeepReplication, options, restoreDatabaseTaskDataObject.Object);
+            bool expected = (bool)options[RestoreOptionsHelper.KeepReplication].DefaultValue;
+
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void KeepReplicationShouldSetToValueInRequestGivenRecoveryStateWithRecovery()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+           
+            restoreParams.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithRecovery;
+            Mock<IRestoreDatabaseTaskDataObject> restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+            Dictionary<string, RestorePlanDetailInfo> options = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject.Object);
+
+            restoreParams.Options[RestoreOptionsHelper.KeepReplication] = true;
+
+            bool actual = RestoreOptionsHelper.GetOptionValue<bool>(RestoreOptionsHelper.KeepReplication, options, restoreDatabaseTaskDataObject.Object);
+            bool expected = true;
+            Assert.Equal(actual, expected);
+
+        }
+
+
+        private RestoreParams CreateOptionsTestData()
+        {
+            RestoreParams optionValues = new RestoreParams();
+            optionValues.Options.Add(RestoreOptionsHelper.CloseExistingConnections, false);
+            optionValues.Options.Add(RestoreOptionsHelper.DataFileFolder, "Data file folder");
+            optionValues.Options.Add("DbFiles", new List<DbFile>() { new DbFile("", '1', "") });
+            optionValues.Options.Add("DefaultDataFileFolder", "Default data file folder");
+            optionValues.Options.Add("DefaultLogFileFolder", "Default log file folder");
+            optionValues.Options.Add("IsTailLogBackupPossible", true);
+            optionValues.Options.Add("IsTailLogBackupWithNoRecoveryPossible", true);
+            optionValues.Options.Add("GetDefaultStandbyFile", "default standby file");
+            optionValues.Options.Add("GetDefaultTailLogbackupFile", "default tail log backup file");
+            optionValues.Options.Add("LogFilesFolder", "Log file folder");
+            optionValues.Options.Add("RelocateAllFiles", false);
+            optionValues.Options.Add("TailLogBackupFile", "tail log backup file");
+            optionValues.Options.Add("TailLogWithNoRecovery", false);
+            optionValues.Options.Add("BackupTailLog", false);
+            optionValues.Options.Add(RestoreOptionsHelper.KeepReplication, false);
+            optionValues.Options.Add("ReplaceDatabase", false);
+            optionValues.Options.Add("SetRestrictedUser", false);
+            optionValues.Options.Add("StandbyFile", "Stand by file");
+            optionValues.Options.Add(RestoreOptionsHelper.RecoveryState, DatabaseRecoveryState.WithNoRecovery.ToString());
+            return optionValues;
+        }
+
+        private Mock<IRestoreDatabaseTaskDataObject> CreateRestoreDatabaseTaskDataObject(GeneralRequestDetails optionValues)
+        {
+            var restoreDataObject = new Mock<IRestoreDatabaseTaskDataObject>();
+            restoreDataObject.Setup(x => x.CloseExistingConnections).Returns(optionValues.GetOptionValue<bool>(RestoreOptionsHelper.CloseExistingConnections));
+            restoreDataObject.Setup(x => x.DataFilesFolder).Returns(optionValues.GetOptionValue<string>(RestoreOptionsHelper.DataFileFolder));
+            restoreDataObject.Setup(x => x.DbFiles).Returns(optionValues.GetOptionValue<List<DbFile>>("DbFiles"));
+            restoreDataObject.Setup(x => x.DefaultDataFileFolder).Returns(optionValues.GetOptionValue<string>("DefaultDataFileFolder"));
+            restoreDataObject.Setup(x => x.DefaultLogFileFolder).Returns(optionValues.GetOptionValue<string>("DefaultLogFileFolder"));
+            restoreDataObject.Setup(x => x.IsTailLogBackupPossible(It.IsAny<string>())).Returns(optionValues.GetOptionValue<bool>("IsTailLogBackupPossible"));
+            restoreDataObject.Setup(x => x.IsTailLogBackupWithNoRecoveryPossible(It.IsAny<string>())).Returns(optionValues.GetOptionValue<bool>("IsTailLogBackupWithNoRecoveryPossible"));
+            restoreDataObject.Setup(x => x.GetDefaultStandbyFile(It.IsAny<string>())).Returns(optionValues.GetOptionValue<string>("GetDefaultStandbyFile"));
+            restoreDataObject.Setup(x => x.GetDefaultTailLogbackupFile(It.IsAny<string>())).Returns(optionValues.GetOptionValue<string>("GetDefaultTailLogbackupFile"));
+            restoreDataObject.Setup(x => x.LogFilesFolder).Returns(optionValues.GetOptionValue<string>("LogFilesFolder"));
+            restoreDataObject.Setup(x => x.RelocateAllFiles).Returns(optionValues.GetOptionValue<bool>("RelocateAllFiles"));
+            restoreDataObject.Setup(x => x.TailLogBackupFile).Returns(optionValues.GetOptionValue<string>("TailLogBackupFile"));
+            restoreDataObject.Setup(x => x.TailLogWithNoRecovery).Returns(optionValues.GetOptionValue<bool>("TailLogWithNoRecovery"));
+            restoreDataObject.Setup(x => x.BackupTailLog).Returns(optionValues.GetOptionValue<bool>("BackupTailLog"));
+            restoreDataObject.Setup(x => x.RestoreParams).Returns(optionValues as RestoreParams);
+            restoreDataObject.Setup(x => x.RestorePlan).Returns(() => null);
+            RestoreOptions restoreOptions = new RestoreOptions();
+            restoreOptions.KeepReplication = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.KeepReplication);
+            restoreOptions.ReplaceDatabase = optionValues.GetOptionValue<bool>("ReplaceDatabase");
+            restoreOptions.SetRestrictedUser = optionValues.GetOptionValue<bool>("SetRestrictedUser");
+            restoreOptions.StandByFile = optionValues.GetOptionValue<string>("StandbyFile");
+            restoreOptions.RecoveryState = optionValues.GetOptionValue<DatabaseRecoveryState>(RestoreOptionsHelper.RecoveryState);
+            restoreDataObject.Setup(x => x.RestoreOptions).Returns(restoreOptions);
+
+
+            return restoreDataObject;
+        }
+
+        private void VerifyOptions(Dictionary<string, RestorePlanDetailInfo> optionInResponse, GeneralRequestDetails optionValues)
+        {
+            RestorePlanDetailInfo planDetailInfo = optionInResponse[RestoreOptionsHelper.DataFileFolder];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.DataFileFolder);
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("RelocateAllFiles"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>(RestoreOptionsHelper.DataFileFolder));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<string>("DefaultDataFileFolder"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.LogFileFolder];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.LogFileFolder);
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("RelocateAllFiles"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>("LogFilesFolder"));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<string>("DefaultLogFileFolder"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.RelocateDbFiles];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.RelocateDbFiles);
+            Assert.Equal(planDetailInfo.IsReadOnly, (optionValues.GetOptionValue<List<DbFile>>("DbFiles").Count == 0));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("LogFilesFolder"));
+            Assert.Equal(planDetailInfo.DefaultValue, false);
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.ReplaceDatabase];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.ReplaceDatabase);
+            Assert.Equal(planDetailInfo.IsReadOnly, false);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("ReplaceDatabase"));
+            Assert.Equal(planDetailInfo.DefaultValue, false);
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.KeepReplication];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.KeepReplication);
+            Assert.Equal(planDetailInfo.IsReadOnly, optionValues.GetOptionValue<DatabaseRecoveryState>(RestoreOptionsHelper.RecoveryState) == DatabaseRecoveryState.WithNoRecovery);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.KeepReplication));
+            Assert.Equal(planDetailInfo.DefaultValue, false);
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.SetRestrictedUser];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.SetRestrictedUser);
+            Assert.Equal(planDetailInfo.IsReadOnly, false);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("SetRestrictedUser"));
+            Assert.Equal(planDetailInfo.DefaultValue, false);
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.RecoveryState];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.RecoveryState);
+            Assert.Equal(planDetailInfo.IsReadOnly, false);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<DatabaseRecoveryState>(RestoreOptionsHelper.RecoveryState).ToString());
+            Assert.Equal(planDetailInfo.DefaultValue, DatabaseRecoveryState.WithRecovery.ToString());
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.StandbyFile];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.StandbyFile);
+            Assert.Equal(planDetailInfo.IsReadOnly, optionValues.GetOptionValue<DatabaseRecoveryState>(RestoreOptionsHelper.RecoveryState) != DatabaseRecoveryState.WithStandBy);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>("StandbyFile"));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<string>("GetDefaultStandbyFile"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.BackupTailLog];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.BackupTailLog);
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("IsTailLogBackupPossible"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("BackupTailLog"));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<bool>("IsTailLogBackupPossible"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.TailLogBackupFile];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.TailLogBackupFile);
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("IsTailLogBackupPossible"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>("TailLogBackupFile"));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<string>("GetDefaultTailLogbackupFile"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.TailLogWithNoRecovery];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.TailLogWithNoRecovery);
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("IsTailLogBackupWithNoRecoveryPossible"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("TailLogWithNoRecovery"));
+            Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<bool>("IsTailLogBackupWithNoRecoveryPossible"));
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+
+            planDetailInfo = optionInResponse[RestoreOptionsHelper.CloseExistingConnections];
+            Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.CloseExistingConnections);
+            Assert.Equal(planDetailInfo.IsReadOnly, false);
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<bool>("CloseExistingConnections"));
+            Assert.Equal(planDetailInfo.DefaultValue, false);
+            Assert.Equal(planDetailInfo.IsVisiable, true);
+        }
+        
+    }
+}