Using specific exceptions for errors

Author: Jake Ginnivan

TestStack.ConventionTests.Tests/ProjectBasedConventions.cs

@@ -9,42 +9,39 @@
     using TestStack.ConventionTests.Tests.Properties;
 
     [TestFixture]
-    [UseReporter(typeof (DiffReporter))]
+    [UseReporter(typeof(DiffReporter))]
     public class ProjectBasedConventions
     {
-        public ProjectBasedConventions()
+        Project project;
+        IProjectProvider projectProvider;
+
+        [SetUp]
+        public void Setup()
         {
-            Convention.Settings.AssertInclunclusive = Assert.Inconclusive;
-            Convention.Settings.AssertZero = (v, m) => Assert.AreEqual(0, v, m);
+            projectProvider = Substitute.For<IProjectProvider>();
+            var projectLocator = Substitute.For<IProjectLocator>();
+            project = new Project(typeof(ProjectBasedConventions).Assembly, projectProvider, projectLocator);
         }
 
         [Test]
         public void ReferencingBinObj()
         {
-            var projectProvider = Substitute.For<IProjectProvider>();
-            var projectLocator = Substitute.For<IProjectLocator>();
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithBinReference));
 
-            Convention.Is(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(),
-                new Project(typeof (ProjectBasedConventions).Assembly, projectProvider, projectLocator));
+            Convention.Is(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(), project);
         }
-         
+
         [Test]
         public void ScriptsNotEmbeddedResources()
         {
-            var projectProvider = Substitute.For<IProjectProvider>();
-            var projectLocator = Substitute.For<IProjectLocator>();
+            project.Includes = i => i.EndsWith(".sql");
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithInvalidSqlScriptFile));
 
-            Convention.Is(new FilesAreEmbeddedResources(),
-                new Project(typeof (ProjectBasedConventions).Assembly, projectProvider, projectLocator)
-                {
-                    Includes = i => i.EndsWith(".sql")
-                });
+            Convention.Is(new FilesAreEmbeddedResources(), project);
         }
     }
 }

TestStack.ConventionTests.Tests/TypeBasedConventions.cs

@@ -13,15 +13,10 @@ public class TypeBasedConventions
 
         public TypeBasedConventions()
         {
-            // TODO: This should go to some sort of autodiscovery mechanism so users don't have to see this shit
-            Convention.Settings.AssertInclunclusive = Assert.Inconclusive;
-            Convention.Settings.AssertZero = (v, m) => Assert.AreEqual(0, v, m);
-
             var itemsToVerify = typeof (SampleDomainClass).Assembly.GetTypes();
             nhibernateEntities = new Types
             {
-                ApplicableTypes = itemsToVerify,
-                HasApprovedExceptions = false
+                ApplicableTypes = itemsToVerify
             };
         }
 

TestStack.ConventionTests/Convention.cs

@@ -1,45 +1,32 @@
 namespace TestStack.ConventionTests
 {
-    using System;
+    using System.Diagnostics;
     using ApprovalTests;
+    using ApprovalTests.Core.Exceptions;
 
     public static class Convention
     {
-        public static readonly ConventionSettings Settings = new ConventionSettings();
-
         public static void Is<TData>(IConvention<TData> convention, TData data) where TData : IConventionData
         {
-            if (data.HasValidSource == false)
-            {
-                // TODO: this would have to have a more reasonable and helpful message...
-                Settings.AssertInclunclusive("No valid source in " + data);
-                return;
-            }
+            data.ThrowIfHasInvalidSource();
             var result = convention.Execute(data);
-            if (result.IsConclusive == false)
-            {
-                Settings.AssertInclunclusive(result.Message);
-                return;
-            }
             if (data.HasApprovedExceptions)
             {
                 // should we encapsulate Approvals behind Settings?
-                Approvals.Verify(result.Message);
+                try
+                {
+                    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;
             }
-            Settings.AssertZero(result.InvalidResultsCount, result.Message);
-        }
-
-        public class ConventionSettings
-        {
-            public Action<String> AssertInclunclusive;
 
-            public Action<int, string> AssertZero;
-
-            public ConventionSettings()
-            {
-                // TODO: initialize the type;
-            }
+            throw new ConventionFailedException(result.Message);
         }
     }
 }

TestStack.ConventionTests/ConventionFailedException.cs

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

TestStack.ConventionTests/Conventions/ConventionSourceInvalidException.cs

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

TestStack.ConventionTests/Conventions/Project.cs

@@ -22,9 +22,10 @@ public Project(Assembly assembly, IProjectProvider projectProvider, IProjectLoca
 
         public IProjectProvider ProjectProvider { get; private set; }
 
-        public bool HasValidSource
+        public void ThrowIfHasInvalidSource()
         {
-            get { return ProjectLocator.ResolveProjectFilePath(Assembly) != null; }
+            if (ProjectLocator.ResolveProjectFilePath(Assembly) == null)
+                throw new ConventionSourceInvalidException("Cannot resolve project file for assembly {0}");
         }
 
         public bool HasApprovedExceptions { get; set; }

TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs

@@ -16,7 +16,6 @@ public ConventionResult Execute(Project data)
             return ConventionResult.For(invalid, "Some invalid references found.", (r, m) => m.AppendLine("\t" + r));
         }
 
-
         static bool IsBinOrObjReference(string reference)
         {
             return Regex.IsMatch(reference, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase);

TestStack.ConventionTests/Conventions/Types.cs

@@ -1,7 +1,7 @@
 namespace TestStack.ConventionTests.Conventions
 {
     using System;
-    using System.Linq;
+    using TestStack.ConventionTests.Internal;
 
     /// <summary>
     ///     This is where we set what our convention is all about.
@@ -13,9 +13,10 @@ public class Types : IConventionData
 
         public bool HasApprovedExceptions { get; set; }
 
-        public bool HasValidSource
+        public void ThrowIfHasInvalidSource()
         {
-            get { return ApplicableTypes.Any(); }
+            if (ApplicableTypes.None())
+                throw new ConventionSourceInvalidException("You must supply types to verify");
         }
     }
 }

TestStack.ConventionTests/IConventionData.cs

@@ -2,7 +2,7 @@
 {
     public interface IConventionData
     {
-        bool HasValidSource { get; }
+        void ThrowIfHasInvalidSource();
         bool HasApprovedExceptions { get; }
     }
 }

TestStack.ConventionTests/Internal/ConventionResult.cs

@@ -8,20 +8,13 @@
     public class ConventionResult
     {
         public string Message { get; set; }
-        public bool IsConclusive { get; set; }
-        // TODO: perhaps name it better so that it doesn't get confused with System.Exception and related concepts
-        public int InvalidResultsCount { get; set; }
 
         public static ConventionResult For<TResult>(IEnumerable<TResult> items,
             string header,
             Action<TResult, StringBuilder> itemDescriptor)
         {
             var array = items.ToArray();
-            var result = new ConventionResult
-            {
-                InvalidResultsCount = array.Length,
-                IsConclusive = true
-            };
+            var result = new ConventionResult();
             if (array.None())
             {
                 return result;
@@ -36,14 +29,5 @@ public static ConventionResult For<TResult>(IEnumerable<TResult> items,
             result.Message = message.ToString();
             return result;
         }
-
-        public static ConventionResult Inconclusive(string message)
-        {
-            return new ConventionResult
-            {
-                Message = message,
-                IsConclusive = false
-            };
-        }
     }
 }