public void KeepReplicationShouldSetToDefaultValueGivenRecoveryStateWithNoRecovery()
{
RestoreParams restoreParams = CreateOptionsTestData();
restoreParams.Options[RestoreOptionsHelper.RecoveryState] = DatabaseRecoveryState.WithNoRecovery;
IRestoreDatabaseTaskDataObject restoreDatabaseTaskDataObject = CreateRestoreDatabaseTaskDataObject(restoreParams);
Dictionary <string, RestorePlanDetailInfo> options = RestoreOptionsHelper.CreateRestorePlanOptions(restoreDatabaseTaskDataObject);
restoreParams.Options[RestoreOptionsHelper.KeepReplication] = true;
RestoreOptionsHelper.UpdateOptionsInPlan(restoreDatabaseTaskDataObject);
bool actual = restoreDatabaseTaskDataObject.RestoreOptions.KeepReplication;
bool expected = (bool)options[RestoreOptionsHelper.KeepReplication].DefaultValue;
Assert.Equal(actual, expected);
}
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);
}
private RestorePlanDetailInfo Create(
string optionKey,
IRestoreDatabaseTaskDataObject restoreDataObject,
OptionBuilder optionBuilder)
{
object currnetValue = optionBuilder.CurrentValueFunction(restoreDataObject);
object defaultValue = optionBuilder.DefaultValueFunction(restoreDataObject);
OptionValidationResult validationResult = optionBuilder.ValidateFunction(restoreDataObject, currnetValue, defaultValue);
return(new RestorePlanDetailInfo
{
Name = optionKey,
CurrentValue = currnetValue,
DefaultValue = defaultValue,
IsReadOnly = validationResult.IsReadOnly,
IsVisiable = validationResult.IsVisible,
ErrorMessage = validationResult.ErrorMessage
});
}
public void TargetDatabaseNameShouldBeWhatIsRequested2()
{
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);
}
/// <summary>
/// Load options in restore plan
/// </summary>
internal static void UpdateOptionsInPlan(IRestoreDatabaseTaskDataObject restoreDataObject)
{
RestoreOptionFactory restoreOptionFactory = RestoreOptionFactory.Instance;
foreach (var optionKey in optionNames)
{
restoreOptionFactory.SetValue(optionKey, restoreDataObject);
}
//After all options are set do a vaidation so any invalid option set to default
foreach (var optionKey in optionNames)
{
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
}
}
}
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);
}
/// <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 (optionBuilders.ContainsKey(optionKey))
{
var builder = optionBuilders[optionKey];
if (restoreDataObject.RestoreParams != null && restoreDataObject.RestoreParams.Options.ContainsKey(optionKey))
{
try
{
var value = restoreDataObject.RestoreParams.GetOptionValue <object>(optionKey);
builder.SetValueFunction(restoreDataObject, value);
}
catch (Exception ex)
{
var defaultValue = builder.DefaultValueFunction(restoreDataObject);
builder.SetValueFunction(restoreDataObject, defaultValue);
Logger.Write(LogLevel.Warning, $"Failed tp set restore option {optionKey} error:{ex.Message}");
}
}
else
{
try
{
var defaultValue = builder.DefaultValueFunction(restoreDataObject);
builder.SetValueFunction(restoreDataObject, defaultValue);
}
catch (Exception)
{
Logger.Write(LogLevel.Warning, $"Failed to set restore option {optionKey} to default value");
}
}
}
else
{
Logger.Write(LogLevel.Warning, $"cannot find restore option builder for {optionKey}");
}
}
}
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);
}
/// <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 SetAndValidate(string optionKey, IRestoreDatabaseTaskDataObject restoreDataObject)
{
this.SetValue(optionKey, restoreDataObject);
this.ValidateOption(optionKey, restoreDataObject);
}
internal static Dictionary <string, RestorePlanDetailInfo> CreateRestorePlanOptions(IRestoreDatabaseTaskDataObject restoreDataObject)
{
Validate.IsNotNull(nameof(restoreDataObject), restoreDataObject);
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);
options.Add(optionKey, optionInfo);
}
// 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]);
}
return(options);
}
