fixed the bugs with creating new restore plan (#433)

* fixed the bug with source db name not setting correctly when new plan created

src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreDatabaseHelper.cs

@@ -171,14 +171,13 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                     if (restoreDataObject != null && restoreDataObject.IsValid)
                     {
                         response.SessionId = restoreDataObject.SessionId;
-                        response.DatabaseName = restoreDataObject.TargetDatabase;
+                        response.DatabaseName = restoreDataObject.TargetDatabaseName;
-                        response.PlanDetails.Add(RestoreOptionsHelper.TargetDatabaseName, RestorePlanDetailInfo.Create(
+
-                            name: RestoreOptionsHelper.TargetDatabaseName,
+                        response.PlanDetails.Add(RestoreOptionsHelper.TargetDatabaseName, 
-                            currentValue: restoreDataObject.TargetDatabase, 
+                            RestoreOptionFactory.Instance.CreateAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDataObject));
-                            isReadOnly: !CanChangeTargetDatabase(restoreDataObject)));
+                        response.PlanDetails.Add(RestoreOptionsHelper.SourceDatabaseName, 
-                        response.PlanDetails.Add(RestoreOptionsHelper.SourceDatabaseName, RestorePlanDetailInfo.Create(
+                            RestoreOptionFactory.Instance.CreateAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDataObject));
-                            name: RestoreOptionsHelper.SourceDatabaseName,
+
-                            currentValue: restoreDataObject.RestorePlanner.DatabaseName));
                         response.PlanDetails.Add(RestoreOptionsHelper.ReadHeaderFromMedia, RestorePlanDetailInfo.Create(
                            name: RestoreOptionsHelper.ReadHeaderFromMedia,
                            currentValue: restoreDataObject.RestorePlanner.ReadHeaderFromMedia));
@@ -191,16 +190,11 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                         });
                         response.CanRestore = CanRestore(restoreDataObject);
 
-                        if (!response.CanRestore)
-                        {
-                            response.ErrorMessage = SR.RestoreNotSupported;
-                        }
-
                         response.PlanDetails.Add(LastBackupTaken, 
                             RestorePlanDetailInfo.Create(name: LastBackupTaken, currentValue: restoreDataObject.GetLastBackupTaken(), isReadOnly: true));
 
                         response.BackupSetsToRestore = restoreDataObject.GetSelectedBakupSets();
-                        var dbNames = restoreDataObject.GetPossibleTargerDbNames();
+                        var dbNames = restoreDataObject.SourceDbNames;
                         response.DatabaseNamesFromBackupSets = dbNames == null ? new string[] { } : dbNames.ToArray();
 
                         RestoreOptionsHelper.AddOptions(response, restoreDataObject);
@@ -259,11 +253,11 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             if (!sessions.TryGetValue(sessionId, out restoreTaskObject))
             {
                 restoreTaskObject = CreateRestoreForNewSession(restoreParams.OwnerUri, restoreParams.TargetDatabaseName);
+                sessions.AddOrUpdate(sessionId, restoreTaskObject, (key, old) => restoreTaskObject);
             }
             restoreTaskObject.SessionId = sessionId;
             restoreTaskObject.RestoreParams = restoreParams;
-            restoreTaskObject.TargetDatabase = restoreParams.TargetDatabaseName;
+            
-            restoreTaskObject.RestorePlanner.DatabaseName = restoreParams.TargetDatabaseName;
             return restoreTaskObject;
         }
 
@@ -308,33 +302,24 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         /// <returns></returns>
         private void UpdateRestorePlan(RestoreDatabaseTaskDataObject restoreDataObject)
         {
+            bool shouldCreateNewPlan = restoreDataObject.ShouldCreateNewPlan();
+            
             if (!string.IsNullOrEmpty(restoreDataObject.RestoreParams.BackupFilePaths))
             {
                 restoreDataObject.AddFiles(restoreDataObject.RestoreParams.BackupFilePaths);
             }
             restoreDataObject.RestorePlanner.ReadHeaderFromMedia = restoreDataObject.RestoreParams.ReadHeaderFromMedia;
 
-            if (string.IsNullOrWhiteSpace(restoreDataObject.RestoreParams.SourceDatabaseName))
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDataObject);
-            {
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDataObject);
-                restoreDataObject.RestorePlanner.DatabaseName = restoreDataObject.DefaultDbName;
-            }
-            else
-            {
-                restoreDataObject.RestorePlanner.DatabaseName = restoreDataObject.RestoreParams.SourceDatabaseName;
-            }
 
-            if (CanChangeTargetDatabase(restoreDataObject))
+            if (shouldCreateNewPlan)
             {
-                restoreDataObject.TargetDatabase = restoreDataObject.RestoreParams.TargetDatabaseName;
+                restoreDataObject.CreateNewRestorePlan();
             }
-            else
-            {
-                restoreDataObject.TargetDatabase = restoreDataObject.Server.ConnectionContext.DatabaseName;
-            }
-
-            
 
             restoreDataObject.UpdateRestorePlan();
+
         }
 
         private bool CanChangeTargetDatabase(RestoreDatabaseTaskDataObject restoreDataObject)

src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreDatabaseTaskDataObject.cs

@@ -12,6 +12,7 @@ using Microsoft.SqlServer.Management.Common;
 using Microsoft.SqlServer.Management.Smo;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
 using Microsoft.SqlTools.ServiceLayer.TaskServices;
+using Microsoft.SqlTools.ServiceLayer.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
 {
@@ -43,6 +44,19 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         RestoreParams RestoreParams { get; set; }
 
         bool BackupTailLog { get; set; }
+
+        string DefaultSourceDbName { get; }
+
+        string SourceDatabaseName { get; set; }
+
+        List<String> SourceDbNames { get; }
+
+        bool CanChangeTargetDatabase { get; }
+
+        string DefaultTargetDbName { get; }
+        string TargetDatabaseName { get; set; }
+
+
     }
     /// <summary>
     /// Includes the plan with all the data required to do a restore operation on server
@@ -56,6 +70,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         private BackupSetsFilterInfo backupSetsFilterInfo = new BackupSetsFilterInfo();
         private bool? isTailLogBackupPossible = false;
         private bool? isTailLogBackupWithNoRecoveryPossible = false;
+        private string backupMediaList = string.Empty;
 
         public RestoreDatabaseTaskDataObject(Server server, String databaseName)
         {
@@ -95,11 +110,11 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         /// </summary>
         public SqlTask SqlTask { get; set; }
 
-        public string TargetDatabase
+        public string TargetDatabaseName
         {
             get
             {
-                return string.IsNullOrEmpty(targetDbName) ? DefaultDbName : targetDbName;
+                return string.IsNullOrEmpty(targetDbName) ? DefaultSourceDbName : targetDbName;
             }
             set
             {
@@ -121,9 +136,19 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         /// Database names includes in the restore plan
         /// </summary>
         /// <returns></returns>
-        public List<String> GetPossibleTargerDbNames()
+        public List<String> SourceDbNames
         {
-            return Util.GetSourceDbNames(this.restorePlanner.BackupMediaList, this.CredentialName);
+            get
+            {
+                if (RestorePlanner.ReadHeaderFromMedia)
+                {
+                    return Util.GetSourceDbNames(this.restorePlanner.BackupMediaList, this.CredentialName);
+                }
+                else
+                {
+                    return Util.GetSourceDbNames();
+                }
+            }
         }
 
         /// <summary>
@@ -135,6 +160,23 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             return Util.GetSourceDbNames();
         }
 
+        public bool CanChangeTargetDatabase
+        {
+            get
+            {
+                return DatabaseUtils.IsSystemDatabaseConnection(Server.ConnectionContext.DatabaseName);
+            }
+        }
+
+        public string DefaultTargetDbName
+        {
+            get
+            {
+                return Server.ConnectionContext.DatabaseName;
+            }
+        }
+
+
         /// <summary>
         /// Current sqlserver instance
         /// </summary>
@@ -154,6 +196,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         /// <param name="filePaths"></param>
         public void AddFiles(string filePaths)
         {
+            backupMediaList = filePaths;
             PlanUpdateRequired = true;
             if (!string.IsNullOrWhiteSpace(filePaths))
             {
@@ -634,16 +677,40 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         /// <summary>
         /// The database from the backup file used to restore to by default
         /// </summary>
-        public string DefaultDbName
+        public string DefaultSourceDbName
         {
             get
             {
-                var dbNames = GetPossibleTargerDbNames();
+                var dbNames = SourceDbNames;
                 string dbName = dbNames.FirstOrDefault();
                 return dbName;
             }
         }
 
+        /// <summary>
+        /// Current value of source db name in the planner
+        /// </summary>
+        public string SourceDatabaseName
+        {
+            get
+            {
+                return this.RestorePlanner == null ? string.Empty : this.RestorePlanner.DatabaseName;
+            }
+            set
+            {
+                if(this.RestorePlanner != null)
+                {
+                    string currentDatabaseName = this.RestorePlanner.DatabaseName;
+                    this.RestorePlanner.DatabaseName = value;
+
+                    if (string.Compare(currentDatabaseName, value, StringComparison.InvariantCultureIgnoreCase) != 0)
+                    {
+                        ResetOptions();
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Gets or sets a value indicating whether [close existing connections].
         /// </summary>
@@ -682,10 +749,10 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         private string GetTargetDbFilePhysicalName(string sourceDbFilePhysicalLocation)
         {
             string fileName = Path.GetFileName(sourceDbFilePhysicalLocation);
-            if (!string.IsNullOrEmpty(this.DefaultDbName) && !string.IsNullOrEmpty(this.targetDbName))
+            if (!string.IsNullOrEmpty(this.DefaultSourceDbName) && !string.IsNullOrEmpty(this.targetDbName))
             {
                 string sourceFilename = fileName;
-                fileName = sourceFilename.Replace(this.DefaultDbName, this.targetDbName);
+                fileName = sourceFilename.Replace(this.DefaultSourceDbName, this.targetDbName);
             }
             return fileName;
         }
@@ -798,13 +865,8 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             bool isTailLogBackupWithNoRecoveryPossibleValue = isTailLogBackupPossibleValue;
         }
 
-        /// <summary>
+        public void CreateNewRestorePlan()
-        /// Updates restore plan
-        /// </summary>
-        public void UpdateRestorePlan()
         {
-
-            ResetOptions();
             this.ActiveException = null; //Clear any existing exceptions as the plan is getting recreated. 
                                          //Clear any existing exceptions as new plan is getting recreated.
             this.CreateOrUpdateRestorePlanException = null;
@@ -820,17 +882,14 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             {
                 this.RestorePlan = this.CreateRestorePlan(this.RestorePlanner, this.RestoreOptions);
                 this.Util.AddCredentialNameForUrlBackupSet(this.restorePlan, this.CredentialName);
-                RestoreOptionsHelper.UpdateOptionsInPlan(this);
+
                 if (this.ActiveException == null)
                 {
                     this.dbFiles = this.GetDbFiles();
-                    UpdateDBFilesPhysicalRelocate();
 
-                    if (RelocateAllFiles)
+                    UpdateDBFilesPhysicalRelocate();
-                    {
+                   
-                        UpdateDbFiles();
+
-                    }
-                    this.SetRestorePlanProperties(this.restorePlan);
                 }
             }
             if (this.restorePlan == null)
@@ -838,6 +897,26 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                 this.RestorePlan = new RestorePlan(this.Server);
                 this.Util.AddCredentialNameForUrlBackupSet(this.RestorePlan, this.CredentialName);
             }
+        }
+
+        public bool ShouldCreateNewPlan()
+        {
+            return string.Compare(RestorePlanner.DatabaseName, this.RestoreParams.GetOptionValue<string>(RestoreOptionsHelper.SourceDatabaseName), StringComparison.InvariantCultureIgnoreCase) != 0 ||
+                RestorePlanner.ReadHeaderFromMedia != this.RestoreParams.ReadHeaderFromMedia ||
+                string.Compare(this.backupMediaList, RestoreParams.BackupFilePaths, StringComparison.InvariantCultureIgnoreCase) != 0;
+        }
+
+        /// <summary>
+        /// Updates restore plan
+        /// </summary>
+        public void UpdateRestorePlan()
+        {
+            RestoreOptionsHelper.UpdateOptionsInPlan(this);
+            if (RelocateAllFiles)
+            {
+                UpdateDbFiles();
+            }
+            this.SetRestorePlanProperties(this.restorePlan);
 
             UpdateSelectedBackupSets();
         }
@@ -863,9 +942,9 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             }
             rp.SetRestoreOptions(this.RestoreOptions);
             rp.CloseExistingConnections = this.CloseExistingConnections;
-            if (this.TargetDatabase != null && !this.TargetDatabase.Equals(string.Empty))
+            if (this.TargetDatabaseName != null && !this.TargetDatabaseName.Equals(string.Empty))
             {
-                rp.DatabaseName = TargetDatabase;
+                rp.DatabaseName = TargetDatabaseName;
             }
             rp.RestoreOperations[0].RelocateFiles.Clear();
             foreach (DbFile dbFile in this.DbFiles)

src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreOptionFactory.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.SqlServer.Management.Smo;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Utility;
@@ -32,6 +33,13 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
             }
         }
 
+        public RestorePlanDetailInfo CreateAndValidate(string optionKey, IRestoreDatabaseTaskDataObject restoreDataObject)
+        {
+            RestorePlanDetailInfo restorePlanDetailInfo = CreateOptionInfo(optionKey, restoreDataObject);
+            UpdateOption(optionKey, restoreDataObject, restorePlanDetailInfo);
+            return restorePlanDetailInfo;
+        }
+
         /// <summary>
         /// Create option info using the current values
         /// </summary>
@@ -74,13 +82,24 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
         }
 
         /// <summary>
-        /// Set the option value if restore tak object using the values in the restore request
+        /// Set the option value in restore task object using the values in the restore request
+        /// </summary>
+        /// <param name="optionKey"></param>
+        /// <param name="restoreDataObject"></param>
+        public void SetAndValidate(string optionKey, IRestoreDatabaseTaskDataObject restoreDataObject)
+        {
+            this.SetValue(optionKey, restoreDataObject);
+            this.ValidateOption(optionKey, restoreDataObject);
+        }
+
+        /// <summary>
+        /// Set the option value in restore task object using the values in the restore request
         /// </summary>
         /// <param name="optionKey"></param>
         /// <param name="restoreDataObject"></param>
         public void SetValue(string optionKey, IRestoreDatabaseTaskDataObject restoreDataObject)
         {
-            if(restoreDataObject != null)
+            if (restoreDataObject != null)
             {
                 if (optionBuilders.ContainsKey(optionKey))
                 {
@@ -107,7 +126,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                             var defaultValue = builder.DefaultValueFunction(restoreDataObject);
                             builder.SetValueFunction(restoreDataObject, defaultValue);
                         }
-                        catch(Exception)
+                        catch (Exception)
                         {
                             Logger.Write(LogLevel.Warning, $"Failed to set restore option  {optionKey} to default value");
                         }
@@ -143,10 +162,15 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                         errorMessage = $"{optionKey} is ready only and cannot be modified";
                     }
                 }
+                if (!string.IsNullOrEmpty(result.ErrorMessage))
+                {
+                    errorMessage = result.ErrorMessage;
+                    builder.SetValueFunction(restoreDataObject, defaultValue);
+                }
             }
             else
             {
-                errorMessage = "cannot find restore option builder for {optionKey}";
+                errorMessage = $"cannot find restore option builder for {optionKey}";
                 Logger.Write(LogLevel.Warning, errorMessage);
             }
 
@@ -469,6 +493,64 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
                         return true;
                     }
                 });
+            Register(RestoreOptionsHelper.SourceDatabaseName,
+               new OptionBuilder
+               {
+                   DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
+                   {
+                       return restoreDataObject.DefaultSourceDbName;
+                   },
+                   CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
+                   {
+                       return restoreDataObject.SourceDatabaseName;
+                   },
+                   ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
+                   {
+                       string errorMessage = string.Empty;
+                       var sourceDbNames = restoreDataObject.SourceDbNames;
+                       if (currentValue == null || (sourceDbNames != null && 
+                            !sourceDbNames.Any(x => string.Compare(x, currentValue.ToString(), StringComparison.InvariantCultureIgnoreCase) == 0)))
+                       {
+                           errorMessage = "Source database name is not valid";
+                       }
+                       return new OptionValidationResult()
+                       {
+                          ErrorMessage = errorMessage
+                       };
+                   },
+                   SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
+                   {
+
+                       restoreDataObject.SourceDatabaseName = GetValueAs<string>(value);
+                       return true;
+                   }
+               });
+            Register(RestoreOptionsHelper.TargetDatabaseName,
+               new OptionBuilder
+               {
+                   DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
+                   {
+                       return restoreDataObject.CanChangeTargetDatabase ? restoreDataObject.DefaultSourceDbName : restoreDataObject.DefaultTargetDbName;
+                   },
+                   CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
+                   {
+                       return restoreDataObject.TargetDatabaseName;
+                   },
+                   ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
+                   {
+
+                       return new OptionValidationResult()
+                       {
+                           IsReadOnly = !restoreDataObject.CanChangeTargetDatabase
+                       };
+                   },
+                   SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
+                   {
+
+                       restoreDataObject.TargetDatabaseName = GetValueAs<string>(value);
+                       return true;
+                   }
+               });
         }
 
         internal T GetValueAs<T>(object value)

src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOptionsHelper.cs

@@ -15,7 +15,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
 {
     public class RestoreOptionsHelper
     {
-        //The list of name that service sends to client as options
+        //The list of names service uses to sends restore options to client
         private static string[] optionNames = new string[] { KeepReplication, ReplaceDatabase , SetRestrictedUser, RecoveryState ,
             BackupTailLog , TailLogBackupFile, TailLogWithNoRecovery, CloseExistingConnections, RelocateDbFiles, DataFileFolder, LogFileFolder,
             StandbyFile,
@@ -241,6 +241,8 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
 
             Dictionary<string, RestorePlanDetailInfo> options = new Dictionary<string, RestorePlanDetailInfo>();
             RestoreOptionFactory restoreOptionFactory = RestoreOptionFactory.Instance;
+
+            //Create the options using the current values
             foreach (var optionKey in optionNames)
             {
                 var optionInfo = restoreOptionFactory.CreateOptionInfo(optionKey, restoreDataObject);
@@ -248,6 +250,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
             }
 
             // After all options are set verify them all again to set the read only 
+            // Because some options can change the readonly mode of other options.( e.g Recovery state can affect StandBy to be readyonly)
             foreach (var optionKey in optionNames)
             {
                 restoreOptionFactory.UpdateOption(optionKey, restoreDataObject, options[optionKey]);
@@ -292,7 +295,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
                 string error = restoreOptionFactory.ValidateOption(optionKey, restoreDataObject);
                 if (!string.IsNullOrEmpty(error))
                 {
-                    //TODO: we could send back the error message so client knows the option is set incorrectly 
+                    //TODO: we could send back the error message so client knows the option is set incorrectly
                 }
             }
             

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

@@ -41,5 +41,16 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
         public string DefaultStandbyFile { get; set; }
 
         public string DefaultTailLogbackupFile { get; set; }
+
+        public string DefaultSourceDbName { get; set; }
+        public string SourceDatabaseName { get; set; }
+
+        public List<string> SourceDbNames { get; set; }
+
+        public bool CanChangeTargetDatabase { get; set; }
+
+        public string DefaultTargetDbName { get; set; }
+
+        public string TargetDatabaseName { get; set; }
     }
 }

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

@@ -3,14 +3,12 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using System;
 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
@@ -33,14 +31,73 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
         {
             GeneralRequestDetails optionValues = CreateOptionsTestData();
             optionValues.Options["DbFiles"] = new List<DbFile>();
+            optionValues.Options[RestoreOptionsHelper.RelocateDbFiles] = true;
             IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
 
             Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
             Assert.NotNull(result);
-            VerifyOptions(result, optionValues);
             Assert.True(result[RestoreOptionsHelper.RelocateDbFiles].IsReadOnly);
         }
 
+        [Fact]
+        public void DataFileFolderShouldBeReadOnlyGivenRelocateAllFilesSetToFalse()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options["DbFiles"] = new List<DbFile>() { new DbFile("", '1', "") };
+            optionValues.Options[RestoreOptionsHelper.RelocateDbFiles] = false;
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
+            Assert.NotNull(result);
+            Assert.True(result[RestoreOptionsHelper.DataFileFolder].IsReadOnly);
+            Assert.True(result[RestoreOptionsHelper.LogFileFolder].IsReadOnly);
+        }
+
+        [Fact]
+        public void DataFileFolderShouldBeCurrentValueGivenRelocateAllFilesSetToTrue()
+        {
+            string dataFile = "data files";
+            string logFile = "log files";
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options["DbFiles"] = new List<DbFile>() { new DbFile("", '1', "") };
+            optionValues.Options[RestoreOptionsHelper.RelocateDbFiles] = true;
+            optionValues.Options[RestoreOptionsHelper.DataFileFolder] = dataFile;
+            optionValues.Options[RestoreOptionsHelper.LogFileFolder] = logFile;
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
+            Assert.NotNull(result);
+            Assert.False(result[RestoreOptionsHelper.DataFileFolder].IsReadOnly);
+            Assert.False(result[RestoreOptionsHelper.LogFileFolder].IsReadOnly);
+            Assert.Equal(result[RestoreOptionsHelper.DataFileFolder].CurrentValue, dataFile);
+            Assert.Equal(result[RestoreOptionsHelper.LogFileFolder].CurrentValue, logFile);
+        }
+
+
+        [Fact]
+        public void KeepReplicationShouldBeReadOnlyGivenRecoveryStateWithNoRecovery()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithNoRecovery;
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
+            Assert.NotNull(result);
+            Assert.True(result[RestoreOptionsHelper.KeepReplication].IsReadOnly);
+        }
+
+        [Fact]
+        public void StandbyFileShouldBeReadOnlyGivenRecoveryStateNotWithStandBy()
+        {
+            GeneralRequestDetails optionValues = CreateOptionsTestData();
+            optionValues.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithNoRecovery;
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(optionValues);
+
+            Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
+            Assert.NotNull(result);
+            Assert.True(result[RestoreOptionsHelper.StandbyFile].IsReadOnly);
+        }
+
         [Fact]
         public void BackupTailLogShouldBeReadOnlyTailLogBackupNotPossible()
         {
@@ -50,7 +107,6 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 
             Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
             Assert.NotNull(result);
-            VerifyOptions(result, optionValues);
             Assert.True(result[RestoreOptionsHelper.BackupTailLog].IsReadOnly);
             Assert.True(result[RestoreOptionsHelper.TailLogBackupFile].IsReadOnly);
         }
@@ -64,7 +120,6 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 
             Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
             Assert.NotNull(result);
-            VerifyOptions(result, optionValues);
             Assert.True(result[RestoreOptionsHelper.TailLogWithNoRecovery].IsReadOnly);
         }
 
@@ -77,7 +132,6 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 
             Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
             Assert.NotNull(result);
-            VerifyOptions(result, optionValues);
             Assert.False(result[RestoreOptionsHelper.StandbyFile].IsReadOnly);
         }
 
@@ -90,7 +144,6 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 
             Dictionary<string, RestorePlanDetailInfo> result = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
             Assert.NotNull(result);
-            VerifyOptions(result, optionValues);
             Assert.True(result[RestoreOptionsHelper.KeepReplication].IsReadOnly);
         }
 
@@ -130,6 +183,82 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
 
         }
 
+        [Fact]
+        public void SourceDatabaseNameShouldSetToDefaultIfNotValid()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+            string defaultDbName = "default";
+            string currentDbName = "db3";
+            restoreParams.Options["SourceDbNames"] = new List<string> { "db1", "db2" };
+            restoreParams.Options["DefaultSourceDbName"] = defaultDbName;
+            restoreParams.Options[RestoreOptionsHelper.SourceDatabaseName] = currentDbName;
+
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+            
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDatabaseTaskDataObject);
+
+            string actual = restoreDatabaseTaskDataObject.SourceDatabaseName;
+            string expected = defaultDbName;
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void SourceDatabaseNameShouldStayTheSameIfValid()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+            string defaultDbName = "default";
+            string currentDbName = "db3";
+            restoreParams.Options["SourceDbNames"] = new List<string> { "db1", "db2", "db3" };
+            restoreParams.Options["DefaultSourceDbName"] = defaultDbName;
+            restoreParams.Options[RestoreOptionsHelper.SourceDatabaseName] = currentDbName;
+
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDatabaseTaskDataObject);
+
+            string actual = restoreDatabaseTaskDataObject.SourceDatabaseName;
+            string expected = currentDbName;
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TargetDatabaseNameShouldSetToDefaultIfNotValid()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+            string defaultDbName = "default";
+            string currentDbName = "db3";
+            restoreParams.Options["DefaultTargetDbName"] = defaultDbName;
+            restoreParams.Options[RestoreOptionsHelper.TargetDatabaseName] = currentDbName;
+            restoreParams.Options["CanChangeTargetDatabase"] = false;
+
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDatabaseTaskDataObject);
+
+            string actual = restoreDatabaseTaskDataObject.TargetDatabaseName;
+            string expected = defaultDbName;
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TargetDatabaseNameShouldStayTheSameIfValid()
+        {
+            RestoreParams restoreParams = CreateOptionsTestData();
+            string defaultDbName = "default";
+            string currentDbName = "db3";
+            restoreParams.Options["DefaultTargetDbName"] = defaultDbName;
+            restoreParams.Options[RestoreOptionsHelper.TargetDatabaseName] = currentDbName;
+            restoreParams.Options["CanChangeTargetDatabase"] = true;
+
+            IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
+
+            RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDatabaseTaskDataObject);
+
+            string actual = restoreDatabaseTaskDataObject.TargetDatabaseName;
+            string expected = currentDbName;
+            Assert.Equal(actual, expected);
+        }
+
 
         private RestoreParams CreateOptionsTestData()
         {
@@ -143,16 +272,22 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             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(RestoreOptionsHelper.LogFileFolder, "Log file folder");
-            optionValues.Options.Add("RelocateAllFiles", false);
+            optionValues.Options.Add(RestoreOptionsHelper.RelocateDbFiles, true);
             optionValues.Options.Add("TailLogBackupFile", "tail log backup file");
             optionValues.Options.Add("TailLogWithNoRecovery", false);
-            optionValues.Options.Add("BackupTailLog", false);
+            optionValues.Options.Add(RestoreOptionsHelper.BackupTailLog, false);
             optionValues.Options.Add(RestoreOptionsHelper.KeepReplication, false);
-            optionValues.Options.Add("ReplaceDatabase", false);
+            optionValues.Options.Add(RestoreOptionsHelper.ReplaceDatabase, false);
-            optionValues.Options.Add("SetRestrictedUser", false);
+            optionValues.Options.Add(RestoreOptionsHelper.SetRestrictedUser, false);
-            optionValues.Options.Add("StandbyFile", "Stand by file");
+            optionValues.Options.Add(RestoreOptionsHelper.StandbyFile, "Stand by file");
             optionValues.Options.Add(RestoreOptionsHelper.RecoveryState, DatabaseRecoveryState.WithNoRecovery.ToString());
+            optionValues.Options.Add(RestoreOptionsHelper.TargetDatabaseName, "target db name");
+            optionValues.Options.Add(RestoreOptionsHelper.SourceDatabaseName, "source db name");
+            optionValues.Options.Add("CanChangeTargetDatabase", true);
+            optionValues.Options.Add("DefaultSourceDbName", "DefaultSourceDbName");
+            optionValues.Options.Add("DefaultTargetDbName", "DefaultTargetDbName");
+            optionValues.Options.Add("SourceDbNames", new List<string>());
             return optionValues;
         }
 
@@ -168,18 +303,24 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             restoreDataObject.IsTailLogBackupWithNoRecoveryPossible = optionValues.GetOptionValue<bool>("IsTailLogBackupWithNoRecoveryPossible");
             restoreDataObject.DefaultStandbyFile = optionValues.GetOptionValue<string>("GetDefaultStandbyFile");
             restoreDataObject.DefaultTailLogbackupFile = optionValues.GetOptionValue<string>("GetDefaultTailLogbackupFile");
-            restoreDataObject.LogFilesFolder = optionValues.GetOptionValue<string>("LogFilesFolder");
+            restoreDataObject.LogFilesFolder = optionValues.GetOptionValue<string>(RestoreOptionsHelper.LogFileFolder);
-            restoreDataObject.RelocateAllFiles = optionValues.GetOptionValue<bool>("RelocateAllFiles");
+            restoreDataObject.RelocateAllFiles = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles);
             restoreDataObject.TailLogBackupFile = optionValues.GetOptionValue<string>("TailLogBackupFile");
+            restoreDataObject.SourceDatabaseName = optionValues.GetOptionValue<string>(RestoreOptionsHelper.SourceDatabaseName);
+            restoreDataObject.TargetDatabaseName = optionValues.GetOptionValue<string>(RestoreOptionsHelper.TargetDatabaseName);
             restoreDataObject.TailLogWithNoRecovery = optionValues.GetOptionValue<bool>("TailLogWithNoRecovery");
-            restoreDataObject.BackupTailLog = optionValues.GetOptionValue<bool>("BackupTailLog");
+            restoreDataObject.CanChangeTargetDatabase = optionValues.GetOptionValue<bool>("CanChangeTargetDatabase");
+            restoreDataObject.DefaultSourceDbName = optionValues.GetOptionValue<string>("DefaultSourceDbName");
+            restoreDataObject.SourceDbNames = optionValues.GetOptionValue<List<string>>("SourceDbNames");
+            restoreDataObject.DefaultTargetDbName = optionValues.GetOptionValue<string>("DefaultTargetDbName");
+            restoreDataObject.BackupTailLog = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.BackupTailLog);
             restoreDataObject.RestoreParams = optionValues as RestoreParams;
             restoreDataObject.RestorePlan = null;
             RestoreOptions restoreOptions = new RestoreOptions();
             restoreOptions.KeepReplication = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.KeepReplication);
-            restoreOptions.ReplaceDatabase = optionValues.GetOptionValue<bool>("ReplaceDatabase");
+            restoreOptions.ReplaceDatabase = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.ReplaceDatabase);
-            restoreOptions.SetRestrictedUser = optionValues.GetOptionValue<bool>("SetRestrictedUser");
+            restoreOptions.SetRestrictedUser = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.SetRestrictedUser);
-            restoreOptions.StandByFile = optionValues.GetOptionValue<string>("StandbyFile");
+            restoreOptions.StandByFile = optionValues.GetOptionValue<string>(RestoreOptionsHelper.StandbyFile);
             restoreOptions.RecoveryState = optionValues.GetOptionValue<DatabaseRecoveryState>(RestoreOptionsHelper.RecoveryState);
             restoreDataObject.RestoreOptions = restoreOptions;
 
@@ -191,29 +332,29 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
         {
             RestorePlanDetailInfo planDetailInfo = optionInResponse[RestoreOptionsHelper.DataFileFolder];
             Assert.Equal(planDetailInfo.Name, RestoreOptionsHelper.DataFileFolder);
-            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>("RelocateAllFiles"));
+            Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles));
             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.IsReadOnly, !optionValues.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles));
-            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>("LogFilesFolder"));
+            Assert.Equal(planDetailInfo.CurrentValue, optionValues.GetOptionValue<string>(RestoreOptionsHelper.LogFileFolder));
             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.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles));
             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.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.ReplaceDatabase));
             Assert.Equal(planDetailInfo.DefaultValue, false);
             Assert.Equal(planDetailInfo.IsVisiable, true);
 
@@ -227,7 +368,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             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.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.SetRestrictedUser));
             Assert.Equal(planDetailInfo.DefaultValue, false);
             Assert.Equal(planDetailInfo.IsVisiable, true);
 
@@ -241,14 +382,14 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             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.CurrentValue, optionValues.GetOptionValue<string>(RestoreOptionsHelper.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.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.BackupTailLog));
             Assert.Equal(planDetailInfo.DefaultValue, optionValues.GetOptionValue<bool>("IsTailLogBackupPossible"));
             Assert.Equal(planDetailInfo.IsVisiable, true);
 
@@ -271,7 +412,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.DisasterRecovery
             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.CurrentValue, optionValues.GetOptionValue<bool>(RestoreOptionsHelper.CloseExistingConnections));
             Assert.Equal(planDetailInfo.DefaultValue, false);
             Assert.Equal(planDetailInfo.IsVisiable, true);
         }