Fixed tests, introduced 'IsWithApprovedExeptions' for activating approvals in ConventionTest

Jake Ginnivan · Jake Ginnivan · commit 7b63a34ac2a8 · 2013-07-31T10:20:06.000+01:00
diff --git a/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.approval_mismatch.approved.txt b/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.approval_mismatch.approved.txt
@@ -0,0 +1,3 @@
+﻿Header
+
+Approved Exception
diff --git a/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs b/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs
@@ -0,0 +1,37 @@
+﻿namespace TestStack.ConventionTests.Tests
+{
+    using ApprovalTests.Reporters;
+    using NUnit.Framework;
+    using TestStack.ConventionTests.Internal;
+
+    [TestFixture]
+    [UseReporter(typeof(DiffReporter))] //NOTE: Can we take care of this in IsWithApprovedExceptions?
+    public class ConventionAssertionClassTests
+    {
+        [Test]
+        public void approval_mismatch()
+        {
+            //NOTE Do not approve any changes to this test
+            var ex = Assert.Throws<ConventionFailedException>(() => Convention.IsWithApprovedExeptions(new FailingConvention(), new FakeData()));
+
+            StringAssert.Contains("Approved exceptions for convention differs", ex.Message);
+            StringAssert.Contains("Failed Approval: Received file ", ex.Message);
+            StringAssert.Contains("does not match approved file", ex.Message);
+        }
+
+        public class FakeData : IConventionData
+        {
+            public void ThrowIfHasInvalidSource()
+            {
+            }
+        }
+
+        public class FailingConvention : IConvention<FakeData>
+        {
+            public ConventionResult Execute(FakeData data)
+            {
+                return ConventionResult.For(new[] { "" }, "Header", (s, builder) => builder.AppendLine("Different"));
+            }
+        }
+    }
+}
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.BrokenReferences.received.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.BrokenReferences.received.txt
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.ReferencingBinObj.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.ReferencingBinObj.approved.txt
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.ScriptsNotEmbeddedResources.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.ScriptsNotEmbeddedResources.approved.txt
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.ScriptsNotEmbeddedResources.approved.txt.orig b/TestStack.ConventionTests.Tests/ProjectBasedConventions.ScriptsNotEmbeddedResources.approved.txt.orig
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.assemblies_referencing_bin_obj.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.assemblies_referencing_bin_obj.approved.txt
@@ -0,0 +1,3 @@
+﻿Some invalid assembly references found in TestStack.ConventionTests.Tests
+
+	bin\Debug\ApprovalTests.dll
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.assemblies_referencing_bin_obj_with_approved_exceptions.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.assemblies_referencing_bin_obj_with_approved_exceptions.approved.txt
@@ -0,0 +1,3 @@
+﻿Some invalid assembly references found in TestStack.ConventionTests.Tests
+
+	bin\Debug\ApprovalTests.dll
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.cs b/TestStack.ConventionTests.Tests/ProjectBasedConventions.cs
@@ -1,6 +1,7 @@
 ﻿namespace TestStack.ConventionTests.Tests
 {
     using System.Xml.Linq;
+    using ApprovalTests;
     using ApprovalTests.Reporters;
     using NSubstitute;
     using NUnit.Framework;
@@ -24,24 +25,49 @@ public void Setup()
         }
 
         [Test]
-        public void ReferencingBinObj()
+        public void assemblies_referencing_bin_obj()
         {
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithBinReference));
 
-            Convention.Is(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(), project);
+            var ex = Assert.Throws<ConventionFailedException>(() => Convention.Is(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(), project));
+
+            Approvals.Verify(ex.Message);
+        }
+
+        [Test]
+        public void assemblies_referencing_bin_obj_with_approved_exceptions()
+        {
+            projectProvider
+                .LoadProjectDocument(Arg.Any<string>())
+                .Returns(XDocument.Parse(Resources.ProjectFileWithBinReference));
+
+            Convention.IsWithApprovedExeptions(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(), project);
+        }
+
+        [Test]
+        public void scripts_not_embedded_resources()
+        {
+            project.Includes = i => i.EndsWith(".sql");
+            projectProvider
+                .LoadProjectDocument(Arg.Any<string>())
+                .Returns(XDocument.Parse(Resources.ProjectFileWithInvalidSqlScriptFile));
+
+            var ex = Assert.Throws<ConventionFailedException>(() => Convention.Is(new FilesAreEmbeddedResources(), project));
+
+            Approvals.Verify(ex.Message);
         }
 
         [Test]
-        public void ScriptsNotEmbeddedResources()
+        public void scripts_not_embedded_resources_with_approved_exceptions()
         {
             project.Includes = i => i.EndsWith(".sql");
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithInvalidSqlScriptFile));
 
-            Convention.Is(new FilesAreEmbeddedResources(), project);
+            Convention.IsWithApprovedExeptions(new FilesAreEmbeddedResources(), project);
         }
     }
 }
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.scripts_not_embedded_resources.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.scripts_not_embedded_resources.approved.txt
@@ -0,0 +1,3 @@
+﻿The following files which should be embedded resources:
+
+	Scripts\Script2.sql
diff --git a/TestStack.ConventionTests.Tests/ProjectBasedConventions.scripts_not_embedded_resources_with_approved_exceptions.approved.txt b/TestStack.ConventionTests.Tests/ProjectBasedConventions.scripts_not_embedded_resources_with_approved_exceptions.approved.txt
@@ -0,0 +1,3 @@
+﻿The following files which should be embedded resources:
+
+	Scripts\Script2.sql
diff --git a/TestStack.ConventionTests.Tests/TestStack.ConventionTests.Tests.csproj b/TestStack.ConventionTests.Tests/TestStack.ConventionTests.Tests.csproj
@@ -51,6 +51,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ConventionAssertionClassTests.cs" />
     <Compile Include="ProjectBasedConventions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
diff --git a/TestStack.ConventionTests.Tests/TypeBasedConventions.all_classes_have_default_constructor.approved.txt b/TestStack.ConventionTests.Tests/TypeBasedConventions.all_classes_have_default_constructor.approved.txt
@@ -1,3 +1,4 @@
-﻿Convention has failing items
-	TestAssembly.ClassWithNoDefaultCtor does not have a default constructor
-	TestAssembly.ClassWithPrivateDefaultCtor does not have a default constructor
+﻿The following types do not have default constructor
+
+	TestAssembly.ClassWithNoDefaultCtor
+	TestAssembly.ClassWithPrivateDefaultCtor
diff --git a/TestStack.ConventionTests.Tests/TypeBasedConventions.all_classes_have_default_constructor_wth_approved_exceptions.approved.txt b/TestStack.ConventionTests.Tests/TypeBasedConventions.all_classes_have_default_constructor_wth_approved_exceptions.approved.txt
@@ -0,0 +1,4 @@
+﻿The following types do not have default constructor
+
+	TestAssembly.ClassWithNoDefaultCtor
+	TestAssembly.ClassWithPrivateDefaultCtor
diff --git a/TestStack.ConventionTests.Tests/TypeBasedConventions.all_methods_are_virtual.approved.txt b/TestStack.ConventionTests.Tests/TypeBasedConventions.all_methods_are_virtual.approved.txt
@@ -1,3 +1,3 @@
-﻿Convention has failing items
-	TestAssembly.SampleDomainClass has non virtual method(s):
-	TestNonVirtual
+﻿The following methods are not virtual.
+
+	TestAssembly.SampleDomainClass.TestNonVirtual
diff --git a/TestStack.ConventionTests.Tests/TypeBasedConventions.all_methods_are_virtual_wth_approved_exceptions.approved.txt b/TestStack.ConventionTests.Tests/TypeBasedConventions.all_methods_are_virtual_wth_approved_exceptions.approved.txt
@@ -0,0 +1,3 @@
+﻿The following methods are not virtual.
+
+	TestAssembly.SampleDomainClass.TestNonVirtual
diff --git a/TestStack.ConventionTests.Tests/TypeBasedConventions.cs b/TestStack.ConventionTests.Tests/TypeBasedConventions.cs
@@ -1,5 +1,6 @@
 ﻿namespace TestStack.ConventionTests.Tests
 {
+    using ApprovalTests;
     using ApprovalTests.Reporters;
     using NUnit.Framework;
     using TestAssembly;
@@ -23,13 +24,29 @@ public TypeBasedConventions()
         [Test]
         public void all_classes_have_default_constructor()
         {
-            Convention.Is(new AllClassesHaveDefaultConstructor(), nhibernateEntities);
+            var ex = Assert.Throws<ConventionFailedException>(()=>Convention.Is(new AllClassesHaveDefaultConstructor(), nhibernateEntities));
+
+            Approvals.Verify(ex.Message);
+        }
+
+        [Test]
+        public void all_classes_have_default_constructor_wth_approved_exceptions()
+        {
+            Convention.IsWithApprovedExeptions(new AllClassesHaveDefaultConstructor(), nhibernateEntities);
         }
 
         [Test]
         public void all_methods_are_virtual()
         {
-            Convention.Is(new AllMethodsAreVirtual(), nhibernateEntities);
+            var ex = Assert.Throws<ConventionFailedException>(()=>Convention.Is(new AllMethodsAreVirtual(), nhibernateEntities));
+
+            Approvals.Verify(ex.Message);
+        }
+
+        [Test]
+        public void all_methods_are_virtual_wth_approved_exceptions()
+        {
+            Convention.IsWithApprovedExeptions(new AllMethodsAreVirtual(), nhibernateEntities);
         }
     }
 }
diff --git a/TestStack.ConventionTests/Convention.cs b/TestStack.ConventionTests/Convention.cs
@@ -10,23 +10,27 @@ public static void Is<TData>(IConvention<TData> convention, TData data) where TD
         {
             data.ThrowIfHasInvalidSource();
             var result = convention.Execute(data);
-            if (data.HasApprovedExceptions)
+
+            if (result.Failed)
+                throw new ConventionFailedException(result.Message);
+        }
+
+        public static void IsWithApprovedExeptions<TData>(IConvention<TData> convention, TData data) where TData : IConventionData
+        {
+            data.ThrowIfHasInvalidSource();
+            var result = convention.Execute(data);
+
+            // should we encapsulate Approvals behind Settings?
+            try
             {
-                // should we encapsulate Approvals behind Settings?
-                try
-                {
-                    Approvals.Verify(result.Message);
+                Approvals.Verify(result.Message);
 
-                    Trace.WriteLine(string.Format("{0} has approved exceptions:\r\n\r\n{1}", convention.GetType().Name, result.Message));
-                }
-                catch (ApprovalException ex)
-                {
-                    throw new ConventionFailedException("Approved exceptions for convention differs, see inner exception for more information", ex);
-                }
-                return;
+                Trace.WriteLine(string.Format("{0} has approved exceptions:\r\n\r\n{1}", convention.GetType().Name, result.Message));
+            }
+            catch (ApprovalException ex)
+            {
+                throw new ConventionFailedException("Approved exceptions for convention differs\r\n\r\n"+ex.Message, ex);
             }
-
-            throw new ConventionFailedException(result.Message);
         }
     }
 }
diff --git a/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs b/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs
@@ -20,17 +20,23 @@ public ConventionResult Execute(Types data)
         {
             // do we want to encapsulate that in some way?
             // also notice how data gives us types, yet the convention acts upon methods.
-            var invalid = data.ApplicableTypes.ToLookup(t => t, t => t.NonVirtualMethods()).Where(l => l.Any());
-            return ConventionResult.For(invalid, HeaderMessage, DescribeTypeAndMethods);
+            var items = from applicableType in data.ApplicableTypes
+                        let nonVirtuals = applicableType.NonVirtualMethods()
+                        where nonVirtuals.Any()
+                        select Tuple.Create(applicableType, nonVirtuals);
+            return ConventionResult.For(items, HeaderMessage, DescribeTypeAndMethods);
         }
 
         // I like how that's encapsulated in the reusable convention type, whereas previously it was part of the convention/test code
-        void DescribeTypeAndMethods(IGrouping<Type, IEnumerable<MethodInfo>> item, StringBuilder message)
+        void DescribeTypeAndMethods(Tuple<Type, IEnumerable<MethodInfo>> item, StringBuilder message)
         {
-            message.AppendLine("\t" + item.Key);
-            foreach (var method in item)
+            foreach (var method in item.Item2)
             {
-                message.AppendLine("\t\t" + method);
+                message.Append("\t");
+                message.Append(item.Item1);
+                message.Append(".");
+                message.Append(method.Name);
+                message.AppendLine();
             }
         }
     }
diff --git a/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs b/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs
@@ -2,6 +2,7 @@
 {
     using System.Collections.Generic;
     using System.Linq;
+    using System.Text;
     using System.Text.RegularExpressions;
     using System.Xml.Linq;
     using TestStack.ConventionTests.Internal;
@@ -12,8 +13,15 @@ public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<Pr
 
         public ConventionResult Execute(Project data)
         {
-            var invalid = AllProjectReferences(data.GetProject()).Where(IsBinOrObjReference);
-            return ConventionResult.For(invalid, "Some invalid references found.", (r, m) => m.AppendLine("\t" + r));
+            var projDefinition = data.GetProject();
+            var invalid = AllProjectReferences(projDefinition).Where(IsBinOrObjReference);
+            var header = string.Format("Some invalid assembly references found in {0}", data.Assembly.GetName().Name);
+            return ConventionResult.For(invalid, header, FormatLine);
+        }
+
+        void FormatLine(string assemblyReference, StringBuilder m)
+        {
+            m.AppendLine("\t" + assemblyReference);
         }
 
         static bool IsBinOrObjReference(string reference)
diff --git a/TestStack.ConventionTests/IConventionData.cs b/TestStack.ConventionTests/IConventionData.cs
@@ -3,6 +3,5 @@
     public interface IConventionData
     {
         void ThrowIfHasInvalidSource();
-        bool HasApprovedExceptions { get; }
     }
 }
diff --git a/TestStack.ConventionTests/Internal/ConventionResult.cs b/TestStack.ConventionTests/Internal/ConventionResult.cs
@@ -7,9 +7,13 @@
 
     public class ConventionResult
     {
-        public string Message { get; set; }
+        ConventionResult() { }
 
-        public static ConventionResult For<TResult>(IEnumerable<TResult> items,
+        public string Message { get; private set; }
+        public bool Failed { get { return !string.IsNullOrEmpty(Message); }}
+
+        public static ConventionResult For<TResult>(
+            IEnumerable<TResult> items,
             string header,
             Action<TResult, StringBuilder> itemDescriptor)
         {
@@ -19,13 +23,12 @@ public static ConventionResult For<TResult>(IEnumerable<TResult> items,
             {
                 return result;
             }
+
             // NOTE: we might possibly want to abstract the StringBuilder to have more high level construct that would allow us to plug rich reports here...
             var message = new StringBuilder(header);
-            Array.ForEach(array, r =>
-            {
-                message.AppendLine();
-                itemDescriptor(r, message);
-            });
+            message.AppendLine();
+            message.AppendLine();
+            Array.ForEach(array, r => itemDescriptor(r, message));
             result.Message = message.ToString();
             return result;
         }
diff --git a/TestStack.ConventionTests/Internal/ReflectionExtensions.cs b/TestStack.ConventionTests/Internal/ReflectionExtensions.cs
@@ -87,10 +87,10 @@ public static IEnumerable<MethodInfo> NonVirtualMethods(this Type type)
             var methodInfos =
                 type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic |
                                 BindingFlags.DeclaredOnly);
-            return methodInfos
-                .Where(
-                    methodInfo =>
-                        !methodInfo.IsPrivate && methodInfo.DeclaringType == type && !methodInfo.Name.StartsWith("<"))
+            return methodInfos .Where(methodInfo =>
+                    !methodInfo.IsPrivate && 
+                    methodInfo.DeclaringType == type && 
+                    !methodInfo.Name.StartsWith("<"))
                 .Where(methodInfo => methodInfo.Name != "Equals")
                 .Where(methodInfo => !methodInfo.IsVirtual || methodInfo.IsFinal);
         }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Some invalid assembly references found in TestStack.ConventionTests.Tests`
	`2`	`+`
	`3`	`+ bin\Debug\ApprovalTests.dll`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+The following files which should be embedded resources:`
	`2`	`+`
	`3`	`+ Scripts\Script2.sql`