moved formatting into renderers

kkozmic · kkozmic · commit 827c41c73bc1 · 2013-08-18T12:54:56.000+10:00
They should be in control of how they want the data formatted. We still need to work on how to actually put the two together...
diff --git a/TestStack.ConventionTests/Internal/ConventionContext.cs b/TestStack.ConventionTests/Internal/ConventionContext.cs
@@ -6,7 +6,7 @@
     using TestStack.ConventionTests.Conventions;
     using TestStack.ConventionTests.Reporting;
 
-    public class ConventionContext : IConventionResultContext
+    public class ConventionContext : IConventionResultContext, IConventionFormatContext
     {
         readonly string dataDescription;
         readonly IList<IReportDataFormatter> formatters;
@@ -26,12 +26,25 @@ public ConventionResult[] ConventionResults
             get { return results.ToArray(); }
         }
 
+        ConventionReportFailure IConventionFormatContext.FormatData(object failingData)
+        {
+            var formatter = formatters.FirstOrDefault(f => f.CanFormat(failingData));
+            if (formatter == null)
+            {
+                throw new NoDataFormatterFoundException(
+                    failingData.GetType().Name +
+                    " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
+            }
+
+            return formatter.Format(failingData);
+        }
+
         void IConventionResultContext.Is<T>(string resultTitle, IEnumerable<T> failingData)
         {
             // ReSharper disable PossibleMultipleEnumeration
             results.Add(new ConventionResult(resultTitle,
                 dataDescription,
-                failingData.Select(FormatData).ToArray()));
+                failingData.ToObjectArray()));
         }
 
         void IConventionResultContext.IsSymmetric<TResult>(
@@ -40,10 +53,10 @@ void IConventionResultContext.IsSymmetric<TResult>(
         {
             results.Add(new ConventionResult(firstSetFailureTitle,
                 dataDescription,
-                firstSetFailureData.Select(FormatData).ToArray()));
+                firstSetFailureData.ToObjectArray()));
             results.Add(new ConventionResult(secondSetFailureTitle,
                 dataDescription,
-                secondSetFailureData.Select(FormatData).ToArray()));
+                secondSetFailureData.ToObjectArray()));
         }
 
         void IConventionResultContext.IsSymmetric<TResult>(
@@ -61,19 +74,6 @@ void IConventionResultContext.IsSymmetric<TResult>(
                 secondSetFailureTitle, secondSetFailingData);
         }
 
-        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);
-        }
-
         public void Execute<TDataSource>(IConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
@@ -83,7 +83,7 @@ public void Execute<TDataSource>(IConvention<TDataSource> convention, TDataSourc
 
             foreach (var resultsProcessor in processors)
             {
-                resultsProcessor.Process(ConventionResults);
+                resultsProcessor.Process(this, ConventionResults);
             }
         }
     }
diff --git a/TestStack.ConventionTests/Internal/ConventionResult.cs b/TestStack.ConventionTests/Internal/ConventionResult.cs
@@ -5,18 +5,18 @@
 
     public class ConventionResult
     {
-        public ConventionResult(string conventionTitle, string dataDescription, ConventionReportFailure[] conventionFailures)
+        public ConventionResult(string conventionTitle, string dataDescription, object[] data)
         {
             ConventionTitle = conventionTitle;
             DataDescription = dataDescription;
-            ConventionFailures = conventionFailures;
+            Data = data;
         }
 
         public TestResult Result
         {
             get
             {
-                if (ConventionFailures.Any())
+                if (Data.Any())
                 {
                     return TestResult.Failed;
                 }
@@ -26,7 +26,6 @@ public TestResult Result
 
         public string ConventionTitle { get; private set; }
         public string DataDescription { get; private set; }
-        public ConventionReportFailure[] ConventionFailures { get; private set; }
-        public string ApprovedException { get; private set; }
+        public object[] Data { get; private set; }
     }
 }
diff --git a/TestStack.ConventionTests/Internal/IConventionFormatContext.cs b/TestStack.ConventionTests/Internal/IConventionFormatContext.cs
@@ -0,0 +1,7 @@
+﻿namespace TestStack.ConventionTests.Internal
+{
+    public interface IConventionFormatContext
+    {
+        ConventionReportFailure FormatData(object failingData);
+    }
+}
diff --git a/TestStack.ConventionTests/Internal/LinqExtensions.cs b/TestStack.ConventionTests/Internal/LinqExtensions.cs
@@ -16,10 +16,14 @@ public static bool None<T>(this IEnumerable<T> enumerable, Func<T, bool> predica
             return !enumerable.Any(predicate);
         }
 
-
         public static IEnumerable<T> Unless<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
         {
             return enumerable.Where(i => predicate(i) == false);
         }
+
+        public static object[] ToObjectArray<T>(this IEnumerable<T> enumerable)
+        {
+            return enumerable.Select(x => (object) x).ToArray();
+        }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/ApproveResultsProcessor.cs b/TestStack.ConventionTests/Reporting/ApproveResultsProcessor.cs
@@ -7,12 +7,12 @@
 
     public class ApproveResultsProcessor : IResultsProcessor
     {
-        public void Process(params ConventionResult[] results)
+        public void Process(IConventionFormatContext context, params ConventionResult[] results)
         {
             try
             {
                 var conventionReportTextRenderer = new ConventionReportTextRenderer();
-                conventionReportTextRenderer.Process(results);
+                conventionReportTextRenderer.Process(context, results);
                 Approvals.Verify(conventionReportTextRenderer.Output);
             }
             catch (ApprovalException ex)
diff --git a/TestStack.ConventionTests/Reporting/ConventionReportTextRenderer.cs b/TestStack.ConventionTests/Reporting/ConventionReportTextRenderer.cs
@@ -5,7 +5,7 @@
 
     public class ConventionReportTextRenderer : IResultsProcessor
     {
-        public void Process(params ConventionResult[] results)
+        public void Process(IConventionFormatContext context, params ConventionResult[] results)
         {
             var stringBuilder = new StringBuilder();
 
@@ -17,14 +17,7 @@ public void Process(params ConventionResult[] results)
                 stringBuilder.AppendLine(string.Empty.PadRight(title.Length, '-'));
                 stringBuilder.AppendLine();
 
-                if (!string.IsNullOrEmpty(conventionReport.ApprovedException))
-                {
-                    stringBuilder.AppendLine("With approved exceptions:");
-                    stringBuilder.AppendLine(conventionReport.ApprovedException);
-                    stringBuilder.AppendLine();
-                }
-
-                RenderItems(conventionReport, stringBuilder);
+                RenderItems(conventionReport, stringBuilder, context);
                 stringBuilder.AppendLine();
                 stringBuilder.AppendLine();
             }
@@ -34,19 +27,12 @@ public void Process(params ConventionResult[] results)
 
         public string Output { get; private set; }
 
-        public void RenderItems(ConventionResult conventionResult)
-        {
-            var stringBuilder = new StringBuilder();
-            RenderItems(conventionResult, stringBuilder);
-            Output = stringBuilder.ToString();
-        }
-
-        static void RenderItems(ConventionResult resultInfo, StringBuilder stringBuilder)
+        static void RenderItems(ConventionResult resultInfo, StringBuilder stringBuilder, IConventionFormatContext context)
         {
-            foreach (var conventionFailure in resultInfo.ConventionFailures)
+            foreach (var conventionFailure in resultInfo.Data)
             {
                 stringBuilder.Append("\t");
-                stringBuilder.AppendLine(conventionFailure.ToString());
+                stringBuilder.AppendLine(context.FormatData(conventionFailure).ToString());
             }
         }
     }
diff --git a/TestStack.ConventionTests/Reporting/ConventionReportTraceRenderer.cs b/TestStack.ConventionTests/Reporting/ConventionReportTraceRenderer.cs
@@ -5,10 +5,10 @@
 
     public class ConventionReportTraceRenderer : IResultsProcessor
     {
-        public void Process(params ConventionResult[] results)
+        public void Process(IConventionFormatContext context, params ConventionResult[] results)
         {
             var conventionReportTextRenderer = new ConventionReportTextRenderer();
-            conventionReportTextRenderer.Process(results);
+            conventionReportTextRenderer.Process(context, results);
             Trace.WriteLine(conventionReportTextRenderer.Output);
         }
     }
diff --git a/TestStack.ConventionTests/Reporting/HtmlReportRenderer.cs b/TestStack.ConventionTests/Reporting/HtmlReportRenderer.cs
@@ -18,7 +18,7 @@ public HtmlReportRenderer(string assemblyDirectory)
             file = Path.Combine(assemblyDirectory, "Conventions.htm");
         }
 
-        public void Process(params ConventionResult[] results)
+        public void Process(IConventionFormatContext context, params ConventionResult[] results)
         {
             Reports.AddRange(results);
             var sb = new StringBuilder();
@@ -43,28 +43,14 @@ public void Process(params ConventionResult[] results)
                 html.RenderEndTag();
                 var title = String.Format("{0} for {1}", conventionReport.ConventionTitle, conventionReport.DataDescription);
                 html.Write(title);
-                if (!String.IsNullOrEmpty(conventionReport.ApprovedException))
-                {
-                    html.RenderBeginTag(HtmlTextWriterTag.Div);
-                    html.RenderBeginTag(HtmlTextWriterTag.Strong);
-                    html.WriteLine("With approved exceptions:");
-                    html.RenderEndTag();
-                    html.RenderEndTag();
-                }
                 
                 html.RenderBeginTag(HtmlTextWriterTag.Ul);
 
-                if (!String.IsNullOrEmpty(conventionReport.ApprovedException))
-                {
-                    html.RenderBeginTag(HtmlTextWriterTag.Li);
-                    html.WriteLine(conventionReport.ApprovedException);
-                    html.RenderEndTag();
-                }
 
-                foreach (var conventionFailure in conventionReport.ConventionFailures)
+                foreach (var conventionFailure in conventionReport.Data)
                 {
                     html.RenderBeginTag(HtmlTextWriterTag.Li);
-                    html.Write(conventionFailure.ToString());
+                    html.Write(context.FormatData(conventionFailure).ToString());
                     html.RenderEndTag();
                 }
 
diff --git a/TestStack.ConventionTests/Reporting/IResultsProcessor.cs b/TestStack.ConventionTests/Reporting/IResultsProcessor.cs
@@ -4,6 +4,6 @@
 
     public interface IResultsProcessor
     {
-        void Process(params ConventionResult[] results);
+        void Process(IConventionFormatContext context, params ConventionResult[] results);
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/ThrowOnFailureResultsProcessor.cs b/TestStack.ConventionTests/Reporting/ThrowOnFailureResultsProcessor.cs
@@ -5,10 +5,10 @@
 
     public class ThrowOnFailureResultsProcessor : IResultsProcessor
     {
-        public void Process(params ConventionResult[] results)
+        public void Process(IConventionFormatContext context, params ConventionResult[] results)
         {
             var conventionReportTextRenderer = new ConventionReportTextRenderer();
-            conventionReportTextRenderer.Process(results);
+            conventionReportTextRenderer.Process(context, results);
             if (results.Any(r => r.Result == TestResult.Failed))
             {
                 throw new ConventionFailedException(conventionReportTextRenderer.Output);
diff --git a/TestStack.ConventionTests/TestStack.ConventionTests.csproj b/TestStack.ConventionTests/TestStack.ConventionTests.csproj
@@ -63,6 +63,7 @@
     <Compile Include="Internal\ConventionReportFailure.cs" />
     <Compile Include="Internal\ConventionContext.cs" />
     <Compile Include="Internal\ConventionResult.cs" />
+    <Compile Include="Internal\IConventionFormatContext.cs" />
     <Compile Include="Internal\NoDataFormatterFoundException.cs" />
     <Compile Include="Reporting\ApproveResultsProcessor.cs" />
     <Compile Include="Reporting\CsvReporter.cs" />

Original file line number	Diff line number	Diff line change
`@@ -5,18 +5,18 @@`
`5`	`5`
`6`	`6`	`public class ConventionResult`
`7`	`7`	`{`
`8`		`- public ConventionResult(string conventionTitle, string dataDescription, ConventionReportFailure[] conventionFailures)`
	`8`	`+ public ConventionResult(string conventionTitle, string dataDescription, object[] data)`
`9`	`9`	`{`
`10`	`10`	`ConventionTitle = conventionTitle;`
`11`	`11`	`DataDescription = dataDescription;`
`12`		`- ConventionFailures = conventionFailures;`
	`12`	`+ Data = data;`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`public TestResult Result`
`16`	`16`	`{`
`17`	`17`	`get`
`18`	`18`	`{`
`19`		`- if (ConventionFailures.Any())`
	`19`	`+ if (Data.Any())`
`20`	`20`	`{`
`21`	`21`	`return TestResult.Failed;`
`22`	`22`	`}`
`@@ -26,7 +26,6 @@ public TestResult Result`
`26`	`26`
`27`	`27`	`public string ConventionTitle { get; private set; }`
`28`	`28`	`public string DataDescription { get; private set; }`
`29`		`- public ConventionReportFailure[] ConventionFailures { get; private set; }`
`30`		`- public string ApprovedException { get; private set; }`
	`29`	`+ public object[] Data { get; private set; }`
`31`	`30`	`}`
`32`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,14 @@ public static bool None<T>(this IEnumerable<T> enumerable, Func<T, bool> predica`
`16`	`16`	`return !enumerable.Any(predicate);`
`17`	`17`	`}`
`18`	`18`
`19`		`-`
`20`	`19`	`public static IEnumerable<T> Unless<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)`
`21`	`20`	`{`
`22`	`21`	`return enumerable.Where(i => predicate(i) == false);`
`23`	`22`	`}`
	`23`	`+`
	`24`	`+ public static object[] ToObjectArray<T>(this IEnumerable<T> enumerable)`
	`25`	`+ {`
	`26`	`+ return enumerable.Select(x => (object) x).ToArray();`
	`27`	`+ }`
`24`	`28`	`}`
`25`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,12 @@`
`7`	`7`
`8`	`8`	`public class ApproveResultsProcessor : IResultsProcessor`
`9`	`9`	`{`
`10`		`- public void Process(params ConventionResult[] results)`
	`10`	`+ public void Process(IConventionFormatContext context, params ConventionResult[] results)`
`11`	`11`	`{`
`12`	`12`	`try`
`13`	`13`	`{`
`14`	`14`	`var conventionReportTextRenderer = new ConventionReportTextRenderer();`
`15`		`- conventionReportTextRenderer.Process(results);`
	`15`	`+ conventionReportTextRenderer.Process(context, results);`
`16`	`16`	`Approvals.Verify(conventionReportTextRenderer.Output);`
`17`	`17`	`}`
`18`	`18`	`catch (ApprovalException ex)`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`public class ConventionReportTextRenderer : IResultsProcessor`
`7`	`7`	`{`
`8`		`- public void Process(params ConventionResult[] results)`
	`8`	`+ public void Process(IConventionFormatContext context, params ConventionResult[] results)`
`9`	`9`	`{`
`10`	`10`	`var stringBuilder = new StringBuilder();`
`11`	`11`
`@@ -17,14 +17,7 @@ public void Process(params ConventionResult[] results)`
`17`	`17`	`stringBuilder.AppendLine(string.Empty.PadRight(title.Length, '-'));`
`18`	`18`	`stringBuilder.AppendLine();`
`19`	`19`
`20`		`- if (!string.IsNullOrEmpty(conventionReport.ApprovedException))`
`21`		`- {`
`22`		`- stringBuilder.AppendLine("With approved exceptions:");`
`23`		`- stringBuilder.AppendLine(conventionReport.ApprovedException);`
`24`		`- stringBuilder.AppendLine();`
`25`		`- }`
`26`		`-`
`27`		`- RenderItems(conventionReport, stringBuilder);`
	`20`	`+ RenderItems(conventionReport, stringBuilder, context);`
`28`	`21`	`stringBuilder.AppendLine();`
`29`	`22`	`stringBuilder.AppendLine();`
`30`	`23`	`}`
`@@ -34,19 +27,12 @@ public void Process(params ConventionResult[] results)`
`34`	`27`
`35`	`28`	`public string Output { get; private set; }`
`36`	`29`
`37`		`- public void RenderItems(ConventionResult conventionResult)`
`38`		`- {`
`39`		`- var stringBuilder = new StringBuilder();`
`40`		`- RenderItems(conventionResult, stringBuilder);`
`41`		`- Output = stringBuilder.ToString();`
`42`		`- }`
`43`		`-`
`44`		`- static void RenderItems(ConventionResult resultInfo, StringBuilder stringBuilder)`
	`30`	`+ static void RenderItems(ConventionResult resultInfo, StringBuilder stringBuilder, IConventionFormatContext context)`
`45`	`31`	`{`
`46`		`- foreach (var conventionFailure in resultInfo.ConventionFailures)`
	`32`	`+ foreach (var conventionFailure in resultInfo.Data)`
`47`	`33`	`{`
`48`	`34`	`stringBuilder.Append("\t");`
`49`		`- stringBuilder.AppendLine(conventionFailure.ToString());`
	`35`	`+ stringBuilder.AppendLine(context.FormatData(conventionFailure).ToString());`
`50`	`36`	`}`
`51`	`37`	`}`
`52`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,10 @@`
`5`	`5`
`6`	`6`	`public class ConventionReportTraceRenderer : IResultsProcessor`
`7`	`7`	`{`
`8`		`- public void Process(params ConventionResult[] results)`
	`8`	`+ public void Process(IConventionFormatContext context, params ConventionResult[] results)`
`9`	`9`	`{`
`10`	`10`	`var conventionReportTextRenderer = new ConventionReportTextRenderer();`
`11`		`- conventionReportTextRenderer.Process(results);`
	`11`	`+ conventionReportTextRenderer.Process(context, results);`
`12`	`12`	`Trace.WriteLine(conventionReportTextRenderer.Output);`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@`
`4`	`4`
`5`	`5`	`public interface IResultsProcessor`
`6`	`6`	`{`
`7`		`- void Process(params ConventionResult[] results);`
	`7`	`+ void Process(IConventionFormatContext context, params ConventionResult[] results);`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,10 @@`
`5`	`5`
`6`	`6`	`public class ThrowOnFailureResultsProcessor : IResultsProcessor`
`7`	`7`	`{`
`8`		`- public void Process(params ConventionResult[] results)`
	`8`	`+ public void Process(IConventionFormatContext context, params ConventionResult[] results)`
`9`	`9`	`{`
`10`	`10`	`var conventionReportTextRenderer = new ConventionReportTextRenderer();`
`11`		`- conventionReportTextRenderer.Process(results);`
	`11`	`+ conventionReportTextRenderer.Process(context, results);`
`12`	`12`	`if (results.Any(r => r.Result == TestResult.Failed))`
`13`	`13`	`{`
`14`	`14`	`throw new ConventionFailedException(conventionReportTextRenderer.Output);`