Reporting and formatting

TestAssembly/Collections/Branch.cs

@@ -0,0 +1,20 @@
+namespace TestAssembly.Collections
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public class Branch : IEnumerable<Leaf>
+    {
+        readonly List<Leaf> items = new List<Leaf>();
+
+        public IEnumerator<Leaf> GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

TestAssembly/Collections/Forest.cs

@@ -0,0 +1,30 @@
+namespace TestAssembly.Collections
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public class Forest : ICanAdd<Tree>, ICanRemove<Tree>
+    {
+        readonly List<Tree> items = new List<Tree>();
+
+        public void Add(Tree item)
+        {
+            items.Add(item);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable) items).GetEnumerator();
+        }
+
+        public IEnumerator<Tree> GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
+
+        public bool Remove(Tree item)
+        {
+            return items.Remove(item);
+        }
+    }
+}

TestAssembly/Collections/ICanAdd.cs

@@ -0,0 +1,9 @@
+namespace TestAssembly.Collections
+{
+    using System.Collections.Generic;
+
+    public interface ICanAdd<T> : IEnumerable<T>
+    {
+        void Add(T item);
+    }
+}

TestAssembly/Collections/ICanRemove.cs

@@ -0,0 +1,9 @@
+namespace TestAssembly.Collections
+{
+    using System.Collections.Generic;
+
+    public interface ICanRemove<T> : IEnumerable<T>
+    {
+        bool Remove(T item);
+    }
+}

TestAssembly/Collections/Leaf.cs

@@ -0,0 +1,6 @@
+namespace TestAssembly.Collections
+{
+    public class Leaf
+    {
+    }
+}

TestAssembly/Collections/Tree.cs

@@ -0,0 +1,31 @@
+namespace TestAssembly.Collections
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    public class Tree : ICanAdd<Branch>, IEnumerable<Leaf>
+    {
+        readonly List<Branch> items = new List<Branch>();
+
+        public void Add(Branch item)
+        {
+            items.Add(item);
+        }
+
+        public IEnumerator<Branch> GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator<Leaf> IEnumerable<Leaf>.GetEnumerator()
+        {
+            return items.SelectMany(i => i).GetEnumerator();
+        }
+    }
+}

TestAssembly/TestAssembly.csproj

@@ -44,6 +44,12 @@
     <Compile Include="ClassWithPrivateDefaultCtor.cs" />
     <Compile Include="ClassWithProtectedDefaultCtor.cs" />
     <Compile Include="ClassWithPublicDefaultCtor.cs" />
+    <Compile Include="Collections\Branch.cs" />
+    <Compile Include="Collections\Forest.cs" />
+    <Compile Include="Collections\ICanAdd.cs" />
+    <Compile Include="Collections\ICanRemove.cs" />
+    <Compile Include="Collections\Leaf.cs" />
+    <Compile Include="Collections\Tree.cs" />
     <Compile Include="Dtos\AnotherClass.cs" />
     <Compile Include="Dtos\BlahDto.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs

@@ -33,7 +33,7 @@ public ConventionReportFailure Format(string failingData)
 
         public class FailingConvention : IConvention<FakeData>
         {
-            public void Execute(FakeData data, IConventionResult result)
+            public void Execute(FakeData data, IConventionResultContext result)
             {
                 result.Is("Header", new[] {"Different"});
             }

TestStack.ConventionTests.Tests/CsvReportTests.Can_run_convention_with_simple_reporter.approved.txt

@@ -0,0 +1,5 @@
+collection,item,can add,can remove
+TestAssembly.Collections.Branch,TestAssembly.Collections.Leaf,False,False
+TestAssembly.Collections.Forest,TestAssembly.Collections.Tree,True,True
+TestAssembly.Collections.Tree,TestAssembly.Collections.Branch,True,False
+TestAssembly.Collections.Tree,TestAssembly.Collections.Leaf,False,False

TestStack.ConventionTests.Tests/CsvReportTests.cs

@@ -0,0 +1,24 @@
+namespace TestStack.ConventionTests.Tests
+{
+    using System.Linq;
+    using ApprovalTests.Reporters;
+    using NUnit.Framework;
+    using TestAssembly.Collections;
+    using TestStack.ConventionTests.ConventionData;
+    using TestStack.ConventionTests.Tests.TestConventions;
+
+    [UseReporter(typeof(DiffReporter))]
+    public class CsvReportTests
+    {
+        [Test]
+        public void Can_run_convention_with_simple_reporter()
+        {
+            Convention.IsWithApprovedExeptions(new CollectionsRelationsConvention(), new Types("Entities")
+            {
+                TypesToVerify =
+                    typeof (Leaf).Assembly.GetExportedTypes()
+                        .Where(t => t.Namespace == typeof (Leaf).Namespace).ToArray()
+            });
+        }
+    }
+}

TestStack.ConventionTests.Tests/TestConventions/CollectionsRelationsConvention.cs

@@ -0,0 +1,42 @@
+namespace TestStack.ConventionTests.Tests.TestConventions
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using TestAssembly.Collections;
+    using TestStack.ConventionTests.ConventionData;
+
+    public class CollectionsRelationsConvention : IConvention<Types>
+    {
+        public string ConventionTitle { get; private set; }
+
+        public void Execute(Types data, IConventionResultContext result)
+        {
+            ConventionTitle = "well, does the header apply here all across the board? How would that work for CSV?";
+            var types = data.TypesToVerify;
+            var collectionToItemLookup = from collection in types
+                where collection.IsClass
+                orderby collection.FullName
+                from item in GetItemTypes(collection)
+                select new
+                {
+                    collection,
+                    item,
+                    can_add = typeof (ICanAdd<>).MakeGenericType(item).IsAssignableFrom(collection),
+                    can_remove = typeof (ICanRemove<>).MakeGenericType(item).IsAssignableFrom(collection)
+                };
+
+            result.Is("Some title", collectionToItemLookup);
+        }
+
+        IEnumerable<Type> GetItemTypes(Type type)
+        {
+            return from @interface in type.GetInterfaces()
+                where @interface.IsGenericType
+                where @interface.GetGenericTypeDefinition() == typeof (IEnumerable<>)
+                let item = @interface.GetGenericArguments().Single()
+                orderby item.FullName
+                select item;
+        }
+    }
+}

TestStack.ConventionTests.Tests/TestStack.ConventionTests.Tests.csproj

@@ -52,13 +52,15 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ConventionAssertionClassTests.cs" />
+    <Compile Include="CsvReportTests.cs" />
     <Compile Include="ProjectBasedConventions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
+    <Compile Include="TestConventions\CollectionsRelationsConvention.cs" />
     <Compile Include="TypeBasedConventions.cs" />
   </ItemGroup>
   <ItemGroup>

TestStack.ConventionTests.Tests/TypeBasedConventions.cs

@@ -1,5 +1,6 @@
 namespace TestStack.ConventionTests.Tests
 {
+    using System.Linq;
     using ApprovalTests;
     using ApprovalTests.Reporters;
     using NUnit.Framework;
@@ -16,7 +17,9 @@ public class TypeBasedConventions
 
         public TypeBasedConventions()
         {
-            var itemsToVerify = typeof (SampleDomainClass).Assembly.GetTypes();
+            var itemsToVerify = typeof (SampleDomainClass).Assembly.GetTypes()
+                .Where(t => t.IsClass && t.Namespace == typeof (SampleDomainClass).Namespace)
+                .ToArray();
             nhibernateEntities = new Types("nHibernate Entitites")
             {
                 TypesToVerify = itemsToVerify
@@ -76,4 +79,4 @@ public void dtos_exists_in_dto_namespace_wth_approved_exceptions()
             Convention.IsWithApprovedExeptions(convention, types);
         }
     }
-}
+}

TestStack.ConventionTests/Convention.cs

@@ -12,7 +12,7 @@
     public static class Convention
     {
         static readonly HtmlReportRenderer HtmlRenderer = new HtmlReportRenderer(AssemblyDirectory);
-        static readonly List<ResultInfo> Reports = new List<ResultInfo>();
+        static readonly List<ConventionResult> Reports = new List<ConventionResult>();
 
         static Convention()
         {
@@ -26,7 +26,7 @@ static Convention()
             };
         }
 
-        public static IEnumerable<ResultInfo> ConventionReports { get { return Reports; } }
+        public static IEnumerable<ConventionResult> ConventionReports { get { return Reports; } }
         public static IList<IReportDataFormatter> Formatters { get; set; } 
 
         public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSource data)
@@ -40,7 +40,8 @@ public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSou
         {
             try
             {
-                var conventionResult = Executor.GetConventionResults(convention, data);
+                var context = new ConventionContext(data.Description, Formatters);
+                var conventionResult = context.GetConventionResults(convention, data);
                 Reports.AddRange(conventionResult);
 
                 new ConventionReportTraceRenderer().Render(conventionResult);
@@ -55,7 +56,8 @@ public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSou
         public static void IsWithApprovedExeptions<TDataSource>(IConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
-            var conventionResult = Executor.GetConventionResultsWithApprovedExeptions(convention, data);
+            var context = new ConventionContext(data.Description, Formatters);
+            var conventionResult = context.GetConventionResultsWithApprovedExeptions(convention, data);
             Reports.AddRange(conventionResult);
 
             try

TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs

@@ -6,7 +6,7 @@
 
     public class AllClassesHaveDefaultConstructor : IConvention<Types>
     {
-        public void Execute(Types data, IConventionResult result)
+        public void Execute(Types data, IConventionResultContext result)
         {
             result.Is("Types must have a default constructor",
                 data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false));

TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs

@@ -6,7 +6,7 @@
 
     public class AllMethodsAreVirtual : IConvention<Types>
     {
-        public void Execute(Types data, IConventionResult result)
+        public void Execute(Types data, IConventionResultContext result)
         {
             result.Is("Methods must be virtual", data.TypesToVerify.SelectMany(t => t.NonVirtualMethods()));
         }

TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs

@@ -31,7 +31,7 @@ public ClassTypeHasSpecificNamespace(Func<Type, bool> classIsApplicable, string
             this.classType = classType;
         }
 
-        public void Execute(Types data, IConventionResult result)
+        public void Execute(Types data, IConventionResultContext result)
         {
             result.IsSymmetric(
                 string.Format("{0}s must be under the '{1}' namespace", classType, namespaceToCheck),

TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs

@@ -12,7 +12,7 @@ public FilesAreEmbeddedResources(string fileExtension)
 
         public string FileExtension { get; private set; }
 
-        public void Execute(ProjectFiles data, IConventionResult result)
+        public void Execute(ProjectFiles data, IConventionResultContext result)
         {
             result.Is(
                 string.Format("{0} Files must be embedded resources", FileExtension),

TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs

@@ -8,7 +8,7 @@ public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<Pr
     {
         const string AssemblyReferencingObjRegex = @"^(?<assembly>.*?(obj|bin).*?)$";
 
-        public void Execute(ProjectReferences data, IConventionResult result)
+        public void Execute(ProjectReferences data, IConventionResultContext result)
         {
             result.Is("Project must not reference dlls from bin or obj directories",
                 data.References.Where(IsBinOrObjReference));

TestStack.ConventionTests/IConvention.cs

@@ -2,6 +2,6 @@
 {
     public interface IConvention<in T> where T : IConventionData
     {
-        void Execute(T data, IConventionResult result);
+        void Execute(T data, IConventionResultContext result);
     }
 }

TestStack.ConventionTests/IConventionResult.cs → TestStack.ConventionTests/IConventionResultContext.cs

@@ -3,7 +3,7 @@
     using System;
     using System.Collections.Generic;
 
-    public interface IConventionResult
+    public interface IConventionResultContext
     {
         void Is<T>(string resultTitle, IEnumerable<T> failingData);
 
@@ -14,13 +14,13 @@ public interface IConventionResult
         ///     and if a non-dto is in Project.Dto the test will also fail
         /// </summary>
         /// <typeparam name="TResult">The data type the convention is applied to</typeparam>
-        /// <param name="conventionResultTitle">Title of the convention, i.e Dto's must live in Project.Dto namespace</param>
-        /// <param name="conventionFailingData">Data failing to conform to the convention</param>
-        /// <param name="inverseResultTitle">The inverse scenario title, i.e Non-dtos must not live inside Project.Dto namespace</param>
-        /// <param name="inverseFailingData">Data failing to conform to the inverse of the convention</param>
+        /// <param name="firstSetFailureTitle">Title of the convention, i.e Dto's must live in Project.Dto namespace</param>
+        /// <param name="firstSetFailureData">Data failing to conform to the convention</param>
+        /// <param name="secondSetFailureTitle">The inverse scenario title, i.e Non-dtos must not live inside Project.Dto namespace</param>
+        /// <param name="secondSetFailureData">Data failing to conform to the inverse of the convention</param>
         void IsSymmetric<TResult>(
-            string conventionResultTitle, IEnumerable<TResult> conventionFailingData,
-            string inverseResultTitle, IEnumerable<TResult> inverseFailingData);
+            string firstSetFailureTitle, IEnumerable<TResult> firstSetFailureData,
+            string secondSetFailureTitle, IEnumerable<TResult> secondSetFailureData);
 
         /// <summary>
         ///     A symmetric convention is a convention which also can be applied in reverse. For example