public void TestWriteEmptyString_String()
{
RemoveSettings();
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "Test1";
values[LocalMixedScopeSettings.PropertyApp2] = "Test2";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("Test2", values[LocalMixedScopeSettings.PropertyApp2]);
values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "";
values[LocalMixedScopeSettings.PropertyApp2] = "";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("", values[LocalMixedScopeSettings.PropertyApp2]);
//For string values, empty string means empty string.
var settings = (LocalMixedScopeSettings)ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
Assert.AreEqual("", settings.App1);
Assert.AreEqual("", settings.App2);
}
private void TestWriteNull_String(Type settingsClass)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "Test1";
values[MixedScopeSettingsBase.PropertyApp2] = "Test2";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("Test2", values[MixedScopeSettingsBase.PropertyApp2]);
values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = null;
values[MixedScopeSettingsBase.PropertyApp2] = null;
//writing null essentially means to reset it to the default, which is equivalent to removing it.
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
var settings = (MixedScopeSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp1, settings.App1);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp2, settings.App2);
}
private static void TestLocalSharedSettingsMigration(Type mixedScopeSettingsClass)
{
if (!mixedScopeSettingsClass.IsSubclassOf(typeof(MixedScopeSettingsBase)))
{
throw new ArgumentException();
}
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = CreateSettingsValues(mixedScopeSettingsClass, MigrationScope.Shared, SettingValue.Current);
configuration.PutSettingsValues(mixedScopeSettingsClass, values);
string directory = Path.GetDirectoryName(configuration.FilePath);
string previousExeFilename = String.Format("{0}{1}Previous.exe.config", directory, Path.DirectorySeparatorChar);
try
{
TestConfigResourceToFile(previousExeFilename);
ValidateLocalMixedScopeSettingsValuesInConfig(mixedScopeSettingsClass, configuration, SettingValue.Current);
SettingsMigrator.MigrateSharedSettings(mixedScopeSettingsClass, previousExeFilename);
configuration = SystemConfigurationHelper.GetExeConfiguration();
ValidateLocalMixedScopeSettingsValuesInConfig(mixedScopeSettingsClass, configuration, SettingValue.Previous);
}
finally
{
File.Delete(previousExeFilename);
configuration.RemoveSettingsValues(mixedScopeSettingsClass);
}
}
public void TestWriteEmptyString_Xml()
{
Type settingsClass = typeof(LocalXmlSettings);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
try
{
var values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettings.PropertyApp] = "";
SystemConfigurationHelper.PutSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(1, values.Count);
Assert.AreEqual("", values[LocalXmlSettings.PropertyApp]);
//For xml values, empty string means "default".
LocalXmlSettings settings = (LocalXmlSettings)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettings.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
}
public void TestReadStringSettings()
{
Type settingsClass = typeof(LocalMixedScopeSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyApp1, "TestApp1");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyApp2, "TestApp2");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyUser1, "TestUser1");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyUser2, "TestUser2");
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestApp1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("TestApp2", values[LocalMixedScopeSettings.PropertyApp2]);
path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestUser1", values[LocalMixedScopeSettings.PropertyUser1]);
Assert.AreEqual("TestUser2", values[LocalMixedScopeSettings.PropertyUser2]);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
public void TestLocalSharedSettingsMigration()
{
Type settingsClass = typeof(LocalMixedScopeSettings);
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = CreateSettingsValues(settingsClass, MigrationScope.Shared, SettingValue.Current);
SystemConfigurationHelper.PutSettingsValues(configuration, settingsClass, values);
string directory = Path.GetDirectoryName(configuration.FilePath);
string previousExeFilename = String.Format("{0}{1}Previous.exe.config", directory, Path.DirectorySeparatorChar);
try
{
TestConfigResourceToFile(previousExeFilename);
ValidateLocalMixedScopeSettingsValuesInConfig(configuration, SettingValue.Current);
SettingsMigrator.MigrateSharedSettings(settingsClass, previousExeFilename);
configuration = SystemConfigurationHelper.GetExeConfiguration();
ValidateLocalMixedScopeSettingsValuesInConfig(configuration, SettingValue.Previous);
}
finally
{
File.Delete(previousExeFilename);
SystemConfigurationHelper.RemoveSettingsValues(configuration, settingsClass);
}
}
public void TestRepeatedWritesDifferentProperties()
{
RemoveSettings();
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var expectedValue1 = CreateSettingValue(LocalMixedScopeSettings.PropertyApp1, SettingValue.Current);
var expectedValue2 = CreateSettingValue(LocalMixedScopeSettings.PropertyApp2, SettingValue.Current);
var values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = expectedValue1;
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(configuration, _settingsClass);
Assert.AreEqual(1, values.Count);
Assert.AreEqual(expectedValue1, values[LocalMixedScopeSettings.PropertyApp1]);
values.Clear();
values[LocalMixedScopeSettings.PropertyApp2] = expectedValue2;
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(configuration, _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual(expectedValue1, values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual(expectedValue2, values[LocalMixedScopeSettings.PropertyApp2]);
}
public void TestReadStringSettings(Type localSettingsClass)
{
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(localSettingsClass);
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp1, "TestApp1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp2, "TestApp2");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser1, "TestUser1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser2, "TestUser2");
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(localSettingsClass, SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestApp1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("TestApp2", values[MixedScopeSettingsBase.PropertyApp2]);
path = new ConfigurationSectionPath(localSettingsClass, SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestUser1", values[MixedScopeSettingsBase.PropertyUser1]);
Assert.AreEqual("TestUser2", values[MixedScopeSettingsBase.PropertyUser2]);
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(localSettingsClass);
}
internal static void WriteSharedValuesToConfig(Type type, SettingValue settingValue)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = CreateSettingsValues(type, MigrationScope.Shared, settingValue);
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
}
private void ValidateValuesInConfig(MigrationScope migrationScope, SettingValue settingValue)
{
var configuration = GetExeConfiguration();
var values = SystemConfigurationHelper.GetSettingsValues(configuration, _settingsClass);
ValidateValues(values, migrationScope, settingValue);
}
public void TestReadWriteValues_Xml()
{
Type settingsClass = typeof(LocalXmlSettings);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
try
{
var values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettings.PropertyUser] = LocalXmlSettings.DefaultValueUser;
values[LocalXmlSettings.PropertyApp] = LocalXmlSettings.DefaultValueApp;
SystemConfigurationHelper.PutSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(1, values.Count);
LocalXmlSettings settings = (LocalXmlSettings)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.IsNull(ApplicationSettingsExtensions.GetSharedPropertyValue(settings, LocalXmlSettings.PropertyUser));
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettings.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
}
private void TestWriteNull_Xml(Type settingsClass)
{
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(settingsClass);
try
{
var values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettingsBase.PropertyApp] = null;
SystemConfigurationHelper.GetExeConfiguration().PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
LocalXmlSettingsBase settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettingsBase.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(settingsClass);
}
}
public void TestWriteNull_String()
{
RemoveSettings();
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "Test1";
values[LocalMixedScopeSettings.PropertyApp2] = "Test2";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("Test2", values[LocalMixedScopeSettings.PropertyApp2]);
values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = null;
values[LocalMixedScopeSettings.PropertyApp2] = null;
//writing null essentially means to reset it to the default, which is equivalent to removing it.
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(0, values.Count);
var settings = (LocalMixedScopeSettings)ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
Assert.AreEqual(LocalMixedScopeSettings.PropertyApp1, settings.App1);
Assert.AreEqual(LocalMixedScopeSettings.PropertyApp2, settings.App2);
}
private void TestWriteEmptyString_String(Type settingsClass)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "Test1";
values[MixedScopeSettingsBase.PropertyApp2] = "Test2";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("Test2", values[MixedScopeSettingsBase.PropertyApp2]);
values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "";
values[MixedScopeSettingsBase.PropertyApp2] = "";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("", values[MixedScopeSettingsBase.PropertyApp2]);
//For string values, empty string means empty string.
var settings = (MixedScopeSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual("", settings.App1);
Assert.AreEqual("", settings.App2);
}
/// <summary>
/// Stores the settings values (both application and user scoped) for a given settings class. Only the shared profile
/// is supported (application settings + default user settings).
/// </summary>
/// <param name="group">the settings class for which to store the values</param>
/// <param name="user">must be null or ""</param>
/// <param name="instanceKey">must be null or ""</param>
/// <param name="dirtyValues">contains the values to be stored</param>
/// <exception cref="NotSupportedException">will be thrown if the user or instance key is specified</exception>
public void PutSettingsValues(SettingsGroupDescriptor group, string user, string instanceKey, Dictionary <string, string> dirtyValues)
{
CheckUser(user);
CheckInstanceKey(instanceKey);
Type type = Type.GetType(group.AssemblyQualifiedTypeName, true);
SystemConfigurationHelper.PutSettingsValues(_configuration, type, dirtyValues);
}
private void ValidateLocalMixedScopeSettingsValuesInConfig(System.Configuration.Configuration configuration, SettingValue settingValue)
{
Type settingsClass = typeof(LocalMixedScopeSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
settings.Reload();
SettingsProperty property = settings.Properties[LocalMixedScopeSettings.PropertyApp1];
string expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
string actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
var values = SystemConfigurationHelper.GetSettingsValues(configuration, settingsClass, SettingScope.Application);
Assert.AreEqual(2, values.Count);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
values = SystemConfigurationHelper.GetSettingsValues(configuration, settingsClass, SettingScope.User);
Assert.AreEqual(2, values.Count);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Loads the settings values (both application and user scoped) for a given settings class. Only the shared profile
/// is supported (application settings + default user settings).
/// </summary>
/// <param name="group">the settings class for which to retrieve the defaults</param>
/// <param name="user">must be null or ""</param>
/// <param name="instanceKey">must be null or ""</param>
/// <returns>returns only those values that are different from the property defaults</returns>
/// <exception cref="NotSupportedException">will be thrown if the user or instance key is specified</exception>
public Dictionary <string, string> GetSettingsValues(SettingsGroupDescriptor group, string user, string instanceKey)
{
CheckUser(user);
CheckInstanceKey(instanceKey);
Type type = Type.GetType(group.AssemblyQualifiedTypeName, true);
return(SystemConfigurationHelper.GetSettingsValues(_configuration, type));
}
private static void TestReadNoSettings(Type localSettingsClass)
{
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(localSettingsClass);
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(localSettingsClass, SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(0, values.Count);
path = new ConfigurationSectionPath(localSettingsClass, SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(0, values.Count);
}
public void TestReadNoSettings()
{
Type settingsClass = typeof(LocalMixedScopeSettings);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(0, values.Count);
path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(0, values.Count);
}
private static void TestMigrateXmlSettings(Type xmlSettingsClass)
{
if (!xmlSettingsClass.IsSubclassOf(typeof(LocalXmlSettingsBase)))
{
throw new ArgumentException();
}
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(xmlSettingsClass);
var document = new XmlDocument();
document.LoadXml((string)settings.Properties[LocalXmlSettingsBase.PropertyApp].DefaultValue);
var node = document.SelectSingleNode("//test");
node.InnerText = "CurrentApp";
var values = new Dictionary <string, string>();
values[LocalXmlSettingsBase.PropertyApp] = document.InnerXml;
configuration.PutSettingsValues(xmlSettingsClass, values);
string directory = Path.GetDirectoryName(configuration.FilePath);
string previousExeFilename = String.Format("{0}{1}Previous.exe.config", directory, Path.DirectorySeparatorChar);
try
{
TestConfigResourceToFile(previousExeFilename);
SettingsMigrator.MigrateSharedSettings(xmlSettingsClass, previousExeFilename);
configuration = SystemConfigurationHelper.GetExeConfiguration();
settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(xmlSettingsClass);
settings.Reload();
document = (XmlDocument)settings.GetSharedPropertyValue(LocalXmlSettingsBase.PropertyApp);
Assert.AreEqual("PreviousApp", document.SelectSingleNode("//test").InnerXml);
document = settings.App;
Assert.AreEqual("PreviousApp", document.SelectSingleNode("//test").InnerXml);
}
finally
{
File.Delete(previousExeFilename);
configuration.RemoveSettingsValues(xmlSettingsClass);
}
}
public static void MigrateAll(string previousExeConfigFilename)
{
IsMigrating = true;
try
{
Configuration previousConfiguration = SystemConfigurationHelper.GetExeConfiguration(previousExeConfigFilename);
Configuration currentConfiguration = SystemConfigurationHelper.GetExeConfiguration();
var legacySections = new List <IMigrateLegacyShredConfigSection>();
foreach (var sectionEntry in GetConfigurationSections(previousConfiguration, (p, k) => HandleLegacyConfigurationSection(previousExeConfigFilename, p, k)))
{
// don't migrate legacy sections with the shred settings migration handler
if (sectionEntry.Section is IMigrateLegacyShredConfigSection)
{
legacySections.Add((IMigrateLegacyShredConfigSection)sectionEntry.Section);
continue;
}
if (IsShredSettingsClass(sectionEntry.Section))
{
MigrateSection(sectionEntry.Section, sectionEntry.ParentPath, currentConfiguration);
}
}
currentConfiguration.Save(ConfigurationSaveMode.Full);
// migrate all legacy sections
foreach (var legacySection in legacySections)
{
legacySection.Migrate();
}
}
finally
{
IsMigrating = false;
}
}
public void TestReadXmlSettings()
{
Type settingsClass = typeof(LocalXmlSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
var appValue = @"<test><app/></test>";
XmlDocument appDocument = new XmlDocument();
appDocument.LoadXml(appValue);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalXmlSettings.PropertyApp, appDocument);
var userValue = @"<test><user/></test>";
XmlDocument userDocument = new XmlDocument();
userDocument.LoadXml(userValue);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalXmlSettings.PropertyUser, userDocument);
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(typeof(LocalXmlSettings), SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(1, values.Count);
XmlDocument testDocument = new XmlDocument();
testDocument.LoadXml(values[LocalXmlSettings.PropertyApp]);
Assert.AreEqual(appDocument.InnerXml, testDocument.InnerXml);
path = new ConfigurationSectionPath(typeof(LocalXmlSettings), SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(1, values.Count);
testDocument = new XmlDocument();
testDocument.LoadXml(values[LocalXmlSettings.PropertyUser]);
Assert.AreEqual(userDocument.InnerXml, testDocument.InnerXml);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
private void TestRepeatedWritesDifferentProperties(Type settingsClass)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var expectedValue1 = CreateSettingValue(MixedScopeSettingsBase.PropertyApp1, SettingValue.Current);
var expectedValue2 = CreateSettingValue(MixedScopeSettingsBase.PropertyApp2, SettingValue.Current);
var values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = expectedValue1;
configuration.PutSettingsValues(settingsClass, values);
values = configuration.GetSettingsValues(settingsClass);
Assert.AreEqual(1, values.Count);
Assert.AreEqual(expectedValue1, values[MixedScopeSettingsBase.PropertyApp1]);
values.Clear();
values[MixedScopeSettingsBase.PropertyApp2] = expectedValue2;
configuration.PutSettingsValues(settingsClass, values);
values = configuration.GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual(expectedValue1, values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual(expectedValue2, values[MixedScopeSettingsBase.PropertyApp2]);
}
private static System.Configuration.Configuration GetExeConfiguration()
{
return(SystemConfigurationHelper.GetExeConfiguration());
}
public void TestReadSettingsValues_NoneExist()
{
RemoveSettings();
Assert.AreEqual(0, SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass).Count);
}
private static void RemoveSettings()
{
SystemConfigurationHelper.RemoveSettingsValues(GetExeConfiguration(), _settingsClass);
}
