ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* fixed the bug with source db name not setting correctly when new plan created
This commit is contained in:
Leila Lali
2017-08-16 08:54:05 -07:00
committed by GitHub
parent d6c6700a3a
commit f95a652174
6 changed files with 390 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreDatabaseHelper.cs
View File

@@ -171,14 +171,13 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery.RestoreOperation
if (restoreDataObject != null && restoreDataObject.IsValid)
{
response.SessionId = restoreDataObject.SessionId;
response.DatabaseName = restoreDataObject.TargetDatabase;
response.PlanDetails.Add(RestoreOptionsHelper.TargetDatabaseName, RestorePlanDetailInfo.Create(
name: RestoreOptionsHelper.TargetDatabaseName,
currentValue: restoreDataObject.TargetDatabase,
isReadOnly: !CanChangeTargetDatabase(restoreDataObject)));
response.PlanDetails.Add(RestoreOptionsHelper.SourceDatabaseName, RestorePlanDetailInfo.Create(
name: RestoreOptionsHelper.SourceDatabaseName,
currentValue: restoreDataObject.RestorePlanner.DatabaseName));
response.DatabaseName = restoreDataObject.TargetDatabaseName;
response.PlanDetails.Add(RestoreOptionsHelper.TargetDatabaseName,
RestoreOptionFactory.Instance.CreateAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDataObject));
response.PlanDetails.Add(RestoreOptionsHelper.SourceDatabaseName,
RestoreOptionFactory.Instance.CreateAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDataObject));
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))
{
restoreDataObject.RestorePlanner.DatabaseName = restoreDataObject.DefaultDbName;
}
else
{
restoreDataObject.RestorePlanner.DatabaseName = restoreDataObject.RestoreParams.SourceDatabaseName;
}
RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.SourceDatabaseName, restoreDataObject);
RestoreOptionFactory.Instance.SetAndValidate(RestoreOptionsHelper.TargetDatabaseName, restoreDataObject);
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)

125
src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreDatabaseTaskDataObject.cs
View File

@@ -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>
/// Updates restore plan
/// </summary>
public void UpdateRestorePlan()
public void CreateNewRestorePlan()
{
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)
{
UpdateDbFiles();
}
this.SetRestorePlanProperties(this.restorePlan);
UpdateDBFilesPhysicalRelocate();
}
}
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)

90
src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreOptionFactory.cs
View File

@@ -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)

7
src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOptionsHelper.cs
View File

@@ -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
}
}

11
test/Microsoft.SqlTools.ServiceLayer.UnitTests/DisasterRecovery/RestoreDatabaseTaskDataObjectStub.cs
View File

@@ -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; }
}
}

197
test/Microsoft.SqlTools.ServiceLayer.UnitTests/DisasterRecovery/RestoreOptionsHelperTests.cs
View File

@@ -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("RelocateAllFiles", false);
optionValues.Options.Add(RestoreOptionsHelper.LogFileFolder, "Log file folder");
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("SetRestrictedUser", false);
optionValues.Options.Add("StandbyFile", "Stand by file");
optionValues.Options.Add(RestoreOptionsHelper.ReplaceDatabase, false);
optionValues.Options.Add(RestoreOptionsHelper.SetRestrictedUser, false);
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.RelocateAllFiles = optionValues.GetOptionValue<bool>("RelocateAllFiles");
restoreDataObject.LogFilesFolder = optionValues.GetOptionValue<string>(RestoreOptionsHelper.LogFileFolder);
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.SetRestrictedUser = optionValues.GetOptionValue<bool>("SetRestrictedUser");
restoreOptions.StandByFile = optionValues.GetOptionValue<string>("StandbyFile");
restoreOptions.ReplaceDatabase = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.ReplaceDatabase);
restoreOptions.SetRestrictedUser = optionValues.GetOptionValue<bool>(RestoreOptionsHelper.SetRestrictedUser);
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.CurrentValue, optionValues.GetOptionValue<string>("LogFilesFolder"));
Assert.Equal(planDetailInfo.IsReadOnly, !optionValues.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles));
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);
}