Adds global type filtering (#90)

Author: andrewabest

src/Core/Conventional.Tests/AsyncConformistScenarios.cs

@@ -44,24 +44,55 @@ public override async Task<ConventionResult> IsSatisfiedBy(Type type)
 
     public class AsyncConformistScenarios
     {
+        [SetUp]
+        public void Setup()
+        {
+            ConventionConfiguration.GlobalTypeFilter = type => type != typeof(YouCantSeeMe);
+        }
+
         [Test]
         public void HappyPath_DoesNotThrowExceptions()
         {
-            Action action = async  () => await typeof(String).MustConformTo(new AlwaysSuccessfulAsyncConvention());
+            Action action = async () => await typeof(String).MustConformTo(new AlwaysSuccessfulAsyncConvention());
 
             action.ShouldNotThrow();
         }
 
         [Test]
         public async Task FluentSyntax_OutputsExpectedFailuresInCorrectOrder()
         {
-            var results = await new[] {typeof(String)}
+            var results = await new[] { typeof(String) }
                 .MustConformTo(new NeverSuccessfulAsyncConvention())
                 .AndMustConformTo(new AlsoNeverSuccessfulAsyncConvention());
 
             results.Failures.Should().HaveCount(2);
             results.Failures[0].Should().StartWith("I failed!");
             results.Failures[1].Should().StartWith("I also failed!");
         }
+
+        private class YouCantSeeMe
+        {
+            public string Name { get; set; }
+        }
+
+        private class YouCanSeeMe
+        {
+            public string Name { get; set; }
+        }
+
+        [Test]
+        public async Task WhenDefaultTypeFilterIsSet_ItIsAppliedToAllConventions()
+        {
+            var result = await new[] { typeof(YouCantSeeMe), typeof(YouCanSeeMe) }
+                .MustConformTo(new NeverSuccessfulAsyncConvention());
+
+            result.Failures.Should().HaveCount(1);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            ConventionConfiguration.ResetGlobalTypeFilter();
+        }
     }
 }

src/Core/Conventional.Tests/ConventionConfigurationScenarios.cs

@@ -1,4 +1,5 @@
-using NUnit.Framework;
+using FluentAssertions;
+using NUnit.Framework;
 
 namespace Conventional.Tests
 {
@@ -8,8 +9,9 @@ public class ConventionConfigurationScenarios
         public void Setup()
         {
             ConventionConfiguration.DefaultFailureAssertionCallback = Assert.Pass;
+            ConventionConfiguration.GlobalTypeFilter = type => type != typeof(YouCantSeeMe);
         }
-
+        
         private class AbjectConformanceFailure
         {
             public AbjectConformanceFailure(string name, string description)
@@ -39,11 +41,30 @@ public void WhenDefaultFailureAssertionIsSet_AndWeHaveACompositeConvention_Autom
                         Convention.PropertiesMustHavePublicSetters.And(
                             Convention.MustHaveADefaultConstructor)));
         }
+        
+        private class YouCantSeeMe
+        {
+            public string Name { get; set; }
+        }
+
+        private class YouCanSeeMe
+        {
+            public string Name { get; set; }
+        }
+        
+        [Test]
+        public void WhenDefaultTypeFilterIsSet_ItIsAppliedToAllConventions()
+        {
+            new[] { typeof(YouCantSeeMe), typeof(YouCanSeeMe) }
+                .MustConformTo(Convention.PropertiesMustHavePrivateSetters)
+                .Failures.Should().HaveCount(1);
+        }
 
         [TearDown]
         public void TearDown()
         {
             ConventionConfiguration.DefaultFailureAssertionCallback = null;
+            ConventionConfiguration.ResetGlobalTypeFilter();
         }
     }
 }

src/Core/Conventional/AsyncConformist.cs

@@ -15,9 +15,11 @@ public static async Task<ConventionResult> MustConformTo(this Type type, IAsyncC
 
         public static async Task<WrappedConventionResult> MustConformTo(this IEnumerable<Type> types, IAsyncConventionSpecification conventionSpecification)
         {
+            var filteredTypes = types.Where(ConventionConfiguration.GlobalTypeFilter).ToArray();
+
             return Conformist.EnforceConformance(new WrappedConventionResult(
-                types,
-                await Task.WhenAll(types.Select(conventionSpecification.IsSatisfiedBy))));
+                filteredTypes,
+                await Task.WhenAll(filteredTypes.Select(conventionSpecification.IsSatisfiedBy))));
         }
 
         public static async Task<WrappedConventionResult> AndMustConformTo(this Task<WrappedConventionResult> results, IAsyncConventionSpecification conventionSpecification)

src/Core/Conventional/Conformist.cs

@@ -15,9 +15,11 @@ public static ConventionResult MustConformTo(this Type type, IConventionSpecific
 
         public static WrappedConventionResult MustConformTo(this IEnumerable<Type> types, IConventionSpecification conventionSpecification)
         {
+            var filteredTypes = types.Where(ConventionConfiguration.GlobalTypeFilter).ToArray();
+            
             return EnforceConformance(new WrappedConventionResult(
-                types, 
-                types.Select(conventionSpecification.IsSatisfiedBy)));
+                filteredTypes, 
+                filteredTypes.Select(conventionSpecification.IsSatisfiedBy)));
         }
 
         public static ConventionResult MustConformTo(this Assembly assembly, IAssemblyConventionSpecification assemblyConventionSpecification)

src/Core/Conventional/ConventionConfiguration.cs

@@ -7,5 +7,11 @@ public static class ConventionConfiguration
         public static Action<string> DefaultFailureAssertionCallback { get; set; }
         public static Action<string> DefaultWarningAssertionCallback { get; set; }
         public static Func<DateTime> DefaultCurrentDateResolver { get; set; } = () => DateTime.UtcNow;
+        private static readonly Func<Type, bool> DefaultGlobalTypeFilter = t => true;
+        public static Func<Type, bool> GlobalTypeFilter { get; set; } = DefaultGlobalTypeFilter;
+        public static void ResetGlobalTypeFilter()
+        {
+            GlobalTypeFilter = DefaultGlobalTypeFilter;
+        }
     }
 }