Ability to replace ConfigurationManager with a custom config provider (#2116)

bahusoid · hazzik · commit dceb7fa05a01 · 2019-10-17T10:17:57.000+13:00
- Introduced abstract class ConfigurationProvider exposed as ConfigurationProvider.Current. To skip all configuration calls (fix for Xamarin) just set it to null: ConfigurationProvider.Current = null; Fixes #2105
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2420/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2420/Fixture.cs
@@ -11,8 +11,8 @@
 using System.Data.Common;
 using System.Data.Odbc;
 using System.Data.SqlClient;
-using System.Configuration;
 using System.Transactions;
+using NHibernate.Cfg;
 using NHibernate.Dialect;
 using NHibernate.Driver;
 using NHibernate.Engine;
@@ -43,9 +43,7 @@ private string FetchConnectionStringFromConfiguration()
 			string connectionStringName;
 			if (cfg.Properties.TryGetValue(Environment.ConnectionStringName, out connectionStringName))
 			{
-				var connectionStringSettings = ConfigurationManager.ConnectionStrings[connectionStringName];
-				Assert.That(connectionStringSettings, Is.Not.Null);
-				connectionString = connectionStringSettings.ConnectionString;
+				connectionString = ConfigurationProvider.Current.GetNamedConnectionString(connectionStringName);
 				Assert.That(connectionString, Is.Not.Null.Or.Empty);
 				return connectionString;
 			}
diff --git a/src/NHibernate.Test/CfgTest/ConfigurationSchemaFixture.cs b/src/NHibernate.Test/CfgTest/ConfigurationSchemaFixture.cs
@@ -1,4 +1,3 @@
-using System.Configuration;
 using NHibernate.Event;
 using NUnit.Framework;
 using NHibernate.Cfg;
@@ -26,9 +25,7 @@ public void SessionFactoryIsRequiredWhenConfigurationIsNotLoadedFromAppConfig()
 		[Test]
 		public void FromAppConfigTest()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
-			IHibernateConfiguration hc = ConfigurationManager.GetSection("hibernate-configuration") as IHibernateConfiguration;
+			IHibernateConfiguration hc = ConfigurationProvider.Current.GetConfiguration();
 			Assert.That(hc.ByteCodeProviderType, Is.EqualTo("lcg"));
 			Assert.IsTrue(hc.UseReflectionOptimizer);
 			Assert.AreEqual("NHibernate.Test", hc.SessionFactory.Name);
@@ -37,8 +34,6 @@ public void FromAppConfigTest()
 		[Test]
 		public void ByteCodeProvider()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
 			var xml =
 				@"<?xml version='1.0' encoding='utf-8' ?>
 <hibernate-configuration xmlns='urn:nhibernate-configuration-2.2'>
@@ -54,9 +49,7 @@ public void ByteCodeProvider()
 		[Test]
 		public void IgnoreSystemOutOfAppConfig()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
-			IHibernateConfiguration hc = ConfigurationManager.GetSection("hibernate-configuration") as IHibernateConfiguration;
+			IHibernateConfiguration hc = ConfigurationProvider.Current.GetConfiguration();
 			string xml =
 			@"<?xml version='1.0' encoding='utf-8' ?>
 <hibernate-configuration xmlns='urn:nhibernate-configuration-2.2'>
@@ -75,8 +68,6 @@ public void IgnoreSystemOutOfAppConfig()
 		[Test]
 		public void ObjectsFactory()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
 			var xml =
 				@"<?xml version='1.0' encoding='utf-8' ?>
 <hibernate-configuration xmlns='urn:nhibernate-configuration-2.2'>
diff --git a/src/NHibernate.Test/ConnectionStringTest/NamedConnectionStringFixture.cs b/src/NHibernate.Test/ConnectionStringTest/NamedConnectionStringFixture.cs
@@ -35,8 +35,6 @@ public void ConnectionStringInSettingsOverrideNamedConnectionSTring()
 		[Test]
 		public void CanGetNamedConnectionStringFromConfiguration()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
 			Dictionary<string, string> settings = new Dictionary<string, string>();
 			settings.Add(Environment.ConnectionStringName, "DummyConnectionString");
 			MockConnectionProvider cp = new MockConnectionProvider();
diff --git a/src/NHibernate.Test/Logging/LoggerProviderTest.cs b/src/NHibernate.Test/Logging/LoggerProviderTest.cs
@@ -24,17 +24,13 @@ public void LoggerProviderCanCreateLoggers_Obsolete()
 		[Test]
 		public void WhenNotConfiguredAndLog4NetExistsThenUseLog4NetFactory()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
 			// NoLoggingNHibernateLogger is internal
 			Assert.That(NHibernateLogger.For("pizza").GetType().Name, Is.Not.EqualTo("NoLoggingNHibernateLogger"));
 		}
 
 		[Test, Obsolete]
 		public void WhenNotConfiguredAndLog4NetExistsThenUseLog4NetFactory_Obsolete()
 		{
-			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
-
 			Assert.That(LoggerProvider.LoggerFor("pizza"), Is.Not.InstanceOf<NoLoggingInternalLogger>());
 
 			// works because this is the legacy provider with a legacy logger
diff --git a/src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs
@@ -1,8 +1,8 @@
 ﻿using System.Data.Common;
 using System.Data.Odbc;
 using System.Data.SqlClient;
-using System.Configuration;
 using System.Transactions;
+using NHibernate.Cfg;
 using NHibernate.Dialect;
 using NHibernate.Driver;
 using NHibernate.Engine;
@@ -32,9 +32,7 @@ private string FetchConnectionStringFromConfiguration()
 			string connectionStringName;
 			if (cfg.Properties.TryGetValue(Environment.ConnectionStringName, out connectionStringName))
 			{
-				var connectionStringSettings = ConfigurationManager.ConnectionStrings[connectionStringName];
-				Assert.That(connectionStringSettings, Is.Not.Null);
-				connectionString = connectionStringSettings.ConnectionString;
+				connectionString = ConfigurationProvider.Current.GetNamedConnectionString(connectionStringName);
 				Assert.That(connectionString, Is.Not.Null.Or.Empty);
 				return connectionString;
 			}
diff --git a/src/NHibernate.Test/TestsContext.cs b/src/NHibernate.Test/TestsContext.cs
@@ -1,46 +1,33 @@
-﻿using NUnit.Framework;
+﻿#if NETCOREAPP2_0
+using NUnit.Framework;
 
-#if NETCOREAPP2_0
 using System.Configuration;
 using System.IO;
 using log4net.Repository.Hierarchy;
 using NHibernate.Cfg;
-using NHibernate.Cfg.ConfigurationSchema;
-#endif
 
 namespace NHibernate.Test
 {
-#if NETCOREAPP2_0
 	[SetUpFixture]
-#endif
 	public class TestsContext
 	{
-		public static bool ExecutingWithVsTest { get; } =
+		private static bool ExecutingWithVsTest { get; } =
 			System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name == "testhost";
 
-#if NETCOREAPP2_0
 		[OneTimeSetUp]
 		public void RunBeforeAnyTests()
 		{
 			//When .NET Core App 2.0 tests run from VS/VSTest the entry assembly is "testhost.dll"
 			//so we need to explicitly load the configuration
 			if (ExecutingWithVsTest)
 			{
-				Environment.InitializeGlobalProperties(GetTestAssemblyHibernateConfiguration());
+				var assemblyPath = Path.Combine(TestContext.CurrentContext.TestDirectory, Path.GetFileName(typeof(TestsContext).Assembly.Location));
+				ConfigurationProvider.Current = new SystemConfigurationProvider(ConfigurationManager.OpenExeConfiguration(assemblyPath));
 			}
 
 			ConfigureLog4Net();
 		}
 
-		public static IHibernateConfiguration GetTestAssemblyHibernateConfiguration()
-		{
-			var assemblyPath =
- Path.Combine(TestContext.CurrentContext.TestDirectory, Path.GetFileName(typeof(TestsContext).Assembly.Location));
-			var configuration = ConfigurationManager.OpenExeConfiguration(assemblyPath);
-			var section = configuration.GetSection(CfgXmlHelper.CfgSectionName);
-			return HibernateConfiguration.FromAppConfig(section.SectionInformation.GetRawXml());
-		}
-
 		private static void ConfigureLog4Net()
 		{
 			var hierarchy = (Hierarchy)log4net.LogManager.GetRepository(typeof(TestsContext).Assembly);
@@ -58,6 +45,6 @@ private static void ConfigureLog4Net()
 			hierarchy.Root.AddAppender(consoleAppender);
 			hierarchy.Configured = true;
 		}
-#endif
 	}
 }
+#endif
diff --git a/src/NHibernate/Async/Connection/ConnectionProvider.cs b/src/NHibernate/Async/Connection/ConnectionProvider.cs
@@ -10,7 +10,6 @@
 
 using System;
 using System.Collections;
-using System.Configuration;
 using System.Data.Common;
 
 using NHibernate.Driver;
diff --git a/src/NHibernate/Cfg/AppSettings.cs b/src/NHibernate/Cfg/AppSettings.cs
@@ -0,0 +1,13 @@
+namespace NHibernate.Cfg
+{
+	/// <summary>
+	/// Configuration App Settings
+	/// </summary>
+	public static class AppSettings
+	{
+		/// <summary>
+		/// Type that implements <see cref="INHibernateLoggerFactory"/>
+		/// </summary>
+		public const string LoggerFactoryClassName = "nhibernate-logger";
+	}
+}
diff --git a/src/NHibernate/Cfg/ConfigurationProvider.cs b/src/NHibernate/Cfg/ConfigurationProvider.cs
@@ -0,0 +1,29 @@
+namespace NHibernate.Cfg
+{
+	/// <summary>
+	/// Base class for NHibernate configuration settings
+	/// </summary>
+	public abstract class ConfigurationProvider
+	{
+		private static ConfigurationProvider _current = new StaticConfigurationManagerProvider();
+
+		/// <summary>
+		/// Provides ability to override default <see cref="System.Configuration.ConfigurationManager"/> with custom implementation.
+		/// Can be set to null if all configuration is specified by code 
+		/// </summary>
+		public static ConfigurationProvider Current
+		{
+			get => _current;
+			set => _current = value ?? new NullConfigurationProvider();
+		}
+
+		public abstract IHibernateConfiguration GetConfiguration();
+
+		public abstract string GetNamedConnectionString(string name);
+
+		/// <summary>
+		/// Type that implements <see cref="INHibernateLoggerFactory"/>
+		/// </summary>
+		public abstract string GetLoggerFactoryClassName();
+	}
+}
diff --git a/src/NHibernate/Cfg/Environment.cs b/src/NHibernate/Cfg/Environment.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Configuration;
 using System.Reflection;
 
 using NHibernate.Bytecode;
@@ -382,19 +381,10 @@ public static void InitializeGlobalProperties(IHibernateConfiguration config)
 
 		private static IHibernateConfiguration GetHibernateConfiguration()
 		{
-			object config = ConfigurationManager.GetSection(CfgXmlHelper.CfgSectionName);
-			if (config == null)
+			var nhConfig = ConfigurationProvider.Current.GetConfiguration();
+			if (nhConfig == null && log.IsInfoEnabled())
 			{
 				log.Info("{0} section not found in application configuration file", CfgXmlHelper.CfgSectionName);
-				return null;
-			}
-
-			var nhConfig = config as IHibernateConfiguration;
-			if (nhConfig == null)
-			{
-				log.Info(
-					"{0} section handler, in application configuration file, is not IHibernateConfiguration, section ignored",
-					CfgXmlHelper.CfgSectionName);
 			}
 
 			return nhConfig;
@@ -566,7 +556,6 @@ private static IObjectsFactory CreateCustomObjectsFactory(string assemblyQualifi
 			}
 		}
 
-
 		/// <summary>
 		/// Get a named connection string, if configured.
 		/// </summary>
@@ -576,18 +565,13 @@ private static IObjectsFactory CreateCustomObjectsFactory(string assemblyQualifi
 		/// </exception>
 		internal static string GetNamedConnectionString(IDictionary<string, string> settings)
 		{
-			string connStringName;
-			if (!settings.TryGetValue(ConnectionStringName, out connStringName))
+			if (!settings.TryGetValue(ConnectionStringName, out var connStringName))
 				return null;
 
-			ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings[connStringName];
-			if (connectionStringSettings == null)
-				throw new HibernateException($"Could not find named connection string '{connStringName}'.");
-
-			return connectionStringSettings.ConnectionString;
+			return ConfigurationProvider.Current.GetNamedConnectionString(connStringName)
+			       ?? throw new HibernateException($"Could not find named connection string '{connStringName}'.");
 		}
 
-
 		/// <summary>
 		/// Get the configured connection string, from <see cref="ConnectionString"/> if that
 		/// is set, otherwise from <see cref="ConnectionStringName"/>, or null if that isn't
diff --git a/src/NHibernate/Cfg/NullConfigurationProvider.cs b/src/NHibernate/Cfg/NullConfigurationProvider.cs
@@ -0,0 +1,20 @@
+namespace NHibernate.Cfg
+{
+	class NullConfigurationProvider : ConfigurationProvider
+	{
+		public override IHibernateConfiguration GetConfiguration()
+		{
+			return null;
+		}
+
+		public override string GetNamedConnectionString(string name)
+		{
+			return null;
+		}
+
+		public override string GetLoggerFactoryClassName()
+		{
+			return null;
+		}
+	}
+}
diff --git a/src/NHibernate/Cfg/StaticConfigurationManagerProvider.cs b/src/NHibernate/Cfg/StaticConfigurationManagerProvider.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Configuration;
+using System.Linq;
+using NHibernate.Cfg.ConfigurationSchema;
+
+namespace NHibernate.Cfg
+{
+	class StaticConfigurationManagerProvider : ConfigurationProvider
+	{
+		public override IHibernateConfiguration GetConfiguration()
+		{
+			//TODO 6.0: Throw if not null and not IHibernateConfiguration
+			return ConfigurationManager.GetSection(CfgXmlHelper.CfgSectionName) as IHibernateConfiguration;
+		}
+
+		public override string GetNamedConnectionString(string name)
+		{
+			return ConfigurationManager.ConnectionStrings[name]?.ConnectionString;
+		}
+
+		public override string GetLoggerFactoryClassName()
+		{
+			var name = AppSettings.LoggerFactoryClassName;
+			var value = ConfigurationManager.AppSettings[name];
+
+			//TODO 6.0:  Return value right away. Don't do ignore case search and document it as possible breaking change.
+			if (value != null)
+				return value;
+
+			return GetAppSettingIgnoreCase(name);
+		}
+
+		//TODO 6.0: Remove it
+		private static string GetAppSettingIgnoreCase(string name)
+		{
+			var key = ConfigurationManager.AppSettings.Keys.Cast<string>().FirstOrDefault(k => name.Equals(k, StringComparison.OrdinalIgnoreCase));
+			return string.IsNullOrEmpty(key)
+				? null
+				: ConfigurationManager.AppSettings[key];
+		}
+	}
+}
diff --git a/src/NHibernate/Cfg/SystemConfigurationProvider.cs b/src/NHibernate/Cfg/SystemConfigurationProvider.cs
@@ -0,0 +1,40 @@
+using System.Configuration;
+using NHibernate.Cfg.ConfigurationSchema;
+
+namespace NHibernate.Cfg
+{
+	/// <summary>
+	/// Configuration manager that supports user provided configuration
+	/// </summary>
+	public class SystemConfigurationProvider : ConfigurationProvider
+	{
+		private readonly System.Configuration.Configuration _configuration;
+
+		public SystemConfigurationProvider(System.Configuration.Configuration configuration)
+		{
+			_configuration = configuration;
+		}
+
+		public override IHibernateConfiguration GetConfiguration()
+		{
+			ConfigurationSection configurationSection = _configuration.GetSection(CfgXmlHelper.CfgSectionName);
+			var xml = configurationSection?.SectionInformation.GetRawXml();
+			return xml == null ? null : HibernateConfiguration.FromAppConfig(xml);
+		}
+
+		public override string GetNamedConnectionString(string name)
+		{
+			return _configuration.ConnectionStrings.ConnectionStrings[name]?.ConnectionString;
+		}
+
+		public override string GetLoggerFactoryClassName()
+		{
+			return GetAppSetting(AppSettings.LoggerFactoryClassName);
+		}
+
+		private string GetAppSetting(string name)
+		{
+			return  _configuration.AppSettings.Settings[name]?.Value;
+		}
+	}
+}
diff --git a/src/NHibernate/Connection/ConnectionProvider.cs b/src/NHibernate/Connection/ConnectionProvider.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections;
-using System.Configuration;
 using System.Data.Common;
 
 using NHibernate.Driver;
diff --git a/src/NHibernate/Logging.cs b/src/NHibernate/Logging.cs

Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,6 @@ public void ConnectionStringInSettingsOverrideNamedConnectionSTring()`
`35`	`35`	`[Test]`
`36`	`36`	`public void CanGetNamedConnectionStringFromConfiguration()`
`37`	`37`	`{`
`38`		`- Assume.That(TestsContext.ExecutingWithVsTest, Is.False);`
`39`		`-`
`40`	`38`	`Dictionary<string, string> settings = new Dictionary<string, string>();`
`41`	`39`	`settings.Add(Environment.ConnectionStringName, "DummyConnectionString");`
`42`	`40`	`MockConnectionProvider cp = new MockConnectionProvider();`
Original file line number	Diff line number	Diff line change
`@@ -24,17 +24,13 @@ public void LoggerProviderCanCreateLoggers_Obsolete()`
`24`	`24`	`[Test]`
`25`	`25`	`public void WhenNotConfiguredAndLog4NetExistsThenUseLog4NetFactory()`
`26`	`26`	`{`
`27`		`- Assume.That(TestsContext.ExecutingWithVsTest, Is.False);`
`28`		`-`
`29`	`27`	`// NoLoggingNHibernateLogger is internal`
`30`	`28`	`Assert.That(NHibernateLogger.For("pizza").GetType().Name, Is.Not.EqualTo("NoLoggingNHibernateLogger"));`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`[Test, Obsolete]`
`34`	`32`	`public void WhenNotConfiguredAndLog4NetExistsThenUseLog4NetFactory_Obsolete()`
`35`	`33`	`{`
`36`		`- Assume.That(TestsContext.ExecutingWithVsTest, Is.False);`
`37`		`-`
`38`	`34`	`Assert.That(LoggerProvider.LoggerFor("pizza"), Is.Not.InstanceOf<NoLoggingInternalLogger>());`
`39`	`35`
`40`	`36`	`// works because this is the legacy provider with a legacy logger`
Original file line number	Diff line number	Diff line change
`@@ -1,46 +1,33 @@`
`1`		`-using NUnit.Framework;`
	`1`	`+#if NETCOREAPP2_0`
	`2`	`+using NUnit.Framework;`
`2`	`3`
`3`		`-#if NETCOREAPP2_0`
`4`	`4`	`using System.Configuration;`
`5`	`5`	`using System.IO;`
`6`	`6`	`using log4net.Repository.Hierarchy;`
`7`	`7`	`using NHibernate.Cfg;`
`8`		`-using NHibernate.Cfg.ConfigurationSchema;`
`9`		`-#endif`
`10`	`8`
`11`	`9`	`namespace NHibernate.Test`
`12`	`10`	`{`
`13`		`-#if NETCOREAPP2_0`
`14`	`11`	`[SetUpFixture]`
`15`		`-#endif`
`16`	`12`	`public class TestsContext`
`17`	`13`	`{`
`18`		`- public static bool ExecutingWithVsTest { get; } =`
	`14`	`+ private static bool ExecutingWithVsTest { get; } =`
`19`	`15`	`System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name == "testhost";`
`20`	`16`
`21`		`-#if NETCOREAPP2_0`
`22`	`17`	`[OneTimeSetUp]`
`23`	`18`	`public void RunBeforeAnyTests()`
`24`	`19`	`{`
`25`	`20`	`//When .NET Core App 2.0 tests run from VS/VSTest the entry assembly is "testhost.dll"`
`26`	`21`	`//so we need to explicitly load the configuration`
`27`	`22`	`if (ExecutingWithVsTest)`
`28`	`23`	`{`
`29`		`- Environment.InitializeGlobalProperties(GetTestAssemblyHibernateConfiguration());`
	`24`	`+ var assemblyPath = Path.Combine(TestContext.CurrentContext.TestDirectory, Path.GetFileName(typeof(TestsContext).Assembly.Location));`
	`25`	`+ ConfigurationProvider.Current = new SystemConfigurationProvider(ConfigurationManager.OpenExeConfiguration(assemblyPath));`
`30`	`26`	`}`
`31`	`27`
`32`	`28`	`ConfigureLog4Net();`
`33`	`29`	`}`
`34`	`30`
`35`		`- public static IHibernateConfiguration GetTestAssemblyHibernateConfiguration()`
`36`		`- {`
`37`		`- var assemblyPath =`
`38`		`- Path.Combine(TestContext.CurrentContext.TestDirectory, Path.GetFileName(typeof(TestsContext).Assembly.Location));`
`39`		`- var configuration = ConfigurationManager.OpenExeConfiguration(assemblyPath);`
`40`		`- var section = configuration.GetSection(CfgXmlHelper.CfgSectionName);`
`41`		`- return HibernateConfiguration.FromAppConfig(section.SectionInformation.GetRawXml());`
`42`		`- }`
`43`		`-`
`44`	`31`	`private static void ConfigureLog4Net()`
`45`	`32`	`{`
`46`	`33`	`var hierarchy = (Hierarchy)log4net.LogManager.GetRepository(typeof(TestsContext).Assembly);`
`@@ -58,6 +45,6 @@ private static void ConfigureLog4Net()`
`58`	`45`	`hierarchy.Root.AddAppender(consoleAppender);`
`59`	`46`	`hierarchy.Configured = true;`
`60`	`47`	`}`
`61`		`-#endif`
`62`	`48`	`}`
`63`	`49`	`}`
	`50`	`+#endif`