public void SettingValueUpdatesAllConfigurationSources()
{
// Arrange
var dict = new Dictionary <string, string>()
{
{ "Key1", "Value1" },
{ "Key2", "Value2" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dict);
var memConfigSrc2 = new MemoryConfigurationSource(dict);
var memConfigSrc3 = new MemoryConfigurationSource(dict);
var config = new Configuration();
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
config.AddLoadedSource(memConfigSrc3);
// Act
config.Set("Key1", "NewValue1");
config["Key2"] = "NewValue2";
// Assert
Assert.Equal(6, CountAllEntries(config));
Assert.Equal("NewValue1", config.Get("Key1"));
Assert.Equal("NewValue1", memConfigSrc1.Data["Key1"]);
Assert.Equal("NewValue1", memConfigSrc2.Data["Key1"]);
Assert.Equal("NewValue1", memConfigSrc3.Data["Key1"]);
Assert.Equal("NewValue2", config["Key2"]);
Assert.Equal("NewValue2", memConfigSrc1.Data["Key2"]);
Assert.Equal("NewValue2", memConfigSrc2.Data["Key2"]);
Assert.Equal("NewValue2", memConfigSrc3.Data["Key2"]);
}
public void LoadAndCombineKeyValuePairsFromDifferentConfigurationSources()
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Mem1:KeyInMem1", "ValueInMem1" }
};
var dic2 = new Dictionary <string, string>()
{
{ "Mem2:KeyInMem2", "ValueInMem2" }
};
var dic3 = new Dictionary <string, string>()
{
{ "Mem3:KeyInMem3", "ValueInMem3" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dic1);
var memConfigSrc2 = new MemoryConfigurationSource(dic2);
var memConfigSrc3 = new MemoryConfigurationSource(dic3);
var config = new Configuration();
string memVal1, memVal2, memVal3;
bool memRet1, memRet2, memRet3;
// Act
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
config.AddLoadedSource(memConfigSrc3);
memRet1 = config.TryGet("mem1:keyinmem1", out memVal1);
memRet2 = config.TryGet("Mem2:KeyInMem2", out memVal2);
memRet3 = config.TryGet("MEM3:KEYINMEM3", out memVal3);
// Assert
Assert.Equal(3, CountAllEntries(config));
Assert.Contains(memConfigSrc1, config);
Assert.Contains(memConfigSrc2, config);
Assert.Contains(memConfigSrc3, config);
Assert.True(memRet1);
Assert.True(memRet2);
Assert.True(memRet3);
Assert.Equal("ValueInMem1", memVal1);
Assert.Equal("ValueInMem2", memVal2);
Assert.Equal("ValueInMem3", memVal3);
Assert.Equal("ValueInMem1", config.Get("mem1:keyinmem1"));
Assert.Equal("ValueInMem2", config.Get("Mem2:KeyInMem2"));
Assert.Equal("ValueInMem3", config.Get("MEM3:KEYINMEM3"));
Assert.Null(config.Get("NotExist"));
Assert.Equal("ValueInMem1", config["mem1:keyinmem1"]);
Assert.Equal("ValueInMem2", config["Mem2:KeyInMem2"]);
Assert.Equal("ValueInMem3", config["MEM3:KEYINMEM3"]);
Assert.Null(config["NotExist"]);
}
public void CommitOnConfigurationWithZeroCommitableSourceThrows()
{
var dict = new Dictionary <string, string>()
{
{ "Mem:KeyInMem", "MemVal" }
};
var memConfigSrc = new MemoryConfigurationSource(dict);
var config = new Configuration();
config.Add(memConfigSrc);
var exception = Assert.Throws <InvalidOperationException>(() => config.Commit());
Assert.Equal(1, CountAllEntries(config));
Assert.Equal(Resources.Error_NoCommitableSource, exception.Message);
}
public void LoadAndCombineKeyValuePairsFromDifferentConfigurationSources()
{
// Arrange
var config = new Configuration();
// Act
config.AddIniFile(_iniConfigFilePath);
config.AddJsonFile(_jsonConfigFilePath);
config.AddXmlFile(_xmlConfigFilePath);
var memConfigSrc = new MemoryConfigurationSource(_memConfigContent);
config.Add(memConfigSrc);
// Assert
Assert.Equal(24, CountAllEntries(config));
Assert.Equal("IniValue1", config.Get("IniKey1"));
Assert.Equal("IniValue2", config.Get("IniKey2:IniKey3"));
Assert.Equal("IniValue3", config.Get("IniKey2:IniKey4"));
Assert.Equal("IniValue4", config.Get("IniKey2:IniKey5:IniKey6"));
Assert.Equal("IniValue5", config.Get("CommonKey1:CommonKey2:IniKey7"));
Assert.Equal("JsonValue1", config.Get("JsonKey1"));
Assert.Equal("JsonValue2", config.Get("Json.Key2:JsonKey3"));
Assert.Equal("JsonValue3", config.Get("Json.Key2:Json.Key4"));
Assert.Equal("JsonValue4", config.Get("Json.Key2:JsonKey5:JsonKey6"));
Assert.Equal("JsonValue5", config.Get("CommonKey1:CommonKey2:JsonKey7"));
Assert.Equal("XmlValue1", config.Get("XmlKey1"));
Assert.Equal("XmlValue2", config.Get("XmlKey2:XmlKey3"));
Assert.Equal("XmlValue3", config.Get("XmlKey2:XmlKey4"));
Assert.Equal("XmlValue4", config.Get("XmlKey2:XmlKey5:XmlKey6"));
Assert.Equal("XmlValue5", config.Get("CommonKey1:CommonKey2:XmlKey7"));
Assert.Equal("MemValue1", config["MemKey1"]);
Assert.Equal("MemValue2", config["MemKey2:MemKey3"]);
Assert.Equal("MemValue3", config["MemKey2:MemKey4"]);
Assert.Equal("MemValue4", config["MemKey2:MemKey5:MemKey6"]);
Assert.Equal("MemValue5", config["CommonKey1:CommonKey2:MemKey7"]);
Assert.Equal("MemValue6", config["CommonKey1:CommonKey2:CommonKey3:CommonKey4"]);
}
public void CanOverrideValuesWithNewConfigurationSource()
{
// Arrange
var config = new Configuration();
// Act & Assert
config.AddIniFile(_iniConfigFilePath);
Assert.Equal("IniValue6", config.Get("CommonKey1:CommonKey2:CommonKey3:CommonKey4"));
config.AddJsonFile(_jsonConfigFilePath);
Assert.Equal("JsonValue6", config.Get("CommonKey1:CommonKey2:CommonKey3:CommonKey4"));
config.AddXmlFile(_xmlConfigFilePath);
Assert.Equal("XmlValue6", config.Get("CommonKey1:CommonKey2:CommonKey3:CommonKey4"));
var memConfigSrc = new MemoryConfigurationSource(_memConfigContent);
config.Add(memConfigSrc);
Assert.Equal("MemValue6", config.Get("CommonKey1:CommonKey2:CommonKey3:CommonKey4"));
}
public void CanIterateAfterCastedToIEnumerable()
{
// Arrange
var dict = new Dictionary <string, string>()
{
{ "Mem:KeyInMem", "MemVal" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dict);
var memConfigSrc2 = new MemoryConfigurationSource(dict);
var memConfigSrc3 = new MemoryConfigurationSource(dict);
var srcSet = new HashSet <IConfigurationSource>()
{
memConfigSrc1,
memConfigSrc2,
memConfigSrc3
};
var config = new Configuration();
// Act
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
config.AddLoadedSource(memConfigSrc3);
var enumerable = config as IEnumerable;
// Assert
var enumerator = config.GetEnumerator();
int srcCount = 0;
while (enumerator.MoveNext())
{
Assert.Contains(enumerator.Current, srcSet);
++srcCount;
}
Assert.Equal(3, srcCount);
}
public void CanGetSubKeys()
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Data:DB1:Connection1", "MemVal1" },
{ "Data:DB1:Connection2", "MemVal2" }
};
var dic2 = new Dictionary <string, string>()
{
{ "Data:DB2Connection", "MemVal3" }
};
var dic3 = new Dictionary <string, string>()
{
{ "DataSource:DB3:Connection", "MemVal4" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dic1);
var memConfigSrc2 = new MemoryConfigurationSource(dic2);
var memConfigSrc3 = new MemoryConfigurationSource(dic3);
var config = new Configuration();
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
config.AddLoadedSource(memConfigSrc3);
// Act
var configFocusList = config.GetSubKeys("Data");
var subKeysSet = configFocusList.ToDictionary(e => e.Key, e => e.Value);
// Assert
Assert.Equal(2, configFocusList.Count());
Assert.Equal("MemVal1", subKeysSet["DB1"].Get("Connection1"));
Assert.Equal("MemVal2", subKeysSet["DB1"].Get("Connection2"));
Assert.Equal("MemVal3", subKeysSet["DB2Connection"].Get(null));
Assert.False(subKeysSet.ContainsKey("DB3"));
Assert.False(subKeysSet.ContainsKey("Source:DB3"));
}
public void NewConfigurationSourceOverridesOldOneWhenKeyIsDuplicated()
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Key1:Key2", "ValueInMem1" }
};
var dic2 = new Dictionary <string, string>()
{
{ "Key1:Key2", "ValueInMem2" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dic1);
var memConfigSrc2 = new MemoryConfigurationSource(dic2);
var config = new Configuration();
// Act
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
// Assert
Assert.Equal(2, CountAllEntries(config));
Assert.Equal("ValueInMem2", config.Get("Key1:Key2"));
}
public void CanGetSubKey()
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Data:DB1:Connection1", "MemVal1" },
{ "Data:DB1:Connection2", "MemVal2" }
};
var dic2 = new Dictionary <string, string>()
{
{ "DataSource:DB2:Connection", "MemVal3" }
};
var dic3 = new Dictionary <string, string>()
{
{ "Data", "MemVal4" }
};
var memConfigSrc1 = new MemoryConfigurationSource(dic1);
var memConfigSrc2 = new MemoryConfigurationSource(dic2);
var memConfigSrc3 = new MemoryConfigurationSource(dic3);
var config = new Configuration();
config.AddLoadedSource(memConfigSrc1);
config.AddLoadedSource(memConfigSrc2);
config.AddLoadedSource(memConfigSrc3);
string memVal1, memVal2, memVal3, memVal4, memVal5;
bool memRet1, memRet2, memRet3, memRet4, memRet5;
// Act
var configFocus = config.GetSubKey("Data");
memRet1 = configFocus.TryGet("DB1:Connection1", out memVal1);
memRet2 = configFocus.TryGet("DB1:Connection2", out memVal2);
memRet3 = configFocus.TryGet("DB2:Connection", out memVal3);
memRet4 = configFocus.TryGet("Source:DB2:Connection", out memVal4);
memRet5 = configFocus.TryGet(null, out memVal5);
// Assert
Assert.True(memRet1);
Assert.True(memRet2);
Assert.False(memRet3);
Assert.False(memRet4);
Assert.True(memRet5);
Assert.Equal("MemVal1", memVal1);
Assert.Equal("MemVal2", memVal2);
Assert.Equal("MemVal4", memVal5);
Assert.Equal("MemVal1", configFocus.Get("DB1:Connection1"));
Assert.Equal("MemVal2", configFocus.Get("DB1:Connection2"));
Assert.Null(configFocus.Get("DB2:Connection"));
Assert.Null(configFocus.Get("Source:DB2:Connection"));
Assert.Equal("MemVal4", configFocus.Get(null));
Assert.Equal("MemVal1", configFocus["DB1:Connection1"]);
Assert.Equal("MemVal2", configFocus["DB1:Connection2"]);
Assert.Null(configFocus["DB2:Connection"]);
Assert.Null(configFocus["Source:DB2:Connection"]);
Assert.Equal("MemVal4", configFocus[null]);
}
