added a class diagram giving an overview over the inheritance of the test

.gitignore

@@ -14,4 +14,7 @@
 _ReSharper*/
 *.vs10x
 Source/Gallio Reports
-Source/TestResults
+Source/TestResults
+Source/_UpgradeReport_Files/
+*.orig
+Source/UpgradeLog*

Source/FluentMetadata.Core.Specs/ClassMetadata_with_Person.cs

@@ -1,3 +1,5 @@
+using System.Linq;
+using FluentMetadata.Rules;
 using FluentMetadata.Specs.SampleClasses;
 using Xunit;
 
@@ -10,26 +12,41 @@ public class ClassMetadata_with_Person : MetadataTestBase
         public ClassMetadata_with_Person()
         {
             var query = new QueryFluentMetadata();
-            classMetadata = query.GetMetadataFor(typeof (Person));
+            classMetadata = query.GetMetadataFor(typeof(Person));
         }
 
         [Fact]
         public void Metadata_ModelType_is_Person()
         {
-            Assert.Equal(typeof (Person), classMetadata.ModelType);
+            Assert.Equal(typeof(Person), classMetadata.ModelType);
         }
 
         [Fact]
         public void Metadata_ModelName_is_Null()
         {
-                Assert.Null(classMetadata.ModelName);
-//            Assert.Equal("Person", classMetadata.ModelName);
+            Assert.Null(classMetadata.ModelName);
         }
 
         [Fact]
         public void Metadata_Display_is_Benutzer()
         {
             Assert.Equal("Benutzer", classMetadata.DisplayName);
         }
+
+        [Fact]
+        public void Instance_with_FirstName_different_from_LastName_is_invalid()
+        {
+            var rule = classMetadata.Rules.OfType<PropertyMustMatchRule<Person>>().Last();
+            var person = new Person { FirstName = "foo", LastName = "bar" };
+            Assert.False(rule.IsValid(person));
+        }
+
+        [Fact]
+        public void Instance_with_FirstName_equal_to_LastName_is_valid()
+        {
+            var rule = classMetadata.Rules.OfType<PropertyMustMatchRule<Person>>().Last();
+            var person = new Person { FirstName = "foo", LastName = "foo" };
+            Assert.True(rule.IsValid(person));
+        }
     }
 }

Source/FluentMetadata.Core.Specs/FluentMetadata.Core.Specs.csproj

@@ -87,6 +87,7 @@
     <Compile Include="MetadataSetup.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PropertyMedata_with_WebUser.cs" />
+    <Compile Include="Rules\PropertyMustMatchRuleSpecs.cs" />
     <Compile Include="Rules\RangeRuleSpecs.cs" />
     <Compile Include="Rules\RequiredRuleSpecs.cs" />
     <Compile Include="Rules\StringLengthRuleSpecs.cs" />

Source/FluentMetadata.Core.Specs/PropertyMedata_with_Person.cs

@@ -11,8 +11,8 @@ public class PropertyMedata_with_Person : MetadataTestBase
         public PropertyMedata_with_Person()
         {
             var query = new QueryFluentMetadata();
-            firstName = query.GetMetadataFor(typeof (Person), "FirstName");
-            lastName = query.GetMetadataFor(typeof (Person), "LastName");
+            firstName = query.GetMetadataFor(typeof(Person), "FirstName");
+            lastName = query.GetMetadataFor(typeof(Person), "LastName");
         }
 
         [Fact]
@@ -24,7 +24,7 @@ public void FirstName_ModelName_is_FirstName()
         [Fact]
         public void FirstName_ModelType_is_string()
         {
-            Assert.Equal(typeof (string), firstName.ModelType);
+            Assert.Equal(typeof(string), firstName.ModelType);
         }
 
         [Fact]
@@ -42,7 +42,7 @@ public void LastName_ModelName_is_LastName()
         [Fact]
         public void LastName_ModelType_is_string()
         {
-            Assert.Equal(typeof (string), lastName.ModelType);
+            Assert.Equal(typeof(string), lastName.ModelType);
         }
 
         [Fact]

Source/FluentMetadata.Core.Specs/PropertyMedata_with_WebUser.cs

@@ -1,18 +1,21 @@
-using FluentMetadata.Specs.SampleClasses;
+using System;
+using FluentMetadata.Specs.SampleClasses;
 using Xunit;
 
 namespace FluentMetadata.Specs
 {
     public class PropertyMedata_with_WebUser : MetadataTestBase
     {
-        private Metadata username;
-        private Metadata id;
+        Metadata lastLogin, username, id, passWordHash, role;
 
         public PropertyMedata_with_WebUser()
         {
             var query = new QueryFluentMetadata();
             username = query.GetMetadataFor(typeof(WebUser), "Username");
             id = query.GetMetadataFor(typeof(WebUser), "Id");
+            lastLogin = query.GetMetadataFor(typeof(WebUser), "LastLogin");
+            passWordHash = query.GetMetadataFor(typeof(WebUser), "PasswordHash");
+            role = query.GetMetadataFor(typeof(WebUser), "Role");
         }
 
         [Fact]
@@ -39,6 +42,42 @@ public void Username_Required_is_true()
             Assert.True(username.Required.Value);
         }
 
+        [Fact]
+        public void Username_MinLength_is_3()
+        {
+            Assert.Equal(3, username.GetMinimumLength());
+        }
+
+        [Fact]
+        public void Username_MaxLength_is_256()
+        {
+            Assert.Equal(256, username.GetMaximumLength());
+        }
+
+        [Fact]
+        public void PassWordHash_MinLength_is_32()
+        {
+            Assert.Equal(32, passWordHash.GetMinimumLength());
+        }
+
+        [Fact]
+        public void PassWordHash_MaxLength_is_null()
+        {
+            Assert.Null(passWordHash.GetMaximumLength());
+        }
+
+        [Fact]
+        public void Role_MinLength_is_null()
+        {
+            Assert.Null(role.GetMinimumLength());
+        }
+
+        [Fact]
+        public void Role_MaxLength_is_256()
+        {
+            Assert.Equal(256, role.GetMaximumLength());
+        }
+
         [Fact]
         public void Id_ModelName_is_Id()
         {
@@ -56,5 +95,17 @@ public void Id_Required_is_false()
         {
             Assert.False(id.Required.HasValue);
         }
+
+        [Fact]
+        public void Last_Login_Minimum_is_2010_1_23()
+        {
+            Assert.Equal(new DateTime(2010, 1, 23), lastLogin.GetRangeMinimum());
+        }
+
+        [Fact]
+        public void Last_Login_Maximum_is_DoomsDay()
+        {
+            Assert.Equal(DateTime.MaxValue, lastLogin.GetRangeMaximum());
+        }
     }
 }

Source/FluentMetadata.Core.Specs/PropertyMedata_with_WebUserIndexModel.cs

@@ -5,16 +5,16 @@ namespace FluentMetadata.Specs
 {
     public class PropertyMedata_with_WebUserIndexModel : MetadataTestBase
     {
-        private Metadata username;
-        private Metadata id;
-        private Metadata autorName;
+        Metadata username, id, autorName, email, role;
 
         public PropertyMedata_with_WebUserIndexModel()
         {
             var query = new QueryFluentMetadata();
             username = query.GetMetadataFor(typeof(WebUserIndexModel), "Username");
             id = query.GetMetadataFor(typeof(WebUserIndexModel), "Id");
+            email = query.GetMetadataFor(typeof(WebUserIndexModel), "EMail");
             autorName = query.GetMetadataFor(typeof(WebUserIndexModel), "AutorName");
+            role = query.GetMetadataFor(typeof(WebUserIndexModel), "Role");
         }
 
         [Fact]
@@ -62,7 +62,101 @@ public void Id_Required_is_false()
         [Fact]
         public void AutorName_DisplayName_is_emaN()
         {
-            Assert.Equal("emaN",autorName.DisplayName);
+            Assert.Equal("emaN", autorName.DisplayName);
+        }
+
+        [Fact]
+        public void EMail_DataTypeName_is_EmailAddress()
+        {
+            Assert.Equal("EmailAddress", email.DataTypeName);
+        }
+
+        [Fact]
+        public void Username_Description_is_Name_des_Benutzers()
+        {
+            Assert.Equal("Name des Benutzers", username.Description);
+        }
+
+        [Fact]
+        public void EMail_DisplayFormat_is_MailtoLink()
+        {
+            Assert.Equal("<a href='mailto:{0}'>{0}</a>", email.DisplayFormat);
+        }
+
+        [Fact]
+        public void EMail_EditorFormat_is_plain_value()
+        {
+            Assert.Equal("{0}", email.EditorFormat);
+        }
+
+        [Fact]
+        public void Id_HideSurroundingHtml_is_true()
+        {
+            Assert.True(id.HideSurroundingHtml.HasValue);
+            Assert.True(id.HideSurroundingHtml.Value);
+        }
+
+        [Fact]
+        public void Username_ReadOnly_is_true()
+        {
+            Assert.True(username.Readonly);
+        }
+
+        [Fact]
+        public void AutorName_NullDisplayText_is_Anonymous_Autor()
+        {
+            Assert.Equal("Anonymous Autor", autorName.NullDisplayText);
+        }
+
+        [Fact]
+        public void Id_ShowDisplay_is_false()
+        {
+            Assert.False(id.ShowDisplay);
+        }
+
+        [Fact]
+        public void Id_ShowEditor_is_false()
+        {
+            Assert.False(id.ShowEditor);
+        }
+
+        [Fact]
+        public void Role_TemplateHint_is_Roles()
+        {
+            Assert.Equal("Roles", role.TemplateHint);
+        }
+
+        [Fact]
+        public void EMail_Watermark_is_dummy_address()
+        {
+            Assert.Equal("john@doe.com", email.Watermark);
+        }
+
+        [Fact]
+        public void Username_ConvertEmptyStringToNull_is_false()
+        {
+            Assert.False(username.ConvertEmptyStringToNull);
+        }
+
+        [Fact]
+        public void Id_Hidden_is_true()
+        {
+            Assert.True(id.Hidden.HasValue);
+            Assert.True(id.Hidden.Value);
+        }
+
+        [Fact]
+        public void Username_GetMaximumLength_is_256()
+        {
+            var maxLength = username.GetMaximumLength();
+            Assert.True(maxLength.HasValue);
+            Assert.Equal(256, maxLength);
+        }
+
+        [Fact]
+        public void Username_ContainerType_is_WebUserIndexModel()
+        {
+            Assert.Equal(typeof(WebUserIndexModel), username.ContainerType);
         }
     }
 }

Source/FluentMetadata.Core.Specs/Rules/PropertyMustMatchRuleSpecs.cs

@@ -0,0 +1,38 @@
+using FluentMetadata.Rules;
+using Xunit;
+
+namespace FluentMetadata.Specs.Rules
+{
+    public class ChangePasswordModel
+    {
+        public string OldPassword { get; set; }
+        public string NewPassword { get; set; }
+        public string ConfirmPassword { get; set; }
+    }
+
+    public class When_two_properties_should_be_equal : InstanceContextSpecification<PropertyMustMatchRule<ChangePasswordModel>>
+    {
+        protected override PropertyMustMatchRule<ChangePasswordModel> CreateSut()
+        {
+            return new PropertyMustMatchRule<ChangePasswordModel>(x => x.NewPassword, x => x.ConfirmPassword);
+        }
+
+        protected override void Because()
+        {
+        }
+
+        [Observation]
+        public void Should_be_valid_if_properties_match()
+        {
+            var model = new ChangePasswordModel { NewPassword = "asdf", ConfirmPassword = "asdf" };
+            Sut.IsValid(model).ShouldBeTrue();
+        }
+
+        [Observation]
+        public void Should_be_invalid_if_properties_do_not_match()
+        {
+            var model = new ChangePasswordModel { NewPassword = "qwer", ConfirmPassword = "asdf" };
+            Sut.IsValid(model).ShouldBeFalse();
+        }
+    }
+}