moved some common logic out of Convention classes

so ConventionData now has an interface, not so POCO anymore, but we get to have 2LOC conventions

Author: kkozmic

TestStack.ConventionTests/Convention.cs

@@ -11,25 +11,27 @@ public static class Convention
     {
         public static readonly ConventionSettings Settings = new ConventionSettings();
 
-        public static void Is<TData>(IConvention<TData> convention, TData data)
+        public static void Is<TData>(IConvention<TData> convention, TData data) where TData : IConventionData
         {
+            if (data.HasValidSource == false)
+            {
+                // TODO: this would have to have a more reasonable and helpful message...
+                Settings.AssertInclunclusive("No valid source in " + data);
+                return;
+            }
             var result = convention.Execute(data);
             if (result.IsConclusive == false)
             {
                 Settings.AssertInclunclusive(result.Message);
+                return;
             }
-            else
+            if (data.HasApprovedExceptions)
             {
-                if (result.HasExceptions)
-                {
-                    // should we encapsulate Approvals behind Settings?
-                    Approvals.Verify(result.Message);
-                }
-                else
-                {
-                    Settings.AssertZero(result.InvalidResultsCount, result.Message);
-                }
+                // should we encapsulate Approvals behind Settings?
+                Approvals.Verify(result.Message);
+                return;
             }
+            Settings.AssertZero(result.InvalidResultsCount, result.Message);
         }
 
         public static void Is<T, T2>(IEnumerable<T2> itemsToVerify) where T : ConventionData<T2>, new()

TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs

@@ -6,29 +6,17 @@
 
     public class AllClassesHaveDefaultConstructor : IConvention<Types>
     {
-        public string HeaderMessage { get; set; }
-
         public AllClassesHaveDefaultConstructor()
         {
             HeaderMessage = "The following types do not have default constructor";
         }
 
+        public string HeaderMessage { get; set; }
+
         public ConventionResult Execute(Types data)
         {
-            var types = data.ApplicableTypes;
-            if (types.None())
-            {
-                return ConventionResult.Inconclusive("Put sensible 'inconclusive' message here");
-            }
-            // NOTE: thie bit above is duplicated in both conventions we have, and will likely be duplicated in any other.
-            // we likely will want to pull that out, leaving perhaps a property like InconclusiveMessage
-
-            var invalid = types.Where(t => t.HasDefaultConstructor() == false);
-            var result = ConventionResult.For(invalid, HeaderMessage, (t, m) => m.AppendLine("\t" + t));
-
-            //if we switch conventionData to have an interface and put HasApprovedExceptions on it, we'll be able to pull this out as well.
-            result.HasExceptions = data.HasApprovedExceptions;
-            return result;
+            var invalid = data.ApplicableTypes.Where(t => t.HasDefaultConstructor() == false);
+            return ConventionResult.For(invalid, HeaderMessage, (t, m) => m.AppendLine("\t" + t));
         }
     }
 }

TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs

@@ -15,20 +15,14 @@ public AllMethodsAreVirtual()
             HeaderMessage = "The following methods are not virtual.";
         }
 
+        public string HeaderMessage { get; set; }
+
         public ConventionResult Execute(Types data)
         {
-            var types = data.ApplicableTypes;
-            if (types.None())
-            {
-                return ConventionResult.Inconclusive("Put sensible 'inconclusive' message here");
-            }
-
             // do we want to encapsulate that in some way?
             // also notice how data gives us types, yet the convention acts upon methods.
-            var invalid = types.ToLookup(t => t, t => t.NonVirtualMethods()).Where(l => l.Any());
-            var result = ConventionResult.For(invalid, HeaderMessage, DescribeTypeAndMethods);
-            result.HasExceptions = data.HasApprovedExceptions;
-            return result;
+            var invalid = data.ApplicableTypes.ToLookup(t => t, t => t.NonVirtualMethods()).Where(l => l.Any());
+            return ConventionResult.For(invalid, HeaderMessage, DescribeTypeAndMethods);
         }
 
         // I like how that's encapsulated in the reusable convention type, whereas previously it was part of the convention/test code
@@ -40,7 +34,5 @@ void DescribeTypeAndMethods(IGrouping<Type, IEnumerable<MethodInfo>> item, Strin
                 message.AppendLine("\t\t" + method);
             }
         }
-
-        public string HeaderMessage { get; set; }
     }
 }

TestStack.ConventionTests/IConvention.cs

@@ -2,7 +2,7 @@
 {
     using TestStack.ConventionTests.Internal;
 
-    public interface IConvention<T>
+    public interface IConvention<T> where T : IConventionData
     {
         ConventionResult Execute(T data);
     }

TestStack.ConventionTests/IConventionData.cs

@@ -0,0 +1,8 @@
+namespace TestStack.ConventionTests
+{
+    public interface IConventionData
+    {
+        bool HasValidSource { get; }
+        bool HasApprovedExceptions { get; }
+    }
+}

TestStack.ConventionTests/Internal/ConventionResult.cs

@@ -10,7 +10,6 @@ public class ConventionResult
         public string Message { get; set; }
         public bool IsConclusive { get; set; }
         // TODO: perhaps name it better so that it doesn't get confused with System.Exception and related concepts
-        public bool HasExceptions { get; set; }
         public int InvalidResultsCount { get; set; }
 
         public static ConventionResult For<TResult>(IEnumerable<TResult> items,

TestStack.ConventionTests/TestStack.ConventionTests.csproj

@@ -59,6 +59,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="IConventionData.cs" />
     <Compile Include="Internal\ConventionResult.cs" />
     <Compile Include="Conventions\AllMethodsAreVirtual.cs" />
     <Compile Include="ConventionFailedException.cs" />

TestStack.ConventionTests/Types.cs

@@ -1,16 +1,21 @@
 namespace TestStack.ConventionTests
 {
     using System;
+    using System.Linq;
 
     /// <summary>
     ///     This is where we set what our convention is all about.
     /// </summary>
-    // NOTE: notice no base type, no interface. Just a POCO DTO
-    public class Types
+    public class Types : IConventionData
     {
         //NOTE: that's a terrible name
         public Type[] ApplicableTypes { get; set; }
 
         public bool HasApprovedExceptions { get; set; }
+
+        public bool HasValidSource
+        {
+            get { return ApplicableTypes.Any(); }
+        }
     }
 }