public void ImplicitArrayItemReplacement()
{
var json1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var json2 = @"{
'ip': [
'15.16.17.18'
]
}";
var jsonConfigSource1 = new NewtonsoftJsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json1)
};
var jsonConfigSource2 = new NewtonsoftJsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(jsonConfigSource1);
configurationBuilder.Add(jsonConfigSource2);
var config = configurationBuilder.Build();
Assert.Equal(3, config.GetSection("ip").GetChildren().Count());
Assert.Equal("15.16.17.18", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
}
public void SourcesReturnsAddedConfigurationProviders()
{
// Arrange
var dict = new Dictionary <string, string>()
{
{ "Mem:KeyInMem", "MemVal" }
};
var memConfigSrc1 = new MemoryConfigurationProvider(dict);
var memConfigSrc2 = new MemoryConfigurationProvider(dict);
var memConfigSrc3 = new MemoryConfigurationProvider(dict);
var srcSet = new HashSet <IConfigurationProvider>()
{
memConfigSrc1,
memConfigSrc2,
memConfigSrc3
};
var builder = new ConfigurationBuilder();
// Act
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Assert
Assert.Equal(new[] { memConfigSrc1, memConfigSrc2, memConfigSrc3 }, builder.Providers);
}
public void NewConfigurationProviderOverridesOldOneWhenKeyIsDuplicated()
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Key1:Key2", "ValueInMem1" }
};
var dic2 = new Dictionary <string, string>()
{
{ "Key1:Key2", "ValueInMem2" }
};
var memConfigSrc1 = new MemoryConfigurationSource {
InitialData = dic1
};
var memConfigSrc2 = new MemoryConfigurationSource {
InitialData = dic2
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1);
configurationBuilder.Add(memConfigSrc2);
var config = configurationBuilder.Build();
// Assert
Assert.Equal("ValueInMem2", config["Key1:Key2"]);
}
public void OverrideWithNullValue()
{
var yaml1 = @"
firstname: test
";
var yaml2 = @"
firstname: null
";
var yamlConfigSource1 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml1)
};
var yamlConfigSource2 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(yamlConfigSource1);
configurationBuilder.Add(yamlConfigSource2);
var config = configurationBuilder.Build();
Assert.Null(config["firstname"]);
}
public void Test1()
{
var builder = new ConfigurationBuilder();
builder.Add(new JsonSectionConfigurationSource()
{
["ServiceConfig"] = new ServiceConfig()
{
Name = "TestService",
},
["Value"] = 12
});
builder.Add(new JsonStringConfigurationSource("{'Value2':456}"));
var configuration = builder.Build();
var config = configuration.GetSection("ServiceConfig").Get <ServiceConfig>();
//var config = configuration.Get<ServiceConfig>("ServiceConfig");
var val = configuration.Get <int>("Value");
Assert.AreEqual("TestService", config.Name);
var val2 = configuration.Get <int>("Value2");
Assert.AreEqual(456, val2);
}
public void ImplicitArrayItemReplacement()
{
var json1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var json2 = @"{
'ip': [
'15.16.17.18'
]
}";
var jsonConfigSource1 = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource1.Load(TestStreamHelpers.StringToStream(json1));
var jsonConfigSource2 = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource2.Load(TestStreamHelpers.StringToStream(json2));
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(jsonConfigSource1, load: false);
configurationBuilder.Add(jsonConfigSource2, load: false);
var config = configurationBuilder.Build();
Assert.Equal(3, config.GetSection("ip").GetChildren().Count());
Assert.Equal("15.16.17.18", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
}
public void ArrayMerge()
{
var json1 = @"{
""ip"": [
""1.2.3.4"",
""7.8.9.10"",
""11.12.13.14""
]
}";
var json2 = @"{
""ip"": {
""3"": ""15.16.17.18""
}
}";
var jsonConfigSource1 = new JsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json1)
};
var jsonConfigSource2 = new JsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(jsonConfigSource1);
configurationBuilder.Add(jsonConfigSource2);
var config = configurationBuilder.Build();
Assert.Equal(4, config.GetSection("ip").GetChildren().Count());
Assert.Equal("1.2.3.4", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
Assert.Equal("15.16.17.18", config["ip:3"]);
}
public void NewConfigurationProviderOverridesOldOneWhenKeyIsDuplicated()
{
// Arrange
var dic1 = new Dictionary<string, string>()
{
{"Key1:Key2", "ValueInMem1"}
};
var dic2 = new Dictionary<string, string>()
{
{"Key1:Key2", "ValueInMem2"}
};
var memConfigSrc1 = new MemoryConfigurationProvider(dic1);
var memConfigSrc2 = new MemoryConfigurationProvider(dic2);
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1, load: false);
configurationBuilder.Add(memConfigSrc2, load: false);
var config = configurationBuilder.Build();
// Assert
Assert.Equal("ValueInMem2", config["Key1:Key2"]);
}
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 builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Act
config["Key1"] = "NewValue1";
config["Key2"] = "NewValue2";
// Assert
Assert.Equal("NewValue1", config["Key1"]);
Assert.Equal("NewValue1", memConfigSrc1.Get("Key1"));
Assert.Equal("NewValue1", memConfigSrc2.Get("Key1"));
Assert.Equal("NewValue1", memConfigSrc3.Get("Key1"));
Assert.Equal("NewValue2", config["Key2"]);
Assert.Equal("NewValue2", memConfigSrc1.Get("Key2"));
Assert.Equal("NewValue2", memConfigSrc2.Get("Key2"));
Assert.Equal("NewValue2", memConfigSrc3.Get("Key2"));
}
public void ExplicitArrayReplacement()
{
var yaml1 = @"
ip:
- 1.2.3.4
- 7.8.9.10
- 11.12.13.14";
var yaml2 = @"
ip:
1: 15.16.17.18";
var yamlConfigurationSource1 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml1)
};
var yamlConfigurationSource2 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(yamlConfigurationSource1);
configurationBuilder.Add(yamlConfigurationSource2);
var config = configurationBuilder.Build();
Assert.Equal(3, config.GetSection("ip").GetChildren().Count());
Assert.Equal("1.2.3.4", config["ip:0"]);
Assert.Equal("15.16.17.18", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
}
public void SourcesReturnsAddedConfigurationProviders()
{
// Arrange
var dict = new Dictionary <string, string>()
{
{ "Mem:KeyInMem", "MemVal" }
};
var memConfigSrc1 = new MemoryConfigurationSource {
InitialData = dict
};
var memConfigSrc2 = new MemoryConfigurationSource {
InitialData = dict
};
var memConfigSrc3 = new MemoryConfigurationSource {
InitialData = dict
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1);
configurationBuilder.Add(memConfigSrc2);
configurationBuilder.Add(memConfigSrc3);
configurationBuilder.Build();
// Assert
Assert.AreEqual(new[] { memConfigSrc1, memConfigSrc2, memConfigSrc3 }, configurationBuilder.Sources);
}
private static IConfigurationProvider GetChainedConfiguration(string jsonSettings, string[] args)
{
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.Add(new JsonConfigurationSource {
Path = jsonSettings,
Optional = false,
FileProvider = new PhysicalFileProvider(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)),
ReloadOnChange = true
});
configBuilder.Add(new CommandLineConfigurationSource
{
Args = args
});
IConfigurationProvider configProvider = new ChainedConfigurationSource
{
Configuration = configBuilder.Build()
}
.Build(configBuilder);
configProvider.Load();
return(configProvider);
}
public void ArrayMerge()
{
var Taml1 =
@"ip
1.2.3.4
7.8.9.10
11.12.13.14" ;
var Taml2 =
@"ip
3 15.16.17.18" ;
var TamlConfigSource1 = new TamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(Taml1)
};
var TamlConfigSource2 = new TamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(Taml2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(TamlConfigSource1);
configurationBuilder.Add(TamlConfigSource2);
var config = configurationBuilder.Build();
Assert.Equal(4, config.GetSection("ip").GetChildren().Count());
Assert.Equal("1.2.3.4", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
Assert.Equal("15.16.17.18", config["ip:3"]);
}
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 builder = new ConfigurationBuilder();
// Act
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
var config = builder.Build();
// Assert
Assert.Equal("ValueInMem2", config["Key1:Key2"]);
}
public void ExplicitArrayReplacement()
{
var json1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var json2 = @"{
'ip': {
'1': '15.16.17.18'
}
}";
var jsonConfigSource1 = new JsonConfigurationSource(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource1.Load(TestStreamHelpers.StringToStream(json1));
var jsonConfigSource2 = new JsonConfigurationSource(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource2.Load(TestStreamHelpers.StringToStream(json2));
var builder = new ConfigurationBuilder();
builder.Add(jsonConfigSource1, load: false);
builder.Add(jsonConfigSource2, load: false);
var config = builder.Build();
Assert.Equal(3, config.GetConfigurationSections("ip").Count());
Assert.Equal("1.2.3.4", config.Get("ip:0"));
Assert.Equal("15.16.17.18", config.Get("ip:1"));
Assert.Equal("11.12.13.14", config.Get("ip:2"));
}
public void ArrayMerge()
{
var hocon1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var hocon2 = @"{
'ip': {
'3': '15.16.17.18'
}
}";
var hoconConfigSource1 = new HoconConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(hocon1)
};
var hoconConfigSource2 = new HoconConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(hocon2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(hoconConfigSource1);
configurationBuilder.Add(hoconConfigSource2);
var config = configurationBuilder.Build();
Assert.Equal(4, config.GetSection("ip").GetChildren().Count());
Assert.Equal("1.2.3.4", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
Assert.Equal("15.16.17.18", config["ip:3"]);
}
public void ArrayMerge()
{
var json1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var json2 = @"{
'ip': {
'3': '15.16.17.18'
}
}";
var jsonConfigSource1 = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource1.Load(TestStreamHelpers.StringToStream(json1));
var jsonConfigSource2 = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource2.Load(TestStreamHelpers.StringToStream(json2));
var builder = new ConfigurationBuilder();
builder.Add(jsonConfigSource1, load: false);
builder.Add(jsonConfigSource2, load: false);
var config = builder.Build();
Assert.Equal(4, config.GetSection("ip").GetChildren().Count());
Assert.Equal("1.2.3.4", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
Assert.Equal("15.16.17.18", config["ip:3"]);
}
public void ImplicitSequenceItemReplacement()
{
var yaml1 = @"
'ip':
- 1.2.3.4
- '7.8.9.10'
- '11.12.13.14'
";
var yaml2 = @"
'ip':
- '15.16.17.18'
";
var yamlConfigSource1 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml1)
};
var yamlConfigSource2 = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml2)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(yamlConfigSource1);
configurationBuilder.Add(yamlConfigSource2);
var config = configurationBuilder.Build();
Assert.Equal(3, config.GetSection("ip").GetChildren().Count());
Assert.Equal("15.16.17.18", config["ip:0"]);
Assert.Equal("7.8.9.10", config["ip:1"]);
Assert.Equal("11.12.13.14", config["ip:2"]);
}
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 builder = new ConfigurationBuilder();
string memVal1, memVal2, memVal3;
bool memRet1, memRet2, memRet3;
// Act
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
memRet1 = config.TryGet("mem1:keyinmem1", out memVal1);
memRet2 = config.TryGet("Mem2:KeyInMem2", out memVal2);
memRet3 = config.TryGet("MEM3:KEYINMEM3", out memVal3);
// Assert
Assert.Contains(memConfigSrc1, builder.Sources);
Assert.Contains(memConfigSrc2, builder.Sources);
Assert.Contains(memConfigSrc3, builder.Sources);
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 ChainedAsEnumerateFlattensIntoDictionaryTest(bool removePath)
{
// Arrange
var dic1 = new Dictionary <string, string>()
{
{ "Mem1", "Value1" },
{ "Mem1:", "NoKeyValue1" },
{ "Mem1:KeyInMem1", "ValueInMem1" },
{ "Mem1:KeyInMem1:Deep1", "ValueDeep1" }
};
var dic2 = new Dictionary <string, string>()
{
{ "Mem2", "Value2" },
{ "Mem2:", "NoKeyValue2" },
{ "Mem2:KeyInMem2", "ValueInMem2" },
{ "Mem2:KeyInMem2:Deep2", "ValueDeep2" }
};
var dic3 = new Dictionary <string, string>()
{
{ "Mem3", "Value3" },
{ "Mem3:", "NoKeyValue3" },
{ "Mem3:KeyInMem3", "ValueInMem3" },
{ "Mem3:KeyInMem3:Deep3", "ValueDeep3" }
};
var memConfigSrc1 = new MemoryConfigurationSource {
InitialData = dic1
};
var memConfigSrc2 = new MemoryConfigurationSource {
InitialData = dic2
};
var memConfigSrc3 = new MemoryConfigurationSource {
InitialData = dic3
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1);
configurationBuilder.Add(memConfigSrc2);
var config = new ConfigurationBuilder()
.AddConfiguration(configurationBuilder.Build())
.Add(memConfigSrc3)
.Build();
var dict = config.AsEnumerable(makePathsRelative: removePath).ToDictionary(k => k.Key, v => v.Value);
// Assert
Assert.Equal("Value1", dict["Mem1"]);
Assert.Equal("NoKeyValue1", dict["Mem1:"]);
Assert.Equal("ValueDeep1", dict["Mem1:KeyInMem1:Deep1"]);
Assert.Equal("ValueInMem2", dict["Mem2:KeyInMem2"]);
Assert.Equal("Value2", dict["Mem2"]);
Assert.Equal("NoKeyValue2", dict["Mem2:"]);
Assert.Equal("ValueDeep2", dict["Mem2:KeyInMem2:Deep2"]);
Assert.Equal("Value3", dict["Mem3"]);
Assert.Equal("NoKeyValue3", dict["Mem3:"]);
Assert.Equal("ValueInMem3", dict["Mem3:KeyInMem3"]);
Assert.Equal("ValueDeep3", dict["Mem3:KeyInMem3:Deep3"]);
}
public void CanGetConfigurationSection()
{
// 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 {
InitialData = dic1
};
var memConfigSrc2 = new MemoryConfigurationSource {
InitialData = dic2
};
var memConfigSrc3 = new MemoryConfigurationSource {
InitialData = dic3
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(memConfigSrc1);
configurationBuilder.Add(memConfigSrc2);
configurationBuilder.Add(memConfigSrc3);
var config = configurationBuilder.Build();
// Act
var configFocus = config.GetSection("Data");
var memVal1 = configFocus["DB1:Connection1"];
var memVal2 = configFocus["DB1:Connection2"];
var memVal3 = configFocus["DB2:Connection"];
var memVal4 = configFocus["Source:DB2:Connection"];
var memVal5 = configFocus.Value;
// Assert
Assert.Equal("MemVal1", memVal1);
Assert.Equal("MemVal2", memVal2);
Assert.Equal("MemVal4", memVal5);
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.Value);
}
public Config Provide(string?workingDirectory, Config?overrideConfig = null)
{
var configurationBuilder = new ConfigurationBuilder();
if (workingDirectory != null)
{
configurationBuilder = configurationBuilder.Add(this.configFileLocator.ReadConfig(workingDirectory));
}
return(configurationBuilder
.Add(overrideConfig ?? new Config())
.Build());
}
public void LoadAndCombineKeyValuePairsFromDifferentConfigurationProviders()
{
// 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 {
InitialData = dic1
};
var memConfigSrc2 = new MemoryConfigurationSource {
InitialData = dic2
};
var memConfigSrc3 = new MemoryConfigurationSource {
InitialData = dic3
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1);
configurationBuilder.Add(memConfigSrc2);
configurationBuilder.Add(memConfigSrc3);
var config = configurationBuilder.Build();
var memVal1 = config["mem1:keyinmem1"];
var memVal2 = config["Mem2:KeyInMem2"];
var memVal3 = config["MEM3:KEYINMEM3"];
// Assert
Assert.Contains(memConfigSrc1, configurationBuilder.Sources);
Assert.Contains(memConfigSrc2, configurationBuilder.Sources);
Assert.Contains(memConfigSrc3, configurationBuilder.Sources);
Assert.Equal("ValueInMem1", memVal1);
Assert.Equal("ValueInMem2", memVal2);
Assert.Equal("ValueInMem3", memVal3);
Assert.Equal("ValueInMem1", config["mem1:keyinmem1"]);
Assert.Equal("ValueInMem2", config["Mem2:KeyInMem2"]);
Assert.Equal("ValueInMem3", config["MEM3:KEYINMEM3"]);
Assert.Null(config["NotExist"]);
}
public void CanGetConfigurationSection()
{
// 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 builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
string memVal1, memVal2, memVal3, memVal4, memVal5;
// Act
var configFocus = config.GetSection("Data");
memVal1 = configFocus["DB1:Connection1"];
memVal2 = configFocus["DB1:Connection2"];
memVal3 = configFocus["DB2:Connection"];
memVal4 = configFocus["Source:DB2:Connection"];
memVal5 = configFocus.Value;
// Assert
Assert.Equal("MemVal1", memVal1);
Assert.Equal("MemVal2", memVal2);
Assert.Equal("MemVal4", memVal5);
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.Value);
}
public void Build_FromDifferentProviders_Should_LoadAndCombine()
{
// Arrange
var dictionary1 = new Dictionary <string, string>()
{
{ "Mem1:KeyInMem1", "ValueInMem1" }
};
var dictionary2 = new Dictionary <string, string>()
{
{ "Mem2:KeyInMem2", "ValueInMem2" }
};
var dictionary3 = new Dictionary <string, string>()
{
{ "Mem3:KeyInMem3", "ValueInMem3" }
};
var memoryConfigurationSource1 = new MemoryConfigurationSource {
InitialData = dictionary1
};
var memoryConfigurationSource2 = new MemoryConfigurationSource {
InitialData = dictionary2
};
var memoryConfigurationSource3 = new MemoryConfigurationSource {
InitialData = dictionary3
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memoryConfigurationSource1);
configurationBuilder.Add(memoryConfigurationSource2);
configurationBuilder.Add(memoryConfigurationSource3);
var config = configurationBuilder.Build();
// Assert
Assert.Contains(memoryConfigurationSource1, configurationBuilder.Sources);
Assert.Contains(memoryConfigurationSource2, configurationBuilder.Sources);
Assert.Contains(memoryConfigurationSource3, configurationBuilder.Sources);
Assert.Equal("ValueInMem1", config["mem1:keyinmem1"]);
Assert.Equal("ValueInMem2", config["Mem2:KeyInMem2"]);
Assert.Equal("ValueInMem3", config["MEM3:KEYINMEM3"]);
Assert.Equal("ValueInMem1", config["mem1:keyinmem1"]);
Assert.Equal("ValueInMem2", config["Mem2:KeyInMem2"]);
Assert.Equal("ValueInMem3", config["MEM3:KEYINMEM3"]);
Assert.Null(config["NotExist"]);
}
private IConfigurationSection GetConfigSection(string configSectionName, bool includeB2cConfig = false)
{
var configAsDictionary = new Dictionary <string, string>()
{
{ configSectionName, null },
{ $"{configSectionName}:Instance", TestConstants.AadInstance },
{ $"{configSectionName}:TenantId", TestConstants.TenantIdAsGuid },
{ $"{configSectionName}:ClientId", TestConstants.TenantIdAsGuid },
{ $"{configSectionName}:Domain", TestConstants.Domain },
};
if (includeB2cConfig)
{
configAsDictionary.Add($"{configSectionName}:SignUpSignInPolicyId", TestConstants.B2CSignUpSignInUserFlow);
configAsDictionary[$"{configSectionName}:Instance"] = TestConstants.B2CInstance;
configAsDictionary[$"{configSectionName}:Domain"] = TestConstants.B2CTenant;
}
var memoryConfigSource = new MemoryConfigurationSource {
InitialData = configAsDictionary
};
var configBuilder = new ConfigurationBuilder();
configBuilder.Add(memoryConfigSource);
var configSection = configBuilder.Build().GetSection(configSectionName);
return(configSection);
}
/// <summary>
/// Returns a <see cref="ConfigServerConfigurationProvider"/> configured using the values from this <see cref="ConfigServerConfigurationSource"/>
/// </summary>
/// <param name="builder">not required</param>
/// <returns>configuration provider</returns>
public virtual IConfigurationProvider Build(IConfigurationBuilder builder)
{
if (Configuration == null)
{
// Create our own builder to build sources
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
foreach (IConfigurationSource s in _sources)
{
configBuilder.Add(s);
}
// Use properties provided
foreach (var p in _properties)
{
configBuilder.Properties.Add(p);
}
// Create configuration
Configuration = configBuilder.Build();
}
var certificateSource = _sources.FirstOrDefault(cSource => cSource is ICertificateSource);
if (certificateSource != null && DefaultSettings.ClientCertificate == null)
{
var certConfigurer = Activator.CreateInstance((certificateSource as ICertificateSource).OptionsConfigurer, Configuration) as IConfigureNamedOptions <CertificateOptions>;
var certOptions = new CertificateOptions();
certConfigurer.Configure(certOptions);
DefaultSettings.ClientCertificate = certOptions.Certificate;
}
return(new ConfigServerConfigurationProvider(this));
}
public void PropertiesAreSortedByNumberOnlyFirst()
{
var json = @"{
'setting': {
'hello': 'a',
'bob': 'b',
'42': 'c',
'4':'d',
'10': 'e',
'1text': 'f',
}
}";
var jsonConfigSource = new NewtonsoftJsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(jsonConfigSource);
var config = configurationBuilder.Build();
var configurationSection = config.GetSection("setting");
var indexConfigurationSections = configurationSection.GetChildren().ToArray();
Assert.Equal(6, indexConfigurationSections.Count());
Assert.Equal("4", indexConfigurationSections[0].Key);
Assert.Equal("10", indexConfigurationSections[1].Key);
Assert.Equal("42", indexConfigurationSections[2].Key);
Assert.Equal("1text", indexConfigurationSections[3].Key);
Assert.Equal("bob", indexConfigurationSections[4].Key);
Assert.Equal("hello", indexConfigurationSections[5].Key);
}
private BackTelemetryChannel Start(string assemblyName)
{
var customConfig = new MemoryConfigurationProvider();
customConfig.Set("server.urls", this.BaseHost);
var configBuilder = new ConfigurationBuilder();
configBuilder.Add(customConfig);
var config = configBuilder.Build();
var services = new ServiceCollection();
services.AddTransient <IApplicationEnvironment, ApplicationEnvironment>();
var serviceProvider = services.BuildServiceProvider();
var engine = CreateBuilder(config)
.UseServer("Microsoft.AspNet.Server.WebListener")
.UseStartup(assemblyName)
.UseEnvironment("Production")
.Build();
this.hostingEngine = engine.Start();
return((BackTelemetryChannel)engine.ApplicationServices.GetService <ITelemetryChannel>());
}
public void ArraysAreKeptInFileOrder()
{
var json = @"{
'setting': [
'b',
'a',
'2'
]
}";
var jsonConfigSource = new NewtonsoftJsonConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(json)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(jsonConfigSource);
var config = configurationBuilder.Build();
var configurationSection = config.GetSection("setting");
var indexConfigurationSections = configurationSection.GetChildren().ToArray();
Assert.Equal(3, indexConfigurationSections.Count());
Assert.Equal("b", indexConfigurationSections[0].Value);
Assert.Equal("a", indexConfigurationSections[1].Value);
Assert.Equal("2", indexConfigurationSections[2].Value);
}
private async Task <SiloHandle> StartSilo(DirectoryInfo rootDir)
{
SiloHandle silo;
if (this.siloIdx == 0)
{
// Setup configuration
this.builder = new TestClusterBuilder(1)
{
CreateSilo = AppDomainSiloHandle.Create
};
TestDefaultConfiguration.ConfigureTestCluster(this.builder);
builder.Options.ApplicationBaseDirectory = rootDir.FullName;
builder.AddSiloBuilderConfigurator <VersionGrainsSiloBuilderConfigurator>();
builder.ConfigureLegacyConfiguration(legacy =>
{
legacy.ClusterConfiguration.Globals.ExpectedClusterSize = SiloCount;
legacy.ClusterConfiguration.Globals.AssumeHomogenousSilosForTesting = false;
legacy.ClusterConfiguration.Globals.TypeMapRefreshInterval = refreshInterval;
legacy.ClusterConfiguration.Globals.DefaultVersionSelectorStrategy = VersionSelectorStrategy;
legacy.ClusterConfiguration.Globals.DefaultCompatibilityStrategy = CompatibilityStrategy;
legacy.ClientConfiguration.Gateways = legacy.ClientConfiguration.Gateways.Take(1).ToList(); // Only use primary gw
waitDelay = TestClusterLegacyUtils.GetLivenessStabilizationTime(legacy.ClusterConfiguration.Globals, false);
});
this.cluster = builder.Build();
await this.cluster.DeployAsync();
silo = this.cluster.Primary;
}
else
{
var configBuilder = new ConfigurationBuilder();
foreach (var source in cluster.ConfigurationSources)
{
configBuilder.Add(source);
}
var testClusterOptions = new TestClusterOptions();
configBuilder.Build().Bind(testClusterOptions);
// Override the root directory.
var sources = new IConfigurationSource[]
{
new MemoryConfigurationSource {
InitialData = new TestClusterOptions {
ApplicationBaseDirectory = rootDir.FullName
}.ToDictionary()
}
};
silo = TestCluster.StartOrleansSilo(cluster, siloIdx, testClusterOptions, sources);
}
this.deployedSilos.Add(silo);
this.siloIdx++;
return(silo);
}
public void SequencesAreKeptInFileOrder()
{
var yaml = @"
setting:
- 'b'
- 'a'
- '2'
";
var yamlConfigSource = new YamlConfigurationSource {
FileProvider = TestStreamHelpers.StringToFileProvider(yaml)
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.Add(yamlConfigSource);
var config = configurationBuilder.Build();
var configurationSection = config.GetSection("setting");
var indexConfigurationSections = configurationSection.GetChildren().ToArray();
Assert.Equal(3, indexConfigurationSections.Count());
Assert.Equal("b", indexConfigurationSections[0].Value);
Assert.Equal("a", indexConfigurationSections[1].Value);
Assert.Equal("2", indexConfigurationSections[2].Value);
}
private IConfigurationSection GetConfigSection(string configSectionName)
{
string serializedTokenDecryptionJsonBlob = JsonSerializer.Serialize(
s_tokenDecryptionCertificatesDescription,
new JsonSerializerOptions
{
IgnoreNullValues = true,
PropertyNameCaseInsensitive = true,
}).Replace(":2", ": \"Base64Encoded\"");
var configAsDictionary = new Dictionary <string, string>()
{
{ configSectionName, null },
{ $"{configSectionName}:Instance", TestConstants.AadInstance },
{ $"{configSectionName}:TenantId", TestConstants.TenantIdAsGuid },
{ $"{configSectionName}:ClientId", TestConstants.TenantIdAsGuid },
{ $"{configSectionName}:TokenDecryptionCertificates", serializedTokenDecryptionJsonBlob },
};
var memoryConfigSource = new MemoryConfigurationSource {
InitialData = configAsDictionary
};
var configBuilder = new ConfigurationBuilder();
configBuilder.Add(memoryConfigSource);
var configSection = configBuilder.Build().GetSection(configSectionName);
return(configSection);
}
public void LoadAndCombineKeyValuePairsFromDifferentConfigurationProviders()
{
// 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 MemoryConfigurationProvider(dic1);
var memConfigSrc2 = new MemoryConfigurationProvider(dic2);
var memConfigSrc3 = new MemoryConfigurationProvider(dic3);
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1, load: false);
configurationBuilder.Add(memConfigSrc2, load: false);
configurationBuilder.Add(memConfigSrc3, load: false);
var config = configurationBuilder.Build();
var memVal1 = config["mem1:keyinmem1"];
var memVal2 = config["Mem2:KeyInMem2"];
var memVal3 = config["MEM3:KEYINMEM3"];
// Assert
Assert.Contains(memConfigSrc1, configurationBuilder.Providers);
Assert.Contains(memConfigSrc2, configurationBuilder.Providers);
Assert.Contains(memConfigSrc3, configurationBuilder.Providers);
Assert.Equal("ValueInMem1", memVal1);
Assert.Equal("ValueInMem2", memVal2);
Assert.Equal("ValueInMem3", memVal3);
Assert.Equal("ValueInMem1", config["mem1:keyinmem1"]);
Assert.Equal("ValueInMem2", config["Mem2:KeyInMem2"]);
Assert.Equal("ValueInMem3", config["MEM3:KEYINMEM3"]);
Assert.Null(config["NotExist"]);
}
public void CanGetConfigurationChildren()
{
// 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 MemoryConfigurationProvider(dic1);
var memConfigSrc2 = new MemoryConfigurationProvider(dic2);
var memConfigSrc3 = new MemoryConfigurationProvider(dic3);
var builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Act
var configSections = config.GetSection("Data").GetChildren().ToList();
// Assert
Assert.Equal(2, configSections.Count());
Assert.Equal("MemVal1", configSections.FirstOrDefault(c => c.Key == "DB1")["Connection1"]);
Assert.Equal("MemVal2", configSections.FirstOrDefault(c => c.Key == "DB1")["Connection2"]);
Assert.Equal("MemVal3", configSections.FirstOrDefault(c => c.Key == "DB2Connection").Value);
Assert.False(configSections.Exists(c => c.Key == "DB3"));
Assert.False(configSections.Exists(c => c.Key == "DB3"));
}
public void CanGetConfigurationSections()
{
// 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 builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Act
var configFocusList = config.GetConfigurationSections("Data");
var configurationSectionsSet = configFocusList.ToDictionary(e => e.Key, e => e.Value);
// Assert
Assert.Equal(2, configFocusList.Count());
Assert.Equal("MemVal1", configurationSectionsSet["DB1"].Get("Connection1"));
Assert.Equal("MemVal2", configurationSectionsSet["DB1"].Get("Connection2"));
Assert.Equal("MemVal3", configurationSectionsSet["DB2Connection"].Get(null));
Assert.False(configurationSectionsSet.ContainsKey("DB3"));
Assert.False(configurationSectionsSet.ContainsKey("Source:DB3"));
}
public void ImplicitArrayItemReplacement()
{
var json1 = @"{
'ip': [
'1.2.3.4',
'7.8.9.10',
'11.12.13.14'
]
}";
var json2 = @"{
'ip': [
'15.16.17.18'
]
}";
var jsonConfigSource1 = new JsonConfigurationSource(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource1.Load(TestStreamHelpers.StringToStream(json1));
var jsonConfigSource2 = new JsonConfigurationSource(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource2.Load(TestStreamHelpers.StringToStream(json2));
var builder = new ConfigurationBuilder();
builder.Add(jsonConfigSource1, load: false);
builder.Add(jsonConfigSource2, load: false);
var config = builder.Build();
Assert.Equal(3, config.GetConfigurationSections("ip").Count());
Assert.Equal("15.16.17.18", config.Get("ip:0"));
Assert.Equal("7.8.9.10", config.Get("ip:1"));
Assert.Equal("11.12.13.14", config.Get("ip:2"));
}
public void ArraysAreKeptInFileOrder()
{
var json = @"{
'setting': [
'b',
'a',
'2'
]
}";
var jsonConfigSource = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource.Load(TestStreamHelpers.StringToStream(json));
var builder = new ConfigurationBuilder();
builder.Add(jsonConfigSource, load: false);
var config = builder.Build();
var configurationSection = config.GetSection("setting");
var indexConfigurationSections = configurationSection.GetChildren().ToArray();
Assert.Equal(3, indexConfigurationSections.Count());
Assert.Equal("b", indexConfigurationSections[0].Value);
Assert.Equal("a", indexConfigurationSections[1].Value);
Assert.Equal("2", indexConfigurationSections[2].Value);
}
public void SourcesReturnsAddedConfigurationProviders()
{
// Arrange
var dict = new Dictionary<string, string>()
{
{"Mem:KeyInMem", "MemVal"}
};
var memConfigSrc1 = new MemoryConfigurationProvider(dict);
var memConfigSrc2 = new MemoryConfigurationProvider(dict);
var memConfigSrc3 = new MemoryConfigurationProvider(dict);
var srcSet = new HashSet<IConfigurationProvider>()
{
memConfigSrc1,
memConfigSrc2,
memConfigSrc3
};
var configurationBuilder = new ConfigurationBuilder();
// Act
configurationBuilder.Add(memConfigSrc1, load: false);
configurationBuilder.Add(memConfigSrc2, load: false);
configurationBuilder.Add(memConfigSrc3, load: false);
var config = configurationBuilder.Build();
// Assert
Assert.Equal(new[] { memConfigSrc1, memConfigSrc2, memConfigSrc3 }, configurationBuilder.Providers);
}
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 builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Act
config["Key1"] = "NewValue1";
config["Key2"] = "NewValue2";
// Assert
Assert.Equal("NewValue1", config["Key1"]);
Assert.Equal("NewValue1", memConfigSrc1.Get("Key1"));
Assert.Equal("NewValue1", memConfigSrc2.Get("Key1"));
Assert.Equal("NewValue1", memConfigSrc3.Get("Key1"));
Assert.Equal("NewValue2", config["Key2"]);
Assert.Equal("NewValue2", memConfigSrc1.Get("Key2"));
Assert.Equal("NewValue2", memConfigSrc2.Get("Key2"));
Assert.Equal("NewValue2", memConfigSrc3.Get("Key2"));
}
public void PropertiesAreSortedByNumberOnlyFirst()
{
var json = @"{
'setting': {
'hello': 'a',
'bob': 'b',
'42': 'c',
'4':'d',
'10': 'e',
'1text': 'f',
}
}";
var jsonConfigSource = new JsonConfigurationProvider(TestStreamHelpers.ArbitraryFilePath);
jsonConfigSource.Load(TestStreamHelpers.StringToStream(json));
var builder = new ConfigurationBuilder();
builder.Add(jsonConfigSource, load: false);
var config = builder.Build();
var configurationSection = config.GetSection("setting");
var indexConfigurationSections = configurationSection.GetChildren().ToArray();
Assert.Equal(6, indexConfigurationSections.Count());
Assert.Equal("4", indexConfigurationSections[0].Key);
Assert.Equal("10", indexConfigurationSections[1].Key);
Assert.Equal("42", indexConfigurationSections[2].Key);
Assert.Equal("1text", indexConfigurationSections[3].Key);
Assert.Equal("bob", indexConfigurationSections[4].Key);
Assert.Equal("hello", indexConfigurationSections[5].Key);
}
public void CanIterateWithGenericEnumerator()
{
// 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 builder = new ConfigurationBuilder();
// Act
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
// Assert
var enumerator = builder.Sources.GetEnumerator();
int srcCount = 0;
while (enumerator.MoveNext())
{
Assert.Contains(enumerator.Current, srcSet);
++srcCount;
}
Assert.Equal(3, srcCount);
}
public void CanGetConfigurationSection()
{
// 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 builder = new ConfigurationBuilder();
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
string memVal1, memVal2, memVal3, memVal4, memVal5;
bool memRet1, memRet2, memRet3, memRet4, memRet5;
// Act
var configFocus = config.GetConfigurationSection("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]);
}
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 builder = new ConfigurationBuilder();
string memVal1, memVal2, memVal3;
bool memRet1, memRet2, memRet3;
// Act
builder.Add(memConfigSrc1, load: false);
builder.Add(memConfigSrc2, load: false);
builder.Add(memConfigSrc3, load: false);
var config = builder.Build();
memRet1 = config.TryGet("mem1:keyinmem1", out memVal1);
memRet2 = config.TryGet("Mem2:KeyInMem2", out memVal2);
memRet3 = config.TryGet("MEM3:KEYINMEM3", out memVal3);
// Assert
Assert.Contains(memConfigSrc1, builder.Sources);
Assert.Contains(memConfigSrc2, builder.Sources);
Assert.Contains(memConfigSrc3, builder.Sources);
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"]);
}
