Pulled out data formatters

Author: Jake Ginnivan

TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs

@@ -20,17 +20,17 @@ public void approval_mismatch()
             StringAssert.Contains("does not match approved file", ex.Message);
         }
 
-        public class FakeData : IConventionData, ICreateReportLineFor<string>
+        public class FakeData : IConventionData
         {
             public string Description { get { return "Fake data"; } }
 
             public void EnsureHasNonEmptySource()
             {
             }
 
-            public ConventionFailure CreateReportLine(string failingData)
+            public ConventionReportFailure Format(string failingData)
             {
-                return new ConventionFailure(failingData);
+                return new ConventionReportFailure(failingData);
             }
         }
 

TestStack.ConventionTests/Convention.cs

@@ -9,22 +9,36 @@
     using ApprovalTests.Core.Exceptions;
     using TestStack.ConventionTests.Conventions;
     using TestStack.ConventionTests.Internal;
+    using TestStack.ConventionTests.Reporting;
 
     public static class Convention
     {
         static readonly HtmlReportRenderer HtmlRenderer = new HtmlReportRenderer(AssemblyDirectory);
-        static readonly List<ConventionReport> Reports = new List<ConventionReport>();
+        static readonly List<ResultInfo> Reports = new List<ResultInfo>();
 
-        public static IEnumerable<ConventionReport> ConventionReports { get { return Reports; } }
+        static Convention()
+        {
+            Formatters = new List<IReportDataFormatter>
+            {
+                new TypeDataFormatter(),
+                new ProjectReferenceFormatter(),
+                new ProjectFileFormatter(),
+                new MethodInfoDataFormatter(),
+                new StringDataFormatter()
+            };
+        }
+
+        public static IEnumerable<ResultInfo> ConventionReports { get { return Reports; } }
+        public static IList<IReportDataFormatter> Formatters { get; private set; } 
 
         public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             Is(convention, data, new ConventionResultExceptionReporter());
         }
 
         public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter) 
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             try
             {
@@ -42,7 +56,7 @@ public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType
         }
 
         public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
             Reports.Add(conventionResult);
@@ -69,13 +83,13 @@ public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<T
         }
 
         public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             Is(convention, data, new ConventionResultExceptionReporter());
         }
 
         public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             try
             {
@@ -95,7 +109,7 @@ public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource,
         }
 
         public static void IsWithApprovedExeptions<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+            where TDataSource : IConventionData
         {
             var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
             var inverseConventionResult = GetConventionReport(convention.InverseTitle, convention.GetFailingInverseData(data).ToArray(), data);
@@ -130,20 +144,30 @@ public static void IsWithApprovedExeptions<TDataSource, TDataType>(ISymmetricCon
             }
         }
 
-        static ConventionReport GetConventionReport<TDataSource, TDataType>(string conventionTitle, TDataType[] failingData, TDataSource data)
-            where TDataSource : IConventionData, ICreateReportLineFor<TDataType>
+        static ResultInfo GetConventionReport<TDataSource, TDataType>(string conventionTitle, TDataType[] failingData, TDataSource data)
+            where TDataSource : IConventionData
         {
             data.EnsureHasNonEmptySource();
             var passed = failingData.None();
 
-            var conventionResult = new ConventionReport(
-                passed ? Result.Passed : Result.Failed,
+            var conventionResult = new ResultInfo(
+                passed ? TestResult.Passed : TestResult.Failed,
                 conventionTitle,
                 data.Description,
-                failingData.Select(data.CreateReportLine));
+                failingData.Select(FormatData).ToArray());
             return conventionResult;
         }
 
+        static ConventionReportFailure FormatData<T>(T failingData)
+        {
+            var formatter = 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);
+        }
+
         // http://stackoverflow.com/questions/52797/c-how-do-i-get-the-path-of-the-assembly-the-code-is-in#answer-283917
         static string AssemblyDirectory
         {

TestStack.ConventionTests/ConventionData/ProjectFiles.cs

@@ -5,7 +5,7 @@
     using System.Xml.Linq;
     using TestStack.ConventionTests.Internal;
 
-    public class ProjectFiles : AbstractProjectData, ICreateReportLineFor<ProjectFile>
+    public class ProjectFiles : AbstractProjectData
     {
         public ProjectFiles(Assembly assembly, IProjectProvider projectProvider, IProjectLocator projectLocator)
             : base(assembly, projectProvider, projectLocator)
@@ -31,10 +31,5 @@ public ProjectFile[] Files
                     .ToArray();
             }
         }
-
-        public ConventionFailure CreateReportLine(ProjectFile failingData)
-        {
-            return new ConventionFailure(failingData.FilePath);
-        }
     }
 }

TestStack.ConventionTests/ConventionData/ProjectReferences.cs

@@ -7,12 +7,11 @@
     using System.Xml.Linq;
     using TestStack.ConventionTests.Internal;
 
-    public class ProjectReferences : AbstractProjectData, ICreateReportLineFor<ProjectReference>
+    public class ProjectReferences : AbstractProjectData
     {
         public ProjectReferences(Assembly assembly, IProjectProvider projectProvider, IProjectLocator projectLocator)
             : base(assembly, projectProvider, projectLocator)
         {
-            Items = PredicateHelpers.All<ProjectReference>();
         }
 
         public ProjectReference[] References
@@ -25,7 +24,6 @@ public ProjectReference[] References
                     {
                         ReferencedPath = r
                     })
-                    .Where(Items)
                     .ToArray();
             }
         }
@@ -41,12 +39,5 @@ static IEnumerable<string> AllProjectReferences(XDocument projDefinition)
                 .Select(refElem => refElem.Value);
             return references;
         }
-
-        public Func<ProjectReference, bool> Items { get; set; }
-
-        public ConventionFailure CreateReportLine(ProjectReference failingData)
-        {
-            return new ConventionFailure(failingData.ReferencedPath);
-        }
     }
 }

TestStack.ConventionTests/ConventionData/Types.cs

@@ -1,14 +1,13 @@
 namespace TestStack.ConventionTests.ConventionData
 {
     using System;
-    using System.Reflection;
     using TestStack.ConventionTests.Conventions;
     using TestStack.ConventionTests.Internal;
 
     /// <summary>
     ///     This is where we set what our convention is all about.
     /// </summary>
-    public class Types : IConventionData, ICreateReportLineFor<Type>, ICreateReportLineFor<MethodInfo>
+    public class Types : IConventionData
     {
         public Types(string descriptionOfTypes)
         {
@@ -24,15 +23,5 @@ public void EnsureHasNonEmptySource()
             if (TypesToVerify.None())
                 throw new ConventionSourceInvalidException("You must supply types to verify");
         }
-
-        public ConventionFailure CreateReportLine(Type failingData)
-        {
-            return new ConventionFailure(failingData.FullName);
-        }
-
-        public ConventionFailure CreateReportLine(MethodInfo failingData)
-        {
-            return new ConventionFailure(failingData.DeclaringType + "." + failingData.Name);
-        }
     }
 }

TestStack.ConventionTests/ConventionReport.cs

@@ -1,17 +1,17 @@
-namespace TestStack.ConventionTests
-{
-    public class ConventionFailure
-    {
-        public string Failure { get; set; }
-
-        public ConventionFailure(string failure)
-        {
-            Failure = failure;
-        }
-
-        public override string ToString()
-        {
-            return Failure;
-        }
-    }
+namespace TestStack.ConventionTests.Internal
+{
+    public class ConventionReportFailure
+    {
+        public string Failure { get; set; }
+
+        public ConventionReportFailure(string failure)
+        {
+            Failure = failure;
+        }
+
+        public override string ToString()
+        {
+            return Failure;
+        }
+    }
 }

TestStack.ConventionTests/IConventionReportRenderer.cs

@@ -0,0 +1,27 @@
+namespace TestStack.ConventionTests.Internal
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [Serializable]
+    public class NoDataFormatterFoundException : Exception
+    {
+        public NoDataFormatterFoundException()
+        {
+        }
+
+        public NoDataFormatterFoundException(string message) : base(message)
+        {
+        }
+
+        public NoDataFormatterFoundException(string message, Exception inner) : base(message, inner)
+        {
+        }
+
+        protected NoDataFormatterFoundException(
+            SerializationInfo info,
+            StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}