brought back the test for CSV report

Author: kkozmic

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/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, IConventionResult 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;
+        }
+    }
+}