Introduced a IConventionResult to clean things up

Jake Ginnivan · Jake Ginnivan · commit c1514c8c753b · 2013-08-11T20:54:25.000+01:00
diff --git a/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs b/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs
@@ -1,6 +1,5 @@
 ﻿namespace TestStack.ConventionTests.Tests
 {
-    using System.Collections.Generic;
     using ApprovalTests.Reporters;
     using NUnit.Framework;
     using TestStack.ConventionTests.Internal;
@@ -34,10 +33,9 @@ public ConventionReportFailure Format(string failingData)
 
         public class FailingConvention : IConvention<FakeData>
         {
-            public string ConventionTitle { get { return "Header"; } }
-            public IEnumerable<object> GetFailingData(FakeData data)
+            public void Execute(FakeData data, IConventionResult result)
             {
-                return new[] { "Different" };
+                result.Is("Header", new[] {"Different"});
             }
         }
     }
diff --git a/TestStack.ConventionTests/Convention.cs b/TestStack.ConventionTests/Convention.cs
@@ -3,11 +3,9 @@
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
     using System.Reflection;
     using ApprovalTests;
     using ApprovalTests.Core.Exceptions;
-    using TestStack.ConventionTests.Conventions;
     using TestStack.ConventionTests.Internal;
     using TestStack.ConventionTests.Reporting;
 
@@ -42,8 +40,8 @@ public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSou
         {
             try
             {
-                var conventionResult = Executor.GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
-                Reports.Add(conventionResult);
+                var conventionResult = Executor.GetConventionResults(convention, data);
+                Reports.AddRange(conventionResult);
 
                 new ConventionReportTraceRenderer().Render(conventionResult);
                 reporter.Render(conventionResult);
@@ -57,8 +55,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.GetConventionReportWithApprovedExeptions(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
-            Reports.Add(conventionResult);
+            var conventionResult = Executor.GetConventionResultsWithApprovedExeptions(convention, data);
+            Reports.AddRange(conventionResult);
 
             try
             {
@@ -78,60 +76,6 @@ public static void IsWithApprovedExeptions<TDataSource>(IConvention<TDataSource>
             }
         }
 
-        public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)
-            where TDataSource : IConventionData
-        {
-            Is(convention, data, new ConventionResultExceptionReporter());
-        }
-
-        public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data, IConventionReportRenderer reporter)
-            where TDataSource : IConventionData
-        {
-            try
-            {
-                var conventionResult = Executor.GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
-                var inverseConventionResult = Executor.GetConventionReport(convention.InverseTitle, convention.GetFailingInverseData(data).ToArray(), data);
-
-                Reports.Add(conventionResult);
-                Reports.Add(inverseConventionResult);
-
-                new ConventionReportTraceRenderer().Render(conventionResult, inverseConventionResult);
-                reporter.Render(conventionResult, inverseConventionResult);
-            }
-            finally
-            {
-                HtmlRenderer.Render(Reports.ToArray());
-            }
-        }
-
-        public static void IsWithApprovedExeptions<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)
-            where TDataSource : IConventionData
-        {
-            var conventionResult = Executor.GetConventionReportWithApprovedExeptions(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
-            var inverseConventionResult = Executor.GetConventionReportWithApprovedExeptions(convention.InverseTitle, convention.GetFailingInverseData(data).ToArray(), data);
-            Reports.Add(conventionResult);
-            Reports.Add(inverseConventionResult);
-
-            try
-            {
-                //Render both, with approved exceptions included
-                var conventionReportTextRenderer = new ConventionReportTextRenderer();
-                conventionReportTextRenderer.Render(conventionResult, inverseConventionResult);
-                Approvals.Verify(conventionReportTextRenderer.Output);
-
-                // Trace on success
-                new ConventionReportTraceRenderer().Render(conventionResult, inverseConventionResult);
-            }
-            catch (ApprovalException ex)
-            {
-                throw new ConventionFailedException("Approved exceptions for convention differs\r\n\r\n" + ex.Message, ex);
-            }
-            finally
-            {
-                HtmlRenderer.Render(Reports.ToArray());
-            }
-        }
-
         // http://stackoverflow.com/questions/52797/c-how-do-i-get-the-path-of-the-assembly-the-code-is-in#answer-283917
         static string AssemblyDirectory
         {
diff --git a/TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs b/TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs
@@ -1,17 +1,15 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
-    using System.Collections.Generic;
     using System.Linq;
     using TestStack.ConventionTests.ConventionData;
     using TestStack.ConventionTests.Internal;
 
     public class AllClassesHaveDefaultConstructor : IConvention<Types>
     {
-        public string ConventionTitle { get { return "Types must have a default constructor"; } }
-
-        public IEnumerable<object> GetFailingData(Types data)
+        public void Execute(Types data, IConventionResult result)
         {
-            return data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false);
+            result.Is("Types must have a default constructor",
+                data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false));
         }
     }
 }
diff --git a/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs b/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs
@@ -1,18 +1,14 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
-    using System.Collections.Generic;
     using System.Linq;
-    using System.Reflection;
     using TestStack.ConventionTests.ConventionData;
     using TestStack.ConventionTests.Internal;
 
     public class AllMethodsAreVirtual : IConvention<Types>
     {
-        public string ConventionTitle { get { return "Methods must be virtual"; } }
-
-        public IEnumerable<object> GetFailingData(Types data)
+        public void Execute(Types data, IConventionResult result)
         {
-            return data.TypesToVerify.SelectMany(t => t.NonVirtualMethods());
+            result.Is("Methods must be virtual", data.TypesToVerify.SelectMany(t => t.NonVirtualMethods()));
         }
     }
 }
diff --git a/TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs b/TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs
@@ -1,7 +1,6 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
     using System;
-    using System.Collections.Generic;
     using System.Linq;
     using TestStack.ConventionTests.ConventionData;
 
@@ -14,7 +13,7 @@
     /// 
     /// This is a Symmetric convention, and will verify all of a Class Type lives in the namespace, but also that only that class type is in that namespace
     /// </summary>
-    public class ClassTypeHasSpecificNamespace : ISymmetricConvention<Types>
+    public class ClassTypeHasSpecificNamespace : IConvention<Types>
     {
         readonly Func<Type, bool> classIsApplicable;
         readonly string namespaceToCheck;
@@ -33,34 +32,20 @@ public ClassTypeHasSpecificNamespace(Func<Type, bool> classIsApplicable, string
             this.classType = classType;
         }
 
-        public string ConventionTitle
+        public void Execute(Types data, IConventionResult result)
         {
-            get
-            {
-                return string.Format("{0}s must be under the '{1}' namespace", classType, namespaceToCheck);
-            }
-        }
-
-        public string InverseTitle
-        {
-            get
-            {
-                return string.Format("Non-{0}s must not be under the '{1}' namespace", classType, namespaceToCheck);
-            }
-        }
-
-        public IEnumerable<object> GetFailingData(Types data)
-        {
-            return data.TypesToVerify
+            var failingData = data.TypesToVerify
                 .Where(classIsApplicable)
                 .Where(t => t.Namespace == null || !t.Namespace.StartsWith(namespaceToCheck));
-        }
-
-        public IEnumerable<object> GetFailingInverseData(Types data)
-        {
-            return data.TypesToVerify
+            var inverseFailingData = data.TypesToVerify
                 .Where(t => !classIsApplicable(t))
                 .Where(t => t.Namespace != null && t.Namespace.StartsWith(namespaceToCheck));
+
+            result.IsSymmetric(
+                string.Format("{0}s must be under the '{1}' namespace", classType, namespaceToCheck),
+                failingData, 
+                string.Format("Non-{0}s must not be under the '{1}' namespace", classType, namespaceToCheck),
+                inverseFailingData);
         }
     }
 }
diff --git a/TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs b/TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs
@@ -1,6 +1,5 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
-    using System.Collections.Generic;
     using System.Linq;
     using TestStack.ConventionTests.ConventionData;
 
@@ -11,19 +10,13 @@ public FilesAreEmbeddedResources(string fileExtension)
             FileExtension = fileExtension;
         }
 
-        public string ConventionTitle
-        {
-            get
-            {
-                return string.Format("{0} Files must be embedded resources", FileExtension);
-            }
-        }
-
-        public string FileExtension { get; set; }
+        public string FileExtension { get; private set; }
 
-        public IEnumerable<object> GetFailingData(ProjectFiles data)
+        public void Execute(ProjectFiles data, IConventionResult result)
         {
-            return data.Files.Where(s => s.FilePath.EndsWith(FileExtension) && s.ReferenceType != "EmbeddedResource");
+            result.Is(
+                string.Format("{0} Files must be embedded resources", FileExtension),
+                data.Files.Where(s => s.FilePath.EndsWith(FileExtension) && s.ReferenceType != "EmbeddedResource"));
         }
     }
 }
diff --git a/TestStack.ConventionTests/Conventions/ISymmetricConvention.cs b/TestStack.ConventionTests/Conventions/ISymmetricConvention.cs
diff --git a/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs b/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs
@@ -1,6 +1,5 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
-    using System.Collections.Generic;
     using System.Linq;
     using System.Text.RegularExpressions;
     using TestStack.ConventionTests.ConventionData;
@@ -9,16 +8,15 @@ public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<Pr
     {
         const string AssemblyReferencingObjRegex = @"^(?<assembly>.*?(obj|bin).*?)$";
 
-        static bool IsBinOrObjReference(ProjectReference reference)
+        public void Execute(ProjectReferences data, IConventionResult result)
         {
-            return Regex.IsMatch(reference.ReferencedPath, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase);
+            result.Is("Project must not reference dlls from bin or obj directories",
+                data.References.Where(IsBinOrObjReference));
         }
 
-        public string ConventionTitle { get { return "Project must not reference dlls from bin or obj directories"; } }
-
-        public IEnumerable<object> GetFailingData(ProjectReferences data)
+        static bool IsBinOrObjReference(ProjectReference reference)
         {
-            return data.References.Where(IsBinOrObjReference);
+            return Regex.IsMatch(reference.ReferencedPath, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase);
         }
     }
 }
diff --git a/TestStack.ConventionTests/IConvention.cs b/TestStack.ConventionTests/IConvention.cs
@@ -1,10 +1,7 @@
 ﻿namespace TestStack.ConventionTests
 {
-    using System.Collections.Generic;
-
     public interface IConvention<in T> where T : IConventionData
     {
-        string ConventionTitle { get; }
-        IEnumerable<object> GetFailingData(T data);
+        void Execute(T data, IConventionResult result);
     }
 }
diff --git a/TestStack.ConventionTests/IConventionResult.cs b/TestStack.ConventionTests/IConventionResult.cs
@@ -0,0 +1,13 @@
+﻿namespace TestStack.ConventionTests
+{
+    using System;
+    using System.Collections.Generic;
+
+    public interface IConventionResult
+    {
+        void Is<T>(string resultTitle, IEnumerable<T> failingData);
+        void IsSymmetric<T>(
+            string firstResultTitle, IEnumerable<T> firstFailingData,
+            string secondResultTitle, IEnumerable<T> secondFailingData);
+    }
+}
diff --git a/TestStack.ConventionTests/Internal/ConventionResult.cs b/TestStack.ConventionTests/Internal/ConventionResult.cs
@@ -0,0 +1,59 @@
+﻿namespace TestStack.ConventionTests.Internal
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using TestStack.ConventionTests.Reporting;
+
+    public class ConventionResult : IConventionResult
+    {
+        readonly string dataDescription;
+        readonly List<ResultInfo> conventionResults;
+
+        public ConventionResult(string dataDescription)
+        {
+            this.dataDescription = dataDescription;
+            conventionResults = new List<ResultInfo>();
+        }
+
+        public ResultInfo[] ConventionResults
+        {
+            get { return conventionResults.ToArray(); }
+        }
+
+        public void Is<T>(string resultTitle, IEnumerable<T> failingData)
+        {
+            // ReSharper disable PossibleMultipleEnumeration
+            conventionResults.Add(new ResultInfo(
+                failingData.None() ? TestResult.Passed : TestResult.Failed,
+                resultTitle,
+                dataDescription,
+                failingData.Select(FormatData).ToArray()));
+        }
+
+        public void IsSymmetric<T>(
+            string firstResultTitle, IEnumerable<T> firstFailingData,
+            string secondResultTitle, IEnumerable<T> secondFailingData)
+        {
+            conventionResults.Add(new ResultInfo(
+                firstFailingData.None() ? TestResult.Passed : TestResult.Failed,
+                firstResultTitle,
+                dataDescription,
+                firstFailingData.Select(FormatData).ToArray()));
+            conventionResults.Add(new ResultInfo(
+                secondFailingData.None() ? TestResult.Passed : TestResult.Failed,
+                secondResultTitle,
+                dataDescription,
+                secondFailingData.Select(FormatData).ToArray()));
+        }
+
+        static ConventionReportFailure FormatData<T>(T failingData)
+        {
+            var formatter = Convention.Formatters.FirstOrDefault(f => f.CanFormat(failingData));
+
+            if (formatter == null)
+                throw new NoDataFormatterFoundException(typeof(T).Name + " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
+
+            return formatter.Format(failingData);
+        }
+    }
+}
diff --git a/TestStack.ConventionTests/Internal/Executor.cs b/TestStack.ConventionTests/Internal/Executor.cs
diff --git a/TestStack.ConventionTests/TestStack.ConventionTests.csproj b/TestStack.ConventionTests/TestStack.ConventionTests.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`namespace TestStack.ConventionTests.Tests`
`2`	`2`	`{`
`3`		`- using System.Collections.Generic;`
`4`	`3`	`using ApprovalTests.Reporters;`
`5`	`4`	`using NUnit.Framework;`
`6`	`5`	`using TestStack.ConventionTests.Internal;`
`@@ -34,10 +33,9 @@ public ConventionReportFailure Format(string failingData)`
`34`	`33`
`35`	`34`	`public class FailingConvention : IConvention<FakeData>`
`36`	`35`	`{`
`37`		`- public string ConventionTitle { get { return "Header"; } }`
`38`		`- public IEnumerable<object> GetFailingData(FakeData data)`
	`36`	`+ public void Execute(FakeData data, IConventionResult result)`
`39`	`37`	`{`
`40`		`- return new[] { "Different" };`
	`38`	`+ result.Is("Header", new[] {"Different"});`
`41`	`39`	`}`
`42`	`40`	`}`
`43`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,15 @@`
`1`	`1`	`namespace TestStack.ConventionTests.Conventions`
`2`	`2`	`{`
`3`		`- using System.Collections.Generic;`
`4`	`3`	`using System.Linq;`
`5`	`4`	`using TestStack.ConventionTests.ConventionData;`
`6`	`5`	`using TestStack.ConventionTests.Internal;`
`7`	`6`
`8`	`7`	`public class AllClassesHaveDefaultConstructor : IConvention<Types>`
`9`	`8`	`{`
`10`		`- public string ConventionTitle { get { return "Types must have a default constructor"; } }`
`11`		`-`
`12`		`- public IEnumerable<object> GetFailingData(Types data)`
	`9`	`+ public void Execute(Types data, IConventionResult result)`
`13`	`10`	`{`
`14`		`- return data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false);`
	`11`	`+ result.Is("Types must have a default constructor",`
	`12`	`+ data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false));`
`15`	`13`	`}`
`16`	`14`	`}`
`17`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,14 @@`
`1`	`1`	`namespace TestStack.ConventionTests.Conventions`
`2`	`2`	`{`
`3`		`- using System.Collections.Generic;`
`4`	`3`	`using System.Linq;`
`5`		`- using System.Reflection;`
`6`	`4`	`using TestStack.ConventionTests.ConventionData;`
`7`	`5`	`using TestStack.ConventionTests.Internal;`
`8`	`6`
`9`	`7`	`public class AllMethodsAreVirtual : IConvention<Types>`
`10`	`8`	`{`
`11`		`- public string ConventionTitle { get { return "Methods must be virtual"; } }`
`12`		`-`
`13`		`- public IEnumerable<object> GetFailingData(Types data)`
	`9`	`+ public void Execute(Types data, IConventionResult result)`
`14`	`10`	`{`
`15`		`- return data.TypesToVerify.SelectMany(t => t.NonVirtualMethods());`
	`11`	`+ result.Is("Methods must be virtual", data.TypesToVerify.SelectMany(t => t.NonVirtualMethods()));`
`16`	`12`	`}`
`17`	`13`	`}`
`18`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,7 @@`
`1`	`1`	`namespace TestStack.ConventionTests`
`2`	`2`	`{`
`3`		`- using System.Collections.Generic;`
`4`		`-`
`5`	`3`	`public interface IConvention<in T> where T : IConventionData`
`6`	`4`	`{`
`7`		`- string ConventionTitle { get; }`
`8`		`- IEnumerable<object> GetFailingData(T data);`
	`5`	`+ void Execute(T data, IConventionResult result);`
`9`	`6`	`}`
`10`	`7`	`}`