migrated the Project file base conventions

They are pretty nasty to look at, since we're pretty much dealing with raw XML of the .csproj.
We probably want to build some sort of abstraction over that (or use the existing one from Microsoft.MsBuild.something.dll

Author: kkozmic

TestStack.ConventionTests.Tests/ProjectBasedConventions.cs

@@ -1,7 +1,6 @@
 namespace TestStack.ConventionTests.Tests
 {
     using System.Xml.Linq;
-    using ApprovalTests;
     using ApprovalTests.Reporters;
     using NSubstitute;
     using NUnit.Framework;
@@ -10,49 +9,42 @@
     using TestStack.ConventionTests.Tests.Properties;
 
     [TestFixture]
-    [UseReporter(typeof(DiffReporter))]
+    [UseReporter(typeof (DiffReporter))]
     public class ProjectBasedConventions
     {
+        public ProjectBasedConventions()
+        {
+            Convention.Settings.AssertInclunclusive = Assert.Inconclusive;
+            Convention.Settings.AssertZero = (v, m) => Assert.AreEqual(0, v, m);
+        }
+
         [Test]
         public void ReferencingBinObj()
         {
-            // Actual syntax will be (when not testing):
-            //
-            // Convention.Is<ProjectDoesNotReferenceDllsFromBinOrObjDirectories>(new[] { typeof(ProjectBasedConventions).Assembly });
-            //
-
             var projectProvider = Substitute.For<IProjectProvider>();
             var projectLocator = Substitute.For<IProjectLocator>();
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithBinReference));
 
-            var convention = new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(projectLocator, projectProvider);
-
-            var exception = Assert.Throws<ConventionFailedException>(() =>
-                Convention.Is(convention, new[] { typeof(ProjectBasedConventions).Assembly }));
-            Approvals.Verify(exception.Message);
+            Convention.Is(new ProjectDoesNotReferenceDllsFromBinOrObjDirectories(),
+                new Project(typeof (ProjectBasedConventions).Assembly, projectProvider, projectLocator));
         }
-
+         
         [Test]
         public void ScriptsNotEmbeddedResources()
         {
-            // Actual syntax will be (when not testing):
-            //
-            // Convention.Is<FilesAreEmbeddedResources>(new[] { typeof(ProjectBasedConventions).Assembly }, i => i.EndsWith(".sql"));
-            //
-
             var projectProvider = Substitute.For<IProjectProvider>();
             var projectLocator = Substitute.For<IProjectLocator>();
             projectProvider
                 .LoadProjectDocument(Arg.Any<string>())
                 .Returns(XDocument.Parse(Resources.ProjectFileWithInvalidSqlScriptFile));
 
-            var convention = new FilesAreEmbeddedResources(projectLocator, projectProvider);
-
-            var exception = Assert.Throws<ConventionFailedException>(() =>
-                Convention.Is(convention, new[] { typeof(ProjectBasedConventions).Assembly }, i => i.EndsWith(".sql")));
-            Approvals.Verify(exception.Message);
+            Convention.Is(new FilesAreEmbeddedResources(),
+                new Project(typeof (ProjectBasedConventions).Assembly, projectProvider, projectLocator)
+                {
+                    Includes = i => i.EndsWith(".sql")
+                });
         }
     }
 }

TestStack.ConventionTests/Convention.cs

@@ -34,48 +34,6 @@ public static void Is<TData>(IConvention<TData> convention, TData data) where TD
             Settings.AssertZero(result.InvalidResultsCount, result.Message);
         }
 
-        public static void Is<T, T2>(IEnumerable<T2> itemsToVerify) where T : ConventionData<T2>, new()
-        {
-            Is(new T(), itemsToVerify);
-        }
-        public static void Is<T, T2>(IEnumerable<T2> itemsToVerify, Func<string, bool> filter)
-            where T : ConventionData<T2>, IRuntimeFilter<string>, new()
-        {
-            Is(new T(), itemsToVerify);
-        }
-        public static void Is<T, T2, TItem>(IEnumerable<T2> itemsToVerify, Func<TItem, bool> filter) 
-            where T : ConventionData<T2>, IRuntimeFilter<TItem>, new()
-        {
-            Is(new T(), itemsToVerify);
-        }
-
-        //Item.Is<ConventionData<Type>>
-        public static void Is<T>(IEnumerable<Type> itemsToVerify) where T : ConventionData<Type>, new()
-        {
-            Is(new T(), itemsToVerify);
-        }
-        public static void Is<T>(IEnumerable<Type> itemsToVerify, Func<string, bool> filter) where T : ConventionData<Type>, IRuntimeFilter<string>, new()
-        {
-            Is(new T(), itemsToVerify, filter);
-        }
-        public static void Is<T, TItem>(IEnumerable<Type> itemsToVerify, Func<TItem, bool> filter) where T : ConventionData<Type>, IRuntimeFilter<TItem>, new()
-        {
-            Is(new T(), itemsToVerify, filter);
-        }
-
-        //Item.Is<ConventionData<Assembly>>
-        public static void Is<T>(IEnumerable<Assembly> itemsToVerify) where T : ConventionData<Assembly>, new()
-        {
-            Is(new T(), itemsToVerify);
-        }
-        public static void Is<T>(IEnumerable<Assembly> itemsToVerify, Func<string, bool> filter) where T : ConventionData<Assembly>, IRuntimeFilter<string>, new()
-        {
-            Is(new T(), itemsToVerify, filter);
-        }
-        public static void Is<T, TItem>(IEnumerable<Assembly> itemsToVerify, Func<TItem, bool> filter) where T : ConventionData<Assembly>, IRuntimeFilter<TItem>, new()
-        {
-            Is(new T(), itemsToVerify, filter);
-        }
 
         public static void Is<T>(ConventionData<T> convention, IEnumerable<T> itemsToVerify)
         {

TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs

@@ -3,66 +3,33 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
-    using System.Reflection;
     using System.Xml.Linq;
-    using TestStack.ConventionTests.Helpers;
+    using TestStack.ConventionTests.Internal;
 
-    public class FilesAreEmbeddedResources : ConventionData<Assembly>, IRuntimeFilter<string>
+    public class FilesAreEmbeddedResources : IConvention<Project>
     {
-        readonly IProjectLocator projectLocator;
-        readonly IProjectProvider projectProvider;
-        Func<string, bool> itemFilter;
-
-        public FilesAreEmbeddedResources() : this(new AssemblyProjectLocator(), new ProjectProvider()) { }
-        public FilesAreEmbeddedResources(IProjectLocator projectLocator, IProjectProvider projectProvider)
+        public ConventionResult Execute(Project data)
         {
-            this.projectLocator = projectLocator;
-            this.projectProvider = projectProvider;
-
-            Must = assembly =>
-            {
-                var references = GetProjectFiles(assembly);
-
-                return references.All(s => s.Item1 == "EmbeddedResource");
-            };
-            ItemDescription = (assembly, builder) =>
-            {
-                var filesNotEmbedded = GetProjectFiles(assembly)
-                    .Where(r => r.Item1 != "EmbeddedResource");
-
-
-                builder.AppendLine(string.Format("{0} has the following files which should be embedded resources:",
-                    assembly.GetName().Name));
-                foreach (var error in filesNotEmbedded.Select(m => m.Item2 + " which currently has a build action of '" + m.Item1 + "'"))
-                {
-                    builder.Append('\t');
-                    builder.AppendLine(error);
-                }
-            };
+            return ConventionResult.For(GetProjectFiles(data).Where(s => s.Item1 != "EmbeddedResource"),
+                "The following files which should be embedded resources:",
+                (t, m) => m.AppendLine("\t" + t.Item2));
         }
 
-        IEnumerable<Tuple<string, string>> GetProjectFiles(Assembly assembly)
+        IEnumerable<Tuple<string, string>> GetProjectFiles(Project project)
         {
-            //TODO Not sure about filters, we can interate on this...
-            if (itemFilter == null)
-                throw new InvalidOperationException("This convention requires you to provide a filter, which is an overload on Convention.Is");
-
+            if (project.Includes == null)
+                throw new InvalidOperationException(
+                    "This convention requires you to provide a filter on the convention data");
             const string msbuild = "http://schemas.microsoft.com/developer/msbuild/2003";
-            var resolveProjectFilePath = projectLocator.ResolveProjectFilePath(assembly);
-            XDocument projDefinition = projectProvider.LoadProjectDocument(resolveProjectFilePath);
+            var projDefinition = project.GetProject();
             var references = projDefinition
                 .Element(XName.Get("Project", msbuild))
                 .Elements(XName.Get("ItemGroup", msbuild))
                 .Elements()
                 .Select(refElem => Tuple.Create(refElem.Name.LocalName, refElem.Attribute("Include").Value))
-                .Where(i => itemFilter(i.Item2));
+                .Where(i => project.Includes(i.Item2));
 
             return references;
         }
-
-        public void SetFilter(Func<string, bool> filter)
-        {
-            itemFilter = filter;
-        }
     }
 }

TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs

@@ -2,51 +2,30 @@
 {
     using System.Collections.Generic;
     using System.Linq;
-    using System.Reflection;
     using System.Text.RegularExpressions;
     using System.Xml.Linq;
-    using TestStack.ConventionTests.Helpers;
+    using TestStack.ConventionTests.Internal;
 
-    public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : ConventionData<Assembly>
+    public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<Project>
     {
         const string AssemblyReferencingObjRegex = @"^(?<assembly>.*?(obj|bin).*?)$";
 
-        public ProjectDoesNotReferenceDllsFromBinOrObjDirectories()
-            : this(new AssemblyProjectLocator(), new ProjectProvider())
+        public ConventionResult Execute(Project data)
         {
+            var invalid = AllProjectReferences(data.GetProject()).Where(IsBinOrObjReference);
+            return ConventionResult.For(invalid, "Some invalid references found.", (r, m) => m.AppendLine("\t" + r));
         }
 
-        public ProjectDoesNotReferenceDllsFromBinOrObjDirectories(IProjectLocator projectLocator, IProjectProvider projectProvider)
-        {
-            Must = assembly =>
-            {
-                var references = GetProjectReferences(projectLocator, projectProvider, assembly);
-
-                return references.All(s => !Regex.IsMatch(s, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase));
-            };
-            ItemDescription = (assembly, builder) =>
-            {
-                var matches = GetProjectReferences(projectLocator, projectProvider, assembly)
-                    .Select(r => Regex.Match(r, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase))
-                    .Where(r => r.Success);
 
-                builder.AppendLine(string.Format("{0} is referencing assemblies in the bin or obj folders:",
-                    assembly.GetName().Name));
-                foreach (var match in matches.Select(m=>m.Groups["assembly"].Value))
-                {
-                    builder.Append('\t');
-                    builder.AppendLine(match);
-                }
-            };
+        static bool IsBinOrObjReference(string reference)
+        {
+            return Regex.IsMatch(reference, AssemblyReferencingObjRegex, RegexOptions.IgnoreCase);
         }
 
-        static IEnumerable<string> GetProjectReferences(IProjectLocator projectLocator, IProjectProvider projectProvider,
-            Assembly assembly)
+        static IEnumerable<string> AllProjectReferences(XDocument projDefinition)
         {
             XNamespace msbuild = "http://schemas.microsoft.com/developer/msbuild/2003";
-            var resolveProjectFilePath = projectLocator.ResolveProjectFilePath(assembly);
-            XDocument projDefinition = projectProvider.LoadProjectDocument(resolveProjectFilePath);
-            IEnumerable<string> references = projDefinition
+            var references = projDefinition
                 .Element(msbuild + "Project")
                 .Elements(msbuild + "ItemGroup")
                 .Elements(msbuild + "Reference")

TestStack.ConventionTests/Project.cs

@@ -0,0 +1,37 @@
+namespace TestStack.ConventionTests
+{
+    using System;
+    using System.Reflection;
+    using System.Xml.Linq;
+    using TestStack.ConventionTests.Helpers;
+
+    public class Project : IConventionData
+    {
+        readonly Assembly assembly;
+        readonly IProjectLocator projectLocator;
+        readonly IProjectProvider projectProvider;
+
+        public Project(Assembly assembly, IProjectProvider projectProvider, IProjectLocator projectLocator)
+        {
+            this.assembly = assembly;
+            this.projectProvider = projectProvider;
+            this.projectLocator = projectLocator;
+        }
+
+        public bool HasValidSource
+        {
+            get { return projectLocator.ResolveProjectFilePath(assembly) != null; }
+        }
+
+        public bool HasApprovedExceptions { get; set; }
+
+        public XDocument GetProject()
+        {
+            var location = projectLocator.ResolveProjectFilePath(assembly);
+            var project = projectProvider.LoadProjectDocument(location);
+            return project;
+        }
+
+        public Func<string, bool> Includes;
+    }
+}

TestStack.ConventionTests/TestStack.ConventionTests.csproj

@@ -68,6 +68,7 @@
     <Compile Include="Helpers\AssemblyProjectLocator.cs" />
     <Compile Include="Convention.cs" />
     <Compile Include="IConvention.cs" />
+    <Compile Include="Project.cs" />
     <Compile Include="Types.cs" />
     <Compile Include="ConventionData`1.cs" />
     <Compile Include="Helpers\IProjectLocator.cs" />