/// <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"); } }