Ported some tests

SVN: trunk@5785

Author: fabiomaulo

src/NHibernate.Test/MappingByCode/TypeExtensionsTests/CompatibilityWithCandidatePersistentMembers.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate.Mapping.ByCode;
+using NHibernate.Mapping.ByCode.Impl;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class CompatibilityWithCandidatePersistentMembers
+	{
+		public abstract class Geo
+		{
+			public string Descrition { get; set; }
+			protected Geo Parent { get; set; }
+			protected ICollection<Geo> Elements { get; set; }
+		}
+
+		[Test]
+		public void GetFirstPropertyOfTypeShouldUseSameConceptsOfCandidatePersistentMembersProvider()
+		{
+			var memberProvider = new DefaultCandidatePersistentMembersProvider();
+			var properties = memberProvider.GetRootEntityMembers(typeof(Geo));
+			if(properties.Select(p => p.Name).Contains("Parent"))
+			{
+				typeof(Geo).GetFirstPropertyOfType(typeof(Geo)).Should().Not.Be.Null();
+			}
+		}
+	}
+}

src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorConcreteClassesTest.cs

@@ -0,0 +1,53 @@
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetFirstImplementorConcreteClassesTest
+	{
+		private class MyClass1
+		{
+
+		}
+		private class MyClass2 : MyClass1
+		{
+
+		}
+		private class MyClass3 : MyClass2
+		{
+
+		}
+		private class MyClass4 : MyClass3
+		{
+
+		}
+
+		[Test]
+		public void WhenImplIsAtSameLevelThenReturnImplementor()
+		{
+			typeof(MyClass1).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass3)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass4)).Should().Be(typeof(MyClass4));
+		}
+
+		[Test]
+		public void WhenImplIsAtDifferentLevelThenReturnImplementor()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass3)).Should().Be(typeof(MyClass4));
+		}
+
+		[Test]
+		public void WhenImplIsAtUpLevelThenReturnNull()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass3)).Should().Be.Null();
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass4)).Should().Be.Null();
+		}
+	}
+}

src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorTest.cs

@@ -0,0 +1,78 @@
+using System;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetFirstImplementorTest
+	{
+		private interface IInterfaceNoImpl
+		{
+
+		}
+		private interface IInterface1
+		{
+			
+		}
+		private interface IInterface2
+		{
+
+		}
+		private interface IInterface3
+		{
+
+		}
+		private class MyClassNoInterface
+		{
+
+		}
+		private class MyClass1: IInterface1
+		{
+			
+		}
+		private class MyClass2: MyClass1, IInterface2
+		{
+
+		}
+		private class MyClass3 : MyClass2, IInterface3
+		{
+
+		}
+
+		[Test]
+		public void WhenInvalidThenThrows()
+		{
+			Executing.This(()=>((System.Type) null).GetFirstImplementorOf(typeof(IInterfaceNoImpl))).Should().Throw<ArgumentNullException>();
+			Executing.This(() => typeof(IInterfaceNoImpl).GetFirstImplementorOf(null)).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenIsInterfaceThenNoImplementor()
+		{
+			typeof(IInterfaceNoImpl).GetFirstImplementorOf(typeof(IInterfaceNoImpl)).Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenImplAsNoInterfaceThenNoImplementor()
+		{
+			typeof(MyClassNoInterface).GetFirstImplementorOf(typeof(IInterfaceNoImpl)).Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenImplIsAtSameLevelThenReturnImplementor()
+		{
+			typeof(MyClass1).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass2).GetFirstImplementorOf(typeof(IInterface2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface3)).Should().Be(typeof(MyClass3));
+		}
+
+		[Test]
+		public void WhenImplIsAtDifferentLevelThenReturnImplementor()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+		}
+	}
+}

src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromInterfacesTest.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetMemberFromInterfacesTest
+	{
+		private class BaseEntity
+		{
+			public int Id { get; set; }
+		}
+
+		private interface IEntity
+		{
+			bool IsValid { get; }
+			string Something { get; set; }
+		}
+
+		private interface IHasSomething
+		{
+			string Something { get; set; }
+		}
+
+		private class Person : BaseEntity, IEntity, IHasSomething
+		{
+			private int someField;
+			public string Name { get; set; }
+			public bool IsValid { get { return false; } }
+			public string Something { get; set; }
+		}
+
+		private interface IInheritedHasSomething : IHasSomething
+		{
+			string Blah { get; set; }
+		}
+
+
+		[Test]
+		public void WhenNullArgumentThenThrows()
+		{
+			Executing.This(() => ((MemberInfo)null).GetPropertyFromInterfaces().ToList()).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenNoInterfaceThenEmptyList()
+		{
+			For<BaseEntity>.Property(x=> x.Id).GetPropertyFromInterfaces().Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenFieldThenEmptyList()
+		{
+			ForClass<Person>.Field("someField").GetPropertyFromInterfaces().Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenOneInterfaceThenReturnMemberInfoOfInterface()
+		{
+			var members = For<Person>.Property(x => x.IsValid).GetPropertyFromInterfaces();
+			members.Single().Should().Be(For<IEntity>.Property(x=> x.IsValid));
+		}
+
+		[Test]
+		public void WhenTwoInterfacesThenReturnMemberInfoOfEachInterface()
+		{
+			var members = For<Person>.Property(x => x.Something).GetPropertyFromInterfaces();
+			members.Should().Contain(For<IEntity>.Property(x => x.Something));
+			members.Should().Contain(For<IHasSomething>.Property(x => x.Something));
+		}
+
+		[Test]
+		public void WhenPropertyOfInterfaceThenNotThrows()
+		{
+			var member = For<IInheritedHasSomething>.Property(x => x.Blah);
+			member.Executing(x=> x.GetPropertyFromInterfaces().Any()).NotThrows();
+		}
+	}
+}