/// <summary>
/// Initialize this client environment from the specified configuration file and version
/// using the configuration parser.
/// </summary>
/// <param name="parser">Configuration parser to use.</param>
/// <param name="configfile">Configuration file path.</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(AbstractConfigParser parser, string configfile,
Version version, string password = null)
{
try
{
LogUtils.Info(String.Format(
"Initializing Client Environment : With Configuration file [{0}]...",
configfile));
Uri path = new Uri(NetUtils.FilePathToFileUrl(configfile));
AbstractReader reader = ConfigProviderFactory.GetReader(path);
if (reader == null)
{
throw new ConfigurationException(String.Format("Failed to get reader. [URI={0}]", path.ToString()));
}
parser.Parse(ConfigName, reader,
version,
null, password);
__configuration = parser.GetConfiguration();
if (__configuration == null)
{
throw new ConfigurationException(String.Format(
"Error parsing configuration : NULL configuration read. [file={0}]",
configfile));
}
PostInit();
UpdateState(EEnvState.Initialized);
}
catch (Exception e)
{
throw new ConfigurationException(e);
}
}
public void Config_validation_exception_contains_missing_values_when_server_and_cache_config_is_invalid()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
configFromMockCache.Data.Children.Add(new ConfigNode {
Name = "N4", Value = "V4"
});
CreateMockDurableCacheEntry(configFromMockCache);
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary <string, Func <string, bool> > {
{ "foo.N1", x => true }, { "foo.N2", x => true }, { "foo.N3", x => true }, { "foo.N4", x => true }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
try
{
configProvider.GetAndValidateConfiguration();
Assert.Fail("Invalid configuration passed validation");
}
catch (UnableToAccessConfigurationException e)
{
Assert.IsInstanceOfType(e.InnerException, typeof(ConfigValidationException), "Expected a ConfigValidationException to be thrown");
ConfigValidationException configValidationEx = (ConfigValidationException)e.InnerException;
Assert.IsTrue(Regex.IsMatch(configValidationEx.Message, "foo.N3, foo.N4"), "Missing invalid parameters from validation error message");
}
}
private static IConfigProvider CreateConfigProvider(string directoryPath, bool useSingleFileConfig)
{
var configProviderFactory = new ConfigProviderFactory(LogTraceToConsole);
return(useSingleFileConfig
? configProviderFactory.CreateFromXmlConfigFile(Path.Combine(directoryPath, "config.nsdepcop"))
: configProviderFactory.CreateFromMultiLevelXmlConfigFile(directoryPath));
}
public void Broken_validation_handlers_should_cause_config_validation_exception_to_be_thrown()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary<string, Func<string, bool>> { { "N1.N1", x => { throw new Exception(); } } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
public void Missing_config_settings_should_cause_config_validation_exception_to_be_thrown()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary <string, Func <string, bool> > {
{ "Taco", x => true }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
public void Retrieve_valid_configuration()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary<string, Func<string, bool>> { { string.Format("{0}.N1", TestComponentName), x => true }, { string.Format("{0}.N2", TestComponentName), x => true } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
ConfigRoot configuration = configProvider.GetAndValidateConfiguration();
Dictionary<string, string> dictionary = configuration.Data.ToDictionary();
Assert.AreEqual("V1", dictionary[string.Format("{0}.N1", TestComponentName)]);
Assert.AreEqual("V2", dictionary[string.Format("{0}.N2", TestComponentName)]);
}
public void If_server_is_down_and_cache_is_empty_a_config_access_exception_should_be_thrown()
{
_mockConfigServiceHttpClient = HttpClientTestHelper.CreateClientSimulatingABadAddress();
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
// This validator would cause an error, but the simulated connection issue above should prevent it from hitting that.
var validators = new Dictionary <string, Func <string, bool> > {
{ "Taco", x => true }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
public void Config_should_always_come_from_server_if_it_returns_valid_data()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(configFromMockCache);
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
IConfigProvider configProvider = testFactory.Create(TestComponentName, new Dictionary<string, Func<string, bool>>());
ConfigRoot config = configProvider.GetAndValidateConfiguration();
Dictionary<string, string> dictionary = config.Data.ToDictionary();
Assert.AreEqual("V1", dictionary[string.Format("{0}.N1", TestComponentName)]);
}
public void Retrieve_valid_configuration()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary <string, Func <string, bool> > {
{ string.Format("{0}.N1", TestComponentName), x => true }, { string.Format("{0}.N2", TestComponentName), x => true }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
ConfigRoot configuration = configProvider.GetAndValidateConfiguration();
Dictionary <string, string> dictionary = configuration.Data.ToDictionary();
Assert.AreEqual("V1", dictionary[string.Format("{0}.N1", TestComponentName)]);
Assert.AreEqual("V2", dictionary[string.Format("{0}.N2", TestComponentName)]);
}
public void Config_should_always_come_from_server_if_it_returns_valid_data()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(configFromMockCache);
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
IConfigProvider configProvider = testFactory.Create(TestComponentName, new Dictionary <string, Func <string, bool> >());
ConfigRoot config = configProvider.GetAndValidateConfiguration();
Dictionary <string, string> dictionary = config.Data.ToDictionary();
Assert.AreEqual("V1", dictionary[string.Format("{0}.N1", TestComponentName)]);
}
private NScrapyContext()
{
var configPath = ConfigProviderFactory.GetProvider().GetConfigFilePath();
var builder = new ConfigurationBuilder();
builder.SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile(configPath);
CurrentConfig = builder.Build();
Log = log4net.LogManager.GetLogger(this.GetType());
var logConfig = File.ReadAllBytes(Path.Combine(Directory.GetCurrentDirectory(), "log4net.config")); //Properties.Resources.log4net;
using (var configStream = new MemoryStream(logConfig))
{
XmlConfigurator.Configure(Log.Logger.Repository, configStream);
}
}
public void Cache_should_always_be_updated_when_valid_data_is_retrieved_from_server()
{
ConfigRoot originalConfigFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
originalConfigFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(originalConfigFromMockCache);
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
IConfigProvider configProvider = testFactory.Create(TestComponentName, new Dictionary <string, Func <string, bool> >());
ConfigRoot configFromProvider = configProvider.GetAndValidateConfiguration();
ConfigRoot updatedConfigFromMockCache = ReadMockDurableCacheEntry();
Assert.IsFalse(_objectComparer.Compare(originalConfigFromMockCache, updatedConfigFromMockCache).AreEqual);
Assert.IsTrue(_objectComparer.Compare(configFromProvider, updatedConfigFromMockCache).AreEqual);
}
public void Config_data_in_cache_should_always_be_validated()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(configFromMockCache);
// In this case, we have to bypass validation of the service data because the service is offline
_mockConfigServiceHttpClient = HttpClientTestHelper.CreateClientSimulatingABadAddress();
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary <string, Func <string, bool> > {
{ "N1.N1", x => false }, { "N1.N2", x => false }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
/// <summary>
/// Load a configuration from local file.
/// </summary>
/// <param name="configName">Configuration name</param>
/// <param name="configFile">Configuration File Path</param>
/// <param name="version">Configuration Version (expected)</param>
/// <param name="settings">Configuration Settings</param>
/// <param name="password">Password (if required)</param>
/// <returns>Loaded Configruation</returns>
public Configuration Load(string configName, string configFile,
Version version, ConfigurationSettings settings,
string password = null)
{
Preconditions.CheckArgument(configName);
Preconditions.CheckArgument(configFile);
Preconditions.CheckArgument(version);
LogUtils.Info(String.Format("Loading Configuration. [name={0}][version={1}][file={2}]", configName, version.ToString(), configFile));
using (FileReader reader = new FileReader(configFile))
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(configFile);
Postconditions.CheckCondition(parser);
parser.Parse(configName, reader, version, settings, password);
return(parser.GetConfiguration());
}
}
/// <summary>
/// Initialize this client environment from the specified configuration file and version.
/// </summary>
/// <param name="configfile">Configuration file path.</param>
/// <param name="type">Configuration file type (in-case file type cannot be deciphered).</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(string configfile,
EConfigType type,
Version version, string password = null)
{
try
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(type);
if (parser == null)
{
throw new ConfigurationException(String.Format(
"Cannot get configuration parser instance. [file={0}]",
configfile));
}
Init(parser, configfile, version, password);
}
catch (Exception e)
{
state.SetError(e);
throw new ConfigurationException(e);
}
}
/// <summary>
/// Initialize this client environment from the specified configuration file and version.
/// </summary>
/// <param name="configfile">Configuration file path</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(string configfile, Version version, string password = null)
{
Preconditions.CheckArgument(configfile);
Preconditions.CheckArgument(version);
try
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(configfile);
if (parser == null)
{
throw new ConfigurationException(String.Format("Failed to get configuration parser. [config file={0}]", configfile));
}
Init(parser, configfile, version, password);
}
catch (Exception ex)
{
LogUtils.Debug(ex.Message);
state.SetError(ex);
throw ex;
}
}
public void Config_validation_exception_contains_missing_values_when_server_config_is_invalid_and_cache_is_empty()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary <string, Func <string, bool> > {
{ "foo.N1", x => true }, { "foo.N2", x => true }, { "foo.N3", x => true }
};
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
try
{
configProvider.GetAndValidateConfiguration();
Assert.Fail("Invalid configuration passed validation");
}
catch (UnableToAccessConfigurationException e)
{
Assert.IsInstanceOfType(e.InnerException, typeof(ConfigValidationException), "Expected a ConfigValidationException to be thrown");
ConfigValidationException configValidationEx = (ConfigValidationException)e.InnerException;
Assert.IsTrue(Regex.IsMatch(configValidationEx.Message, "foo.N3"), "Missing invalid parameters from validation error message");
}
}
public void Config_data_in_cache_should_always_be_validated()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(configFromMockCache);
// In this case, we have to bypass validation of the service data because the service is offline
_mockConfigServiceHttpClient = HttpClientTestHelper.CreateClientSimulatingABadAddress();
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary<string, Func<string, bool>> { { "N1.N1", x => false }, { "N1.N2", x => false } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
public void Cache_should_never_be_updated_when_invalid_data_is_retrieved_from_server()
{
ConfigRoot originalConfigFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
originalConfigFromMockCache.Data.Children[0].Value = "fromcache";
CreateMockDurableCacheEntry(originalConfigFromMockCache);
_mockConfigServiceHttpClient = HttpClientTestHelper.CreateClientThatAlwaysReturnsGibberish();
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
IConfigProvider configProvider = testFactory.Create(TestComponentName, new Dictionary<string, Func<string, bool>>());
ConfigRoot configFromProvider = configProvider.GetAndValidateConfiguration();
ConfigRoot updatedConfigFromMockCache = ReadMockDurableCacheEntry();
Assert.IsTrue(_objectComparer.Compare(originalConfigFromMockCache, updatedConfigFromMockCache).AreEqual);
Assert.IsTrue(_objectComparer.Compare(configFromProvider, originalConfigFromMockCache).AreEqual);
}
public void If_server_is_down_and_cache_is_empty_a_config_access_exception_should_be_thrown()
{
_mockConfigServiceHttpClient = HttpClientTestHelper.CreateClientSimulatingABadAddress();
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
// This validator would cause an error, but the simulated connection issue above should prevent it from hitting that.
var validators = new Dictionary<string, Func<string, bool>> { { "Taco", x => true } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
configProvider.GetAndValidateConfiguration();
}
public void Config_validation_exception_contains_missing_values_when_server_config_is_invalid_and_cache_is_empty()
{
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary<string, Func<string, bool>> { { "foo.N1", x => true }, { "foo.N2", x => true }, { "foo.N3", x => true } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
try
{
configProvider.GetAndValidateConfiguration();
Assert.Fail("Invalid configuration passed validation");
}
catch (UnableToAccessConfigurationException e)
{
Assert.IsInstanceOfType(e.InnerException, typeof(ConfigValidationException), "Expected a ConfigValidationException to be thrown");
ConfigValidationException configValidationEx = (ConfigValidationException)e.InnerException;
Assert.IsTrue(Regex.IsMatch(configValidationEx.Message, "foo.N3"), "Missing invalid parameters from validation error message");
}
}
public void Config_validation_exception_contains_missing_values_when_server_and_cache_config_is_invalid()
{
ConfigRoot configFromMockCache = MockHabitatServer.GetConfigRoot(TestComponentName);
configFromMockCache.Data.Children[0].Value = "fromcache";
configFromMockCache.Data.Children.Add(new ConfigNode { Name = "N4", Value = "V4" });
CreateMockDurableCacheEntry(configFromMockCache);
var testFactory = new ConfigProviderFactory(TestAssemblyName, _mockConfigServiceHttpClient, _mockFileSystem.Object);
var validators = new Dictionary<string, Func<string, bool>> { { "foo.N1", x => true }, { "foo.N2", x => true }, { "foo.N3", x => true }, { "foo.N4", x => true } };
IConfigProvider configProvider = testFactory.Create(TestComponentName, validators);
try
{
configProvider.GetAndValidateConfiguration();
Assert.Fail("Invalid configuration passed validation");
}
catch (UnableToAccessConfigurationException e)
{
Assert.IsInstanceOfType(e.InnerException, typeof(ConfigValidationException), "Expected a ConfigValidationException to be thrown");
ConfigValidationException configValidationEx = (ConfigValidationException)e.InnerException;
Assert.IsTrue(Regex.IsMatch(configValidationEx.Message, "foo.N3, foo.N4"), "Missing invalid parameters from validation error message");
}
}
