added ConvetionTest/Data for non-type based tests

added IProjectLocator for locating based on debugging info in a project

Author: kkozmic

ConventionTests/ConventionTests.csproj

@@ -43,6 +43,7 @@
     <Reference Include="Castle.Windsor">
       <HintPath>..\packages\Castle.Windsor.3.0.0.4001\lib\net40\Castle.Windsor.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.Build.Engine" />
     <Reference Include="Mono.Cecil">
       <HintPath>..\packages\Mono.Cecil.0.9.5.4\lib\net40\Mono.Cecil.dll</HintPath>
     </Reference>
@@ -67,12 +68,18 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Conventions\Internal\AssemblyProjectLocator.cs" />
     <Compile Include="Conventions\Internal\ConventionData.cs" />
+    <Compile Include="Conventions\Internal\ConventionData.Generic.cs" />
     <Compile Include="Conventions\Internal\ConventionTest.cs" />
+    <Compile Include="Conventions\Internal\ConventionTest.Generic.cs" />
     <Compile Include="Conventions\Internal\ConventionTestBase.cs" />
     <Compile Include="Conventions\Internal\ConventionTestNamer.cs" />
     <Compile Include="Conventions\Internal\IAssert.cs" />
     <Compile Include="Conventions\Internal\IConventionTest.cs" />
+    <Compile Include="Conventions\Internal\IProjectLocator.cs" />
+    <Compile Include="Conventions\Internal\ProjectConventionData.cs" />
+    <Compile Include="Conventions\Internal\ProjectConvetionTest.cs" />
     <Compile Include="Conventions\Internal\ReflectionExtensions.cs" />
     <Compile Include="Conventions\Internal\WindsorConventionData.cs" />
     <Compile Include="Conventions\Internal\WindsorConventionTest.cs" />

ConventionTests/Conventions/Internal/AssemblyProjectLocator.cs

@@ -0,0 +1,55 @@
+namespace ConventionTests
+{
+    using System;
+    using System.Reflection;
+    using Mono.Cecil;
+    using Mono.Cecil.Cil;
+
+    public class AssemblyProjectLocator : IProjectLocator
+    {
+        readonly Assembly assembly;
+
+        public AssemblyProjectLocator(Assembly assembly)
+        {
+            this.assembly = assembly;
+        }
+
+        public string ProjectFilePath
+        {
+            get { return ResolveProjectFilePath(); }
+        }
+
+        string ResolveProjectFilePath()
+        {
+            var readerParameters = new ReaderParameters {ReadSymbols = true, ReadingMode = ReadingMode.Deferred};
+            var definition = AssemblyDefinition.ReadAssembly(assembly.Location, readerParameters);
+            var methodDefinition = GetMethodWithBody(definition);
+            var document = GetMethodDocument(methodDefinition);
+            return document.Url;
+        }
+
+        static Document GetMethodDocument(MethodDefinition methodDefinition)
+        {
+            var instruction = methodDefinition.Body.Instructions[0];
+            var document = instruction.SequencePoint.Document;
+            return document;
+        }
+
+        static MethodDefinition GetMethodWithBody(AssemblyDefinition definition)
+        {
+            foreach (var type in definition.MainModule.Types)
+            {
+                if (type.HasMethods == false) continue;
+
+                foreach (var method in type.Methods)
+                {
+                    if (method.HasBody)
+                    {
+                        return method;
+                    }
+                }
+            }
+            throw new InvalidOperationException("Coudln't find any type with methods with body");
+        }
+    }
+}

ConventionTests/Conventions/Internal/ConventionData.Generic.cs

@@ -0,0 +1,85 @@
+namespace ConventionTests
+{
+    using System;
+    using System.Text;
+
+    /// <summary>
+    ///     This is where we set what our convention is all about
+    /// </summary>
+    public class ConventionData<TItem>
+    {
+        public static readonly Predicate<TItem> All = _ => true;
+        public static readonly Predicate<TItem> None = _ => false;
+        Action<TItem, StringBuilder> DefaultItemDescription = DefaultItemDescriptionMethod;
+
+        static void DefaultItemDescriptionMethod(TItem item, StringBuilder message)
+        {
+            if (ReferenceEquals(item, null))
+            {
+                message.AppendLine("<<null>>");
+            }
+            else
+            {
+                message.AppendLine(item.ToString());
+            }
+        }
+
+
+        public ConventionData(params TItem[] sourceItems)
+        {
+            SourceItems = sourceItems;
+            Items = All;
+            Must = None;
+            OrderBy = HashCode;
+            ItemDescription = DefaultItemDescription;
+        }
+
+        public TItem[] SourceItems { get; set; }
+
+        public Func<TItem, object> OrderBy { get; set; }
+
+        /// <summary>
+        ///     Descriptive text used for failure message in test. Should explan what is wrong, and how to fix it (how to make types that do not conform to the convention do so).
+        /// </summary>
+        public string Description { get; set; }
+
+        /// <summary>
+        ///     Specifies that there are valid exceptions to the rule specified by the convention.
+        /// </summary>
+        /// <remarks>
+        ///     When set to <c>true</c> will run the test as Approval test so that the exceptional cases can be reviewed and approved.
+        /// </remarks>
+        public bool HasApprovedExceptions { get; set; }
+
+        /// <summary>
+        ///     This is the convention. The predicate should return <c>true</c> for types that do conform to the convention, and <c>false</c> otherwise
+        /// </summary>
+        public Predicate<TItem> Must { get; set; }
+
+        /// <summary>
+        ///     Predicate that finds types that we want to apply out convention to.
+        /// </summary>
+        public Predicate<TItem> Items { get; set; }
+
+        public Action<TItem, StringBuilder> ItemDescription { get; set; }
+
+        object HashCode(TItem arg)
+        {
+            if (ReferenceEquals(arg, null))
+            {
+                return 0;
+            }
+            return arg.GetHashCode();
+        }
+
+        /// <summary>
+        ///     helper method to set <see cref="HasApprovedExceptions" /> in a more convenient manner.
+        /// </summary>
+        /// <returns> </returns>
+        public ConventionData<TItem> WithApprovedExceptions(string explanation = null)
+        {
+            HasApprovedExceptions = true;
+            return this;
+        }
+    }
+}

ConventionTests/Conventions/Internal/ConventionData.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Reflection;
+    using System.Text;
 
     /// <summary>
     ///     This is where we set what our convention is all about
@@ -31,7 +32,6 @@ public ConventionData(params Type[] sourceTypes)
 
         public Type[] SourceTypes { get; set; }
 
-
         /// <summary>
         ///     list of assemblies to scan for types that our convention is related to. Can be null, in which case all assemblies starting with The same prefix as your test assembly will be scanned
         /// </summary>
@@ -60,7 +60,7 @@ public ConventionData(params Type[] sourceTypes)
         /// </summary>
         public Predicate<Type> Types { get; set; }
 
-        public Func<Type, string> ItemDescription { get; set; }
+        public Action<Type, StringBuilder> ItemDescription { get; set; }
 
         /// <summary>
         ///     helper method to set <see cref="Assemblies" /> in a more convenient manner.

ConventionTests/Conventions/Internal/ConventionTest.Generic.cs

@@ -0,0 +1,56 @@
+namespace ConventionTests
+{
+    using System;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    ///     Base class for convention tests. Inherited types should be put in "/Conventions" folder in test assembly and follow Sentence_naming_convention_with_underscores_indead_of_spaces These tests will be ran by
+    ///     <see
+    ///         cref="ConventionTestsRunner" />
+    ///     .
+    /// </summary>
+    public abstract class ConventionTest<TItem> : ConventionTestBase
+    {
+        public override void Execute(IAssert assert)
+        {
+            var data = SetUp();
+            var itemsToTest = GetItemsToTest(data);
+            if (itemsToTest.Length == 0)
+            {
+                assert.Inconclusive(
+                    "No items found to apply the convention to. Make sure the Items predicate is correct and that the right sourceItems are specified.");
+            }
+            var invalidItems = Array.FindAll(itemsToTest, t => data.Must(t) == false);
+            var message = new StringBuilder();
+            message.AppendLine(data.Description ?? "Invalid items found");
+            foreach (var invalidType in invalidItems)
+            {
+                message.Append('\t');
+                data.ItemDescription(invalidType, message);
+            }
+            if (data.HasApprovedExceptions)
+            {
+                Approve(message.ToString());
+            }
+            else
+            {
+                assert.AreEqual(0, invalidItems.Count(), message.ToString());
+            }
+        }
+
+        /// <summary>
+        ///     This is the only method you need to override. Return a <see cref="ConventionData" /> that describes your convention.
+        /// </summary>
+        /// <returns> </returns>
+        protected abstract ConventionData<TItem> SetUp();
+
+        protected virtual TItem[] GetItemsToTest(ConventionData<TItem> data)
+        {
+            return data.SourceItems
+                       .Where(data.Items.Invoke)
+                       .OrderBy(data.OrderBy)
+                       .ToArray();
+        }
+    }
+}

ConventionTests/Conventions/Internal/ConventionTest.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Linq;
     using System.Reflection;
+    using System.Text;
 
     /// <summary>
     ///     Base class for convention tests. Inherited types should be put in "/Conventions" folder in test assembly and follow Sentence_naming_convention_with_underscores_indead_of_spaces These tests will be ran by
@@ -21,17 +22,22 @@ public override void Execute(IAssert assert)
                 assert.Inconclusive(
                     "No types found to apply the convention to. Make sure the Types predicate is correct and that the right assemblies to scan are specified.");
             }
-            var itemDescription = (data.ItemDescription ?? (t => t.ToString()));
-            var invalidTypes = Array.FindAll(typesToTest, t => data.Must(t) == false);
-            var message = (data.Description ?? "Invalid types found") + Environment.NewLine + "\t" +
-                          string.Join(Environment.NewLine + "\t", invalidTypes.Select(itemDescription));
+            var invalidItems = Array.FindAll(typesToTest, t => data.Must(t) == false);
+
+            var message = new StringBuilder();
+            message.AppendLine(data.Description ?? "Invalid types found");
+            foreach (var invalidType in invalidItems)
+            {
+                message.Append('\t');
+                data.ItemDescription(invalidType, message);
+            }
             if (data.HasApprovedExceptions)
             {
-                Approve(message);
+                Approve(message.ToString());
             }
             else
             {
-                assert.AreEqual(0, invalidTypes.Count(), message);
+                assert.AreEqual(0, invalidItems.Count(), message.ToString());
             }
         }
 

ConventionTests/Conventions/Internal/IProjectLocator.cs

@@ -0,0 +1,7 @@
+namespace ConventionTests
+{
+    public interface IProjectLocator
+    {
+        string ProjectFilePath { get; }
+    }
+}

ConventionTests/Conventions/Internal/ProjectConventionData.cs

@@ -0,0 +1,24 @@
+namespace ConventionTests
+{
+    using System;
+    using System.Reflection;
+
+    public class ProjectConventionData
+    {
+        readonly IProjectLocator projectLocator;
+
+        public ProjectConventionData(IProjectLocator projectLocator)
+        {
+            this.projectLocator = projectLocator;
+        }
+
+        public ProjectConventionData(Assembly assembly) : this(new AssemblyProjectLocator(assembly))
+        {
+
+        }
+
+        public ProjectConventionData(Type type) : this(type.Assembly)
+        {
+        }
+    }
+}

ConventionTests/Conventions/Internal/ProjectConvetionTest.cs

@@ -0,0 +1,16 @@
+namespace ConventionTests
+{
+    public abstract class ProjectConvetionTest : ConventionTestBase
+    {
+        public override void Execute(IAssert assert)
+        {
+            var data = SetUp();
+        }
+
+        /// <summary>
+        ///     This is the only method you need to override. Return a <see cref="ConventionData" /> that describes your convention.
+        /// </summary>
+        /// <returns> </returns>
+        protected abstract ProjectConventionData SetUp();
+    }
+}

ConventionTests/Conventions/Internal/WindsorConventionTest.cs

@@ -71,7 +71,6 @@ TDiagnosticData[] GetDataToTest(WindsorConventionData<TDiagnosticData> data)
         protected abstract WindsorConventionData<TDiagnosticData> SetUp();
     }
 
-
     public abstract class WindsorConventionTest : ConventionTestBase
     {
         public override void Execute(IAssert assert)