Added unit test for table per class discriminator using the insert attribute set to false

Modified AuditMetadataGenerator to check discriminator for insert flag and keep setting if false.

Author: Patrick Flahan

Src/NHibernate.Envers.Tests/Integration/Inheritance/TablePerClass/Discriminate/BaseEntity.cs

@@ -0,0 +1,28 @@
+using NHibernate.Envers.Configuration.Attributes;
+
+namespace NHibernate.Envers.Tests.Integration.Inheritance.TablePerClass.Discriminate
+{
+	[Audited]
+	public class BaseEntity
+	{
+		public virtual long Id { get; set; }
+		public virtual ClassTypeEntity TypeId { get; set; }
+		public virtual string Data { get; set; }
+
+		public override bool Equals(object obj)
+		{
+			var casted = obj as BaseEntity;
+			if(casted==null)
+				return false;
+
+			return Id == casted.Id
+				&& TypeId.Id == casted.TypeId.Id
+				&& string.Equals(Data, casted.Data);
+		}
+
+		public override int GetHashCode()
+		{
+			return Id.GetHashCode();
+		} 
+	}
+}

Src/NHibernate.Envers.Tests/Integration/Inheritance/TablePerClass/Discriminate/ClassTypeEntity.cs

@@ -0,0 +1,27 @@
+using NHibernate.Envers.Configuration.Attributes;
+
+namespace NHibernate.Envers.Tests.Integration.Inheritance.TablePerClass.Discriminate
+{
+	[Audited]
+	public class ClassTypeEntity
+	{
+		public const string BaseName = "base";
+		public const string SubtypeName = "subtype";
+
+		public virtual int Id { get; set; }
+		public virtual string Type { get; set; }
+
+		public override bool Equals(object obj)
+		{
+			var casted = obj as ClassTypeEntity;
+			if(casted==null)
+				return false;
+			return Id == casted.Id && Type == casted.Type;
+		}
+
+		public override int GetHashCode()
+		{
+			return Id.GetHashCode();
+		}
+	}
+}

Src/NHibernate.Envers.Tests/Integration/Inheritance/TablePerClass/Discriminate/DiscriminatorTest.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Linq;
+using NHibernate.Mapping;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Envers.Tests.Integration.Inheritance.TablePerClass.Discriminate
+{
+	/// <summary>
+	/// Provides a basic set of tests to verify when the insert attribute of the discriminator element is set
+	/// to false, that the setting will carry into the audit table settings. 
+	/// </summary>
+	public class DiscriminatorTest : TestBase
+	{
+		private BaseEntity baseEntityVer1;
+		private BaseEntity baseEntityVer2;
+		private SubtypeEntity subtypeEntityVer1;
+		private SubtypeEntity subtypeEntityVer2;
+
+		public DiscriminatorTest(AuditStrategyForTest strategyType) : base(strategyType)
+		{
+		}
+
+		/// <summary>
+		/// Perform initialization for the test
+		/// </summary>
+		protected override void Initialize()
+		{
+			var baseEntityType = new ClassTypeEntity { Type = ClassTypeEntity.BaseName };
+			var subtypeEntityType = new ClassTypeEntity { Type = ClassTypeEntity.SubtypeName };
+
+			//rev 1
+			using (var tx = Session.BeginTransaction())
+			{
+				Session.Save(baseEntityType);
+				Session.Save(subtypeEntityType);
+				tx.Commit();
+			}
+
+			//rev 2
+			var baseEntity = new BaseEntity { TypeId = baseEntityType, Data = "parent data" };
+			var subtypeEntity = new SubtypeEntity { TypeId = subtypeEntityType, Data = "child data", SubtypeData = "child specific data" };
+			using (var tx = Session.BeginTransaction())
+			{
+				Session.Save(baseEntity);
+				Session.Save(subtypeEntity);
+				tx.Commit();
+			}
+
+			//rev 3
+			using (var tx = Session.BeginTransaction())
+			{
+				baseEntity.Data = "parent data modified";
+				subtypeEntity.Data = "child data modified";
+				tx.Commit();
+			}
+
+			baseEntityVer1 = new BaseEntity { Id = baseEntity.Id, TypeId = baseEntityType, Data = "parent data" };
+			subtypeEntityVer1 = new SubtypeEntity {Id = subtypeEntity.Id, TypeId = subtypeEntityType, Data = "child data", SubtypeData = "child specific data"};
+			baseEntityVer2 = new BaseEntity {Id = baseEntity.Id, TypeId = baseEntityType, Data = "parent data modified"};
+			subtypeEntityVer2 = new SubtypeEntity { Id = subtypeEntity.Id, TypeId = subtypeEntityType, Data = "child data modified", SubtypeData = "child specific data" };
+		}
+
+		/// <summary>
+		/// This test is here to verify that the NHibernate configuration was able to complete and that the set up
+		/// performed in the Initialize method is correct.
+		/// </summary>
+		[Test]
+		public void VerifyInitializeCompleted()
+		{
+			var classTypeEntityCount = Session.Query<ClassTypeEntity>().Count();
+			Assert.IsTrue(classTypeEntityCount == 2, "Did not retrieve two ClassTypeEntity records, but received {0}", classTypeEntityCount);
+
+			var baseTypeCount = Session.Query<BaseEntity>()
+				.Where(be => be.TypeId.Id == 1)
+				.Count();
+			Assert.IsTrue(baseTypeCount == 1, "Only expected one BaseEntity record, but received {0}", baseTypeCount);
+
+			var subtypeCount = Session.Query<SubtypeEntity>().Count();
+			Assert.IsTrue(subtypeCount == 1, "Only expected one SubtypeEntity record, but received {0}", subtypeCount);
+		}
+
+		/// <summary>
+		/// Verify that revisions match for each type 
+		/// </summary>
+		[Test]
+		public void VerifyRevisionCounts()
+		{
+			CollectionAssert.AreEquivalent(new[] { 2, 3 },
+										   AuditReader().GetRevisions(typeof(BaseEntity), baseEntityVer1.Id));
+			CollectionAssert.AreEquivalent(new[] { 2, 3 },
+										   AuditReader().GetRevisions(typeof(SubtypeEntity), subtypeEntityVer1.Id));
+		}
+
+		[Test]
+		public void VerifyHistoryOfParent()
+		{
+			AuditReader().Find<BaseEntity>(baseEntityVer1.Id, 2)
+				.Should().Be.EqualTo(baseEntityVer1);
+
+			AuditReader().Find<BaseEntity>(baseEntityVer2.Id, 3)
+				.Should().Be.EqualTo(baseEntityVer2);
+		}
+
+		[Test]
+		public void VerifyHistoryOfChild()
+		{
+			AuditReader().Find<SubtypeEntity>(subtypeEntityVer1.Id, 2)
+				.Should().Be.EqualTo(subtypeEntityVer1);
+
+			AuditReader().Find<SubtypeEntity>(subtypeEntityVer2.Id, 3)
+				.Should().Be.EqualTo(subtypeEntityVer2);
+		}
+	}
+}

Src/NHibernate.Envers.Tests/Integration/Inheritance/TablePerClass/Discriminate/Mapping.hbm.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
+	assembly="NHibernate.Envers.Tests"
+	namespace="NHibernate.Envers.Tests.Integration.Inheritance.TablePerClass.Discriminate">
+
+	<class name="ClassTypeEntity">
+		<id name="Id">
+			<generator class="native"/>
+		</id>
+		<property name="Type"/>
+	</class>
+
+	<class name="BaseEntity" discriminator-value="1">
+		<id name="Id">
+			<generator class="native"/>
+		</id>
+		
+		<discriminator type="Int32" insert="false">
+			<column name="TypeId" not-null="true" sql-type="int" />
+		</discriminator>  
+	
+		<property name="Data"/>
+		<many-to-one name="TypeId" column="TypeId" class="ClassTypeEntity" />
+	</class>
+	
+	<subclass name="SubtypeEntity" extends="BaseEntity" discriminator-value="2">
+		<property name="SubtypeData" />
+	</subclass>
+	
+
+</hibernate-mapping>

Src/NHibernate.Envers.Tests/Integration/Inheritance/TablePerClass/Discriminate/SubtypeEntity.cs

@@ -0,0 +1,25 @@
+using NHibernate.Envers.Configuration.Attributes;
+
+namespace NHibernate.Envers.Tests.Integration.Inheritance.TablePerClass.Discriminate
+{
+	[Audited]
+	public class SubtypeEntity : BaseEntity
+	{
+		public virtual string SubtypeData { get; set; }
+
+		public override bool Equals(object obj)
+		{
+	 		var casted = obj as SubtypeEntity;
+			if (casted == null)
+				return false;
+
+			return base.Equals(casted)
+				&& string.Equals(SubtypeData, casted.SubtypeData);
+		}
+
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		} 
+	}
+}

Src/NHibernate.Envers/Configuration/Metadata/AuditMetadataGenerator.cs

@@ -332,6 +332,12 @@ private Tuple<XElement, IExtendedPropertyMapper, string> generateMappingData(
 				// Database column or SQL formula allowed to distinguish entity types
 				MetadataTools.AddColumnsOrFormulas(discriminatorElement, pc.Discriminator.ColumnIterator);
 				discriminatorElement.Add(new XAttribute("type", pc.Discriminator.Type.Name));
+
+				// check if the origin discriminator is not insertable and maintain setting for audit class
+				if (!pc.IsDiscriminatorInsertable)
+				{
+					discriminatorElement.Add(new XAttribute("insert", "false"));
+				}
 			}
 
 			// Adding the "revision type" property