Added better IsSymmetric overload thanks to @kkozmic

Author: Jake Ginnivan

TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs

@@ -1,7 +1,6 @@
 namespace TestStack.ConventionTests.Conventions
 {
     using System;
-    using System.Linq;
     using TestStack.ConventionTests.ConventionData;
 
     /// <summary>
@@ -34,18 +33,17 @@ public ClassTypeHasSpecificNamespace(Func<Type, bool> classIsApplicable, string
 
         public void Execute(Types data, IConventionResult result)
         {
-            var failingData = data.TypesToVerify
-                .Where(classIsApplicable)
-                .Where(t => t.Namespace == null || !t.Namespace.StartsWith(namespaceToCheck));
-            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);
+                classIsApplicable,
+                TypeLivesInSpecifiedNamespace,
+                data.TypesToVerify);
+        }
+
+        bool TypeLivesInSpecifiedNamespace(Type t)
+        {
+            return t.Namespace == null || t.Namespace.StartsWith(namespaceToCheck);
         }
     }
 }

TestStack.ConventionTests/IConventionResult.cs

@@ -6,8 +6,37 @@
     public interface IConventionResult
     {
         void Is<T>(string resultTitle, IEnumerable<T> failingData);
-        void IsSymmetric<T>(
-            string firstResultTitle, IEnumerable<T> firstFailingData,
-            string secondResultTitle, IEnumerable<T> secondFailingData);
+
+        /// <summary>
+        ///     A symmetric convention is a convention which also can be applied in reverse. For example
+        ///     All dto's live in Project.Dto namespace AND Only dto's live in Project.Dto
+        ///     This means if a DTO is outside of Project.Dto, the test will fail,
+        ///     and if a non-dto is in Project.Dto the test will also fail
+        /// </summary>
+        /// <typeparam name="TResult">The data type the convention is applied to</typeparam>
+        /// <param name="conventionResultTitle">Title of the convention, i.e Dto's must live in Project.Dto namespace</param>
+        /// <param name="conventionFailingData">Data failing to conform to the convention</param>
+        /// <param name="inverseResultTitle">The inverse scenario title, i.e Non-dtos must not live inside Project.Dto namespace</param>
+        /// <param name="inverseFailingData">Data failing to conform to the inverse of the convention</param>
+        void IsSymmetric<TResult>(
+            string conventionResultTitle, IEnumerable<TResult> conventionFailingData,
+            string inverseResultTitle, IEnumerable<TResult> inverseFailingData);
+
+        /// <summary>
+        ///     A symmetric convention is a convention which also can be applied in reverse. For example
+        ///     All dto's live in Project.Dto namespace AND Only dto's live in Project.Dto
+        ///     This means if a DTO is outside of Project.Dto, the test will fail,
+        ///     and if a non-dto is in Project.Dto the test will also fail
+        /// </summary>
+        /// <typeparam name="TResult">The data type the convention is applied to</typeparam>
+        /// <param name="conventionResultTitle">Title of the convention, i.e Dto's must live in Project.Dto namespace</param>
+        /// <param name="inverseResultTitle">The inverse scenario title, i.e Non-dtos must not live inside Project.Dto namespace</param>
+        /// <param name="isInclusiveData">Predicate describing if the data is included, for example, t => t.Name.EndsWith("Dto")</param>
+        /// <param name="dataConformsToConvention">
+        ///     Predicate describing the convention, for example, t =>
+        ///     t.NameSpace.StartsWith("Project.Dto")
+        /// </param>
+        /// <param name="allData">All data, for dto example, all types in the project, not just dto's</param>
+        void IsSymmetric<TResult>(string conventionResultTitle, string inverseResultTitle, Func<TResult, bool> isInclusiveData, Func<TResult, bool> dataConformsToConvention, IEnumerable<TResult> allData);
     }
 }

TestStack.ConventionTests/Internal/ConventionResult.cs

@@ -1,13 +1,14 @@
 namespace TestStack.ConventionTests.Internal
 {
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using TestStack.ConventionTests.Reporting;
 
     public class ConventionResult : IConventionResult
     {
-        readonly string dataDescription;
         readonly List<ResultInfo> conventionResults;
+        readonly string dataDescription;
 
         public ConventionResult(string dataDescription)
         {
@@ -30,28 +31,44 @@ public void Is<T>(string resultTitle, IEnumerable<T> failingData)
                 failingData.Select(FormatData).ToArray()));
         }
 
-        public void IsSymmetric<T>(
-            string firstResultTitle, IEnumerable<T> firstFailingData,
-            string secondResultTitle, IEnumerable<T> secondFailingData)
+        public void IsSymmetric<TResult>(
+            string conventionResultTitle, IEnumerable<TResult> conventionFailingData,
+            string inverseResultTitle, IEnumerable<TResult> inverseFailingData)
         {
             conventionResults.Add(new ResultInfo(
-                firstFailingData.None() ? TestResult.Passed : TestResult.Failed,
-                firstResultTitle,
+                conventionFailingData.None() ? TestResult.Passed : TestResult.Failed,
+                conventionResultTitle,
                 dataDescription,
-                firstFailingData.Select(FormatData).ToArray()));
+                conventionFailingData.Select(FormatData).ToArray()));
             conventionResults.Add(new ResultInfo(
-                secondFailingData.None() ? TestResult.Passed : TestResult.Failed,
-                secondResultTitle,
+                inverseFailingData.None() ? TestResult.Passed : TestResult.Failed,
+                inverseResultTitle,
                 dataDescription,
-                secondFailingData.Select(FormatData).ToArray()));
+                inverseFailingData.Select(FormatData).ToArray()));
+        }
+
+        public void IsSymmetric<TResult>(string conventionResultTitle, string inverseResultTitle,
+            Func<TResult, bool> isInclusiveData, Func<TResult, bool> dataConformsToConvention,
+            IEnumerable<TResult> allData)
+        {
+            var conventionFailingData = allData.Where(isInclusiveData).Where(d => !dataConformsToConvention(d));
+            var inverseFailingData = allData.Where(d => !isInclusiveData(d)).Where(dataConformsToConvention);
+
+            IsSymmetric(
+                conventionResultTitle, conventionFailingData,
+                inverseResultTitle, inverseFailingData);
         }
 
         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());`");
+            {
+                throw new NoDataFormatterFoundException(
+                    typeof (T).Name +
+                    " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
+            }
 
             return formatter.Format(failingData);
         }