Applied patch from Tolomaüs adding support for setting <key> attribut…

…es on a one-to-many. Added appropriate tests.
erlis · Oct 31, 2009 · 0e26fad · 0e26fad
1 parent 57457eb
commit 0e26fad
Show file tree

Hide file tree

Showing 7 changed files with 104 additions and 1 deletion.
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/OneToManyTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/OneToManyTester.cs
@@ -922,6 +922,14 @@ public void OrderByClauseIgnoredForUnorderableCollections()
                 .Element("class/map").DoesntHaveAttribute("order-by");
         }
 
+        [Test]
+        public void CanSpecifyUniqueKey()
+        {
+            new MappingTester<OneToManyTarget>()
+                .ForMapping(m => m.HasMany(x => x.MapOfChildren).KeyColumns.Add("key_col", c => c.Unique()))
+                .Element("class/bag/key/column").HasAttribute("unique", "true");                
+        }
+
         private class TestO2MConvention : IHasManyConvention
         {
             public void Accept(IAcceptanceCriteria<IOneToManyCollectionInspector> acceptance)

diff --git a/...ntNHibernate.Testing/FluentInterfaceTests/OneToManyMutablePropertyModelGenerationTests.cs b/...ntNHibernate.Testing/FluentInterfaceTests/OneToManyMutablePropertyModelGenerationTests.cs
@@ -220,5 +220,30 @@ public void SubselectShouldSetModelSubselectToValue()
                 .Mapping(m => m.Subselect("whee"))
                 .ModelShouldMatch(x => x.Subselect.ShouldEqual("whee"));
         }
+
+        [Test]
+        public void KeyUpdateShouldSetModelValue()
+        {
+            OneToMany<ChildObject>(x => x.BagOfChildren)
+                .Mapping(m => m.KeyUpdate())
+                .ModelShouldMatch(x => x.Key.Update.ShouldBeTrue());
+        }
+
+        [Test]
+        public void KeyNullableShouldSetModelValue()
+        {
+            OneToMany<ChildObject>(x => x.BagOfChildren)
+                .Mapping(m => m.KeyNullable())
+                .ModelShouldMatch(x => x.Key.NotNull.ShouldBeFalse());
+        }
+
+        [Test]
+        public void KeyNotNullableShouldSetModelValue()
+        {
+            OneToMany<ChildObject>(x => x.BagOfChildren)
+                .Mapping(m => m.Not.KeyNullable())
+                .ModelShouldMatch(x => x.Key.NotNull.ShouldBeTrue());
+        }
+
     }
 }
diff --git a/src/FluentNHibernate.Testing/FluentInterfaceTests/OneToManySubPartModelGenerationTests.cs b/src/FluentNHibernate.Testing/FluentInterfaceTests/OneToManySubPartModelGenerationTests.cs
@@ -76,7 +76,7 @@ public void ElementMappingShouldntHaveOneToMany()
         public void ShouldPerformKeyColumnMapping()
         {
             OneToMany<ChildObject>(x => x.ListOfChildren)
-                .Mapping(m => m.KeyColumns.Add("col1", c => c.Length(50).Not.Nullable()))
+                .Mapping(m => m.KeyColumns.Add("col1", c => c.Length(50).Not.Nullable()))                
                 .ModelShouldMatch(x =>
                 {
                     var column = x.Key.Columns.Single();

diff --git a/src/FluentNHibernate.Testing/MappingModel/Output/XmlKeyWriterTester.cs b/src/FluentNHibernate.Testing/MappingModel/Output/XmlKeyWriterTester.cs
@@ -44,6 +44,34 @@ public void ShouldWriteOnDeleteAttribute()
             testHelper.VerifyAll(writer);
         }
 
+        [Test]
+        public void ShouldWriteNotNullAttribute()
+        {
+            var testHelper = new XmlWriterTestHelper<KeyMapping>();
+            testHelper.Check(x => x.NotNull, true).MapsToAttribute("not-null");
+
+            testHelper.VerifyAll(writer);
+        }
+
+        [Test]
+        public void ShouldWriteUpdateAttribute()
+        {
+            var testHelper = new XmlWriterTestHelper<KeyMapping>();
+            testHelper.Check(x => x.Update, true).MapsToAttribute("update");
+
+            testHelper.VerifyAll(writer);
+        }
+
+        [Test]
+        public void ShouldWriteUniqueAttribute()
+        {
+            var testHelper = new XmlWriterTestHelper<KeyMapping>();
+            testHelper.Check(x => x.Unique, true).MapsToAttribute("unique");
+
+            testHelper.VerifyAll(writer);
+        }
+
+
         [Test]
         public void ShouldWriteColumns()
         {

diff --git a/src/FluentNHibernate/Mapping/OneToManyPart.cs b/src/FluentNHibernate/Mapping/OneToManyPart.cs
@@ -163,5 +163,19 @@ public OneToManyPart<TChild> Subselect(string subselect)
             collectionAttributes.Set(x => x.Subselect, subselect);
             return this;
         }
+
+        public OneToManyPart<TChild> KeyUpdate()
+        {
+            keyMapping.Update = nextBool;
+            nextBool = true;
+            return this;
+        }
+
+        public OneToManyPart<TChild> KeyNullable()
+        {
+            keyMapping.NotNull = !nextBool;
+            nextBool = true;
+            return this;
+        }
     }
 }
diff --git a/src/FluentNHibernate/MappingModel/KeyMapping.cs b/src/FluentNHibernate/MappingModel/KeyMapping.cs
@@ -45,6 +45,24 @@ public string OnDelete
             set { attributes.Set(x => x.OnDelete, value); }
         }
 
+        public bool NotNull
+        {
+            get { return attributes.Get(x => x.NotNull); }
+            set { attributes.Set(x => x.NotNull, value); }
+        }
+
+        public bool Update
+        {
+            get { return attributes.Get(x => x.Update); }
+            set { attributes.Set(x => x.Update, value); }
+        }
+
+        public bool Unique
+        {
+            get { return attributes.Get(x => x.Unique); }
+            set { attributes.Set(x => x.Unique, value); }
+        }
+
         public IDefaultableEnumerable<ColumnMapping> Columns
         {
             get { return columns; }

diff --git a/src/FluentNHibernate/MappingModel/Output/XmlKeyWriter.cs b/src/FluentNHibernate/MappingModel/Output/XmlKeyWriter.cs
@@ -34,6 +34,16 @@ public override void ProcessKey(KeyMapping mapping)
 
             if (mapping.HasValue(x => x.PropertyRef))
                 element.WithAtt("property-ref", mapping.PropertyRef);
+
+            if (mapping.HasValue(x => x.NotNull))
+                element.WithAtt("not-null", mapping.NotNull);
+
+            if (mapping.HasValue(x => x.Update))
+                element.WithAtt("update", mapping.Update);
+
+            if (mapping.HasValue(x => x.Unique))
+                element.WithAtt("unique", mapping.Unique);
+
         }
 
         public override void Visit(ColumnMapping mapping)