Replace IObjectsFactory with IServiceProvider interface.

Author: maca88

src/NHibernate.Test/Bytecode/ActivatorObjectFactoryFixture.cs

@@ -0,0 +1,75 @@
+using System;
+using NHibernate.Bytecode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Bytecode
+{
+	[TestFixture]
+	public class DefaultServiceProviderFixture
+	{
+		public class WithOutPublicParameterLessCtor
+		{
+			public string Something { get; set; }
+			protected WithOutPublicParameterLessCtor() { }
+
+			public WithOutPublicParameterLessCtor(string something)
+			{
+				Something = something;
+			}
+		}
+
+		public class PublicParameterLessCtor
+		{
+		}
+
+		protected virtual IServiceProvider GetServiceProvider()
+		{
+			return new DefaultServiceProvider();
+		}
+
+		[Test]
+		public void CreateInstanceDefCtor()
+		{
+			var sp = GetServiceProvider();
+			Assert.Throws<ArgumentNullException>(() => sp.GetService(null));
+			Assert.Throws<MissingMethodException>(() => sp.GetService(typeof(WithOutPublicParameterLessCtor)));
+			var instance = sp.GetService(typeof(PublicParameterLessCtor));
+			Assert.That(instance, Is.Not.Null);
+			Assert.That(instance, Is.InstanceOf<PublicParameterLessCtor>());
+		}
+
+
+		[Test]
+		public void RegisterService()
+		{
+			var sp = new DefaultServiceProvider();
+
+			Assert.That(sp.GetService(typeof(IInterceptor)), Is.Null);
+
+			sp.Register<IInterceptor, EmptyInterceptor>();
+			var instance = sp.GetService(typeof(IInterceptor));
+			Assert.That(instance, Is.Not.Null);
+			Assert.That(instance, Is.InstanceOf<EmptyInterceptor>());
+
+			Assert.Throws<InvalidOperationException>(() => sp.Register<IInterceptor, EmptyInterceptor>(), "service should not be registered twice.");
+			Assert.Throws<InvalidOperationException>(() => sp.Register<Dialect.Dialect, Dialect.Dialect>(), "non concrete implementation type should not be permitted.");
+			Assert.Throws<InvalidOperationException>(() => sp.Register(typeof(Dialect.Dialect), typeof(EmptyInterceptor)), "concrete implementation type should derive from service type.");
+		}
+
+		[Test]
+		public void RegisterServiceCreator()
+		{
+			var sp = new DefaultServiceProvider();
+
+			Assert.That(sp.GetService(typeof(IInterceptor)), Is.Null);
+
+			sp.Register<IInterceptor>(() => new EmptyInterceptor());
+			var instance = sp.GetService(typeof(IInterceptor));
+			Assert.That(instance, Is.Not.Null);
+			Assert.That(instance, Is.InstanceOf<EmptyInterceptor>());
+
+			Assert.Throws<InvalidOperationException>(() => sp.Register<IInterceptor>(() => new EmptyInterceptor()), "service should not be registered twice.");
+		}
+
+	}
+}

src/NHibernate.Test/Bytecode/DefaultServiceProviderFixture.cs

@@ -73,14 +73,14 @@ public void IgnoreSystemOutOfAppConfig()
 		}
 
 		[Test]
-		public void ObjectsFactory()
+		public void ServiceProvider()
 		{
 			Assume.That(TestsContext.ExecutingWithVsTest, Is.False);
 
 			var xml =
 				@"<?xml version='1.0' encoding='utf-8' ?>
 <hibernate-configuration xmlns='urn:nhibernate-configuration-2.2'>
-		<objects-factory type='test'/>
+		<service-provider type='test'/>
 		<session-factory>
 		</session-factory>
 </hibernate-configuration>";
@@ -89,11 +89,11 @@ public void ObjectsFactory()
 			using (var xtr = new XmlTextReader(xml, XmlNodeType.Document, null))
 			{
 				hc = new HibernateConfiguration(xtr);
-				Assert.That(hc.ObjectsFactoryType, Is.Null);
+				Assert.That(hc.ServiceProviderType, Is.Null);
 			}
 
 			hc = HibernateConfiguration.FromAppConfig(xml);
-			Assert.That(hc.ObjectsFactoryType, Is.EqualTo("test"));
+			Assert.That(hc.ServiceProviderType, Is.EqualTo("test"));
 		}
 
 		[Test]

src/NHibernate.Test/CfgTest/ConfigurationSchemaFixture.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using NHibernate.Bytecode;
+using NUnit.Framework;
+using Environment = NHibernate.Cfg.Environment;
+
+namespace NHibernate.Test.CfgTest
+{
+	[TestFixture]
+	public class CustomServiceProviderTest
+	{
+		private class MyServiceProvider : IServiceProvider
+		{
+			public object GetService(System.Type serviceType)
+			{
+				throw new NotImplementedException();
+			}
+		}
+		private class InvalidServiceProvider
+		{
+		}
+		private class InvalidNoCtorServiceProvider : MyServiceProvider
+		{
+			public InvalidNoCtorServiceProvider(string pizza) {}
+		}
+
+		[Test]
+		public void WhenNoShortCutUsedThenCanBuildServiceProvider()
+		{
+			var properties = new Dictionary<string, string> { { Environment.PropertyBytecodeProvider, typeof(MyServiceProvider).AssemblyQualifiedName } };
+			Assert.That(() => Environment.BuildServiceProvider(properties), Throws.Nothing);
+		}
+
+		[Test]
+		public void WhenNoShortCutUsedThenCanBuildInstanceOfConfiguredServiceProvider()
+		{
+			var properties = new Dictionary<string, string> { { Environment.PropertyServiceProvider, typeof(MyServiceProvider).AssemblyQualifiedName } };
+			Assert.That(Environment.BuildServiceProvider(properties), Is.InstanceOf<MyServiceProvider>());
+		}
+
+		[Test]
+		public void WhenInvalidThenThrow()
+		{
+			var properties = new Dictionary<string, string> { { Environment.PropertyServiceProvider, typeof(InvalidServiceProvider).AssemblyQualifiedName } };
+			Assert.That(() => Environment.BuildServiceProvider(properties), Throws.TypeOf<HibernateServiceProviderException>());
+		}
+
+		[Test]
+		public void WhenNoDefaultCtorThenThrow()
+		{
+			var properties = new Dictionary<string, string> { { Environment.PropertyServiceProvider, typeof(InvalidNoCtorServiceProvider).AssemblyQualifiedName } };
+			Assert.That(() => Environment.BuildServiceProvider(properties), Throws.TypeOf<HibernateServiceProviderException>()
+																				   .And.InnerException.Message.Contains("constructor was not found"));
+		}
+	}
+}