BenMorris/NetArchTest#104 - add rule: HaveMatchingTypeWithName

Author: NeVeSpl

src/NetArchTest.Rules/Condition_Special.cs

@@ -1,4 +1,6 @@
-using NetArchTest.Functions;
+using System;
+using Mono.Cecil;
+using NetArchTest.Functions;
 
 namespace NetArchTest.Rules
 {
@@ -77,7 +79,7 @@ public ConditionList OnlyHaveNonNullableMembers()
 
 
         /// <summary>
-        /// Check if the name of a type is consistent with its source file name
+        /// For each type, check if the name is consistent with its source file name.
         /// </summary>
         /// <remarks>
         /// StringComparison.InvariantCultureIgnoreCase is used for comparing, can be changed through Options
@@ -90,7 +92,7 @@ public ConditionList HaveSourceFileNameMatchingName()
         }
 
         /// <summary>
-        /// Check if the namespace of a type is consistent with its source file path
+        /// For each type, check if the namespace is consistent with its source file path.
         /// </summary>
         /// <remarks>
         /// StringComparison.InvariantCultureIgnoreCase is used for comparing, can be changed through Options
@@ -101,5 +103,15 @@ public ConditionList HaveSourceFilePathMatchingNamespace()
             AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveFilePathMatchingTypeNamespace(context, inputTypes, true));
             return CreateConditionList();
         }
+               
+        /// <summary>
+        /// For each type, check if a matching type with the given name exists.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList HaveMatchingTypeWithName(Func<TypeDefinition, string> getMatchingTypeName)
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveMatchingTypeWithName(context, inputTypes, getMatchingTypeName, true));
+            return CreateConditionList();
+        }
     }
 }

src/NetArchTest.Rules/Functions/FunctionDelegates_Special.cs

@@ -112,5 +112,18 @@ static bool IsMatching(string sourceFilePath, string @namespace, StringCompariso
                 return pathAsNamespace.EndsWith(@namespace, comparer);
             }
         }
+
+        internal static IEnumerable<TypeSpec> HaveMatchingTypeWithName(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, Func<TypeDefinition, string> getMatchingTypeName, bool condition)
+        {
+            var exisitingTypes = new HashSet<string>(context.AllTypes.Select(x => x.Definition.GetName()));
+            if (condition)
+            {
+                return input.Where(c => exisitingTypes.Contains(getMatchingTypeName(c.Definition)));
+            }
+            else
+            {
+                return input.Where(c => !exisitingTypes.Contains(getMatchingTypeName(c.Definition)));
+            }
+        }
     }
 }

src/NetArchTest.Rules/RuleEngine/FunctionSequence.cs

@@ -29,20 +29,20 @@ public void CreateGroup()
         }
 
 
-        public IEnumerable<TypeSpec> ExecuteToGetFailingTypes(IEnumerable<TypeSpec> inputTypes, bool selected, Options options)
+        public IEnumerable<TypeSpec> ExecuteToGetFailingTypes(IEnumerable<TypeSpec> inputTypes, bool selected, Options options, IEnumerable<TypeSpec> allTypes)
         {
-            return Execute(inputTypes, selected, true, options);
+            return Execute(inputTypes, selected, true, options, allTypes);
         }
-        public IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes, Options options)
+        public IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes, Options options, IEnumerable<TypeSpec> allTypes)
         {
-            return Execute(inputTypes, true, false, options);
+            return Execute(inputTypes, true, false, options, allTypes);
         }
 
-        private IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes, bool selected, bool isFailPathRun, Options options)
+        private IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes, bool selected, bool isFailPathRun, Options options, IEnumerable<TypeSpec> allTypes)
         {
             if (isEmpty) return inputTypes;
 
-            var context = new FunctionSequenceExecutionContext(isFailPathRun, options);
+            var context = new FunctionSequenceExecutionContext(allTypes, isFailPathRun, options);
             MarkPassingTypes(context, inputTypes);
 
             return inputTypes.Where(x => x.IsSelectedInMarkPhase == selected).ToArray();

src/NetArchTest.Rules/RuleEngine/FunctionSequenceExecutionContext.cs

@@ -1,16 +1,20 @@
-using NetArchTest.Rules;
+using System.Collections.Generic;
+using NetArchTest.Assemblies;
+using NetArchTest.Rules;
 
 namespace NetArchTest.RuleEngine
-{   
+{
     internal class FunctionSequenceExecutionContext
     {
+        public IEnumerable<TypeSpec> AllTypes { get; }
         public bool IsFailPathRun { get; }
         public IDependencyFilter DependencyFilter { get; }
         public Options UserOptions { get; }
 
 
-        public FunctionSequenceExecutionContext(bool isFailPathRun, Options options = null)
+        public FunctionSequenceExecutionContext(IEnumerable<TypeSpec> allTypes, bool isFailPathRun, Options options = null)
         {
+            AllTypes = allTypes;
             UserOptions = options ?? Options.Default; 
             IsFailPathRun = isFailPathRun;            
         }

src/NetArchTest.Rules/RuleEngine/RuleContext.cs

@@ -23,17 +23,17 @@ public RuleContext(IEnumerable<TypeSpec> inpuTypes)
         public IEnumerable<TypeSpec> Execute(Options options)
         {
             IEnumerable<TypeSpec> result = types;
-            result = PredicateContext.Sequence.Execute(result, options);
-            result = ConditionContext.Sequence.Execute(result, options); 
+            result = PredicateContext.Sequence.Execute(result, options, types);
+            result = ConditionContext.Sequence.Execute(result, options, types); 
             return result;
         }
 
         public TestResult GetResult(Options options)
         {
             bool success;
 
-            var filteredTypes = PredicateContext.Sequence.Execute(types, options);
-            var passingTypes = ConditionContext.Sequence.Execute(filteredTypes, options);
+            var filteredTypes = PredicateContext.Sequence.Execute(types, options, types);
+            var passingTypes = ConditionContext.Sequence.Execute(filteredTypes, options, types);
 
             if (ConditionContext.Should)
             {
@@ -52,7 +52,7 @@ public TestResult GetResult(Options options)
             }
 
             // If we've failed, get a collection of failing types so these can be reported in a failing test.
-            var failedTypes = ConditionContext.Sequence.ExecuteToGetFailingTypes(filteredTypes, selected: !ConditionContext.Should, options);
+            var failedTypes = ConditionContext.Sequence.ExecuteToGetFailingTypes(filteredTypes, selected: !ConditionContext.Should, options, types);
             return TestResult.Failure(failedTypes);
         }
 

test/NetArchTest.Rules.UnitTests/ConditionTests_Special.cs

@@ -2,6 +2,8 @@
 using System.Reflection;
 using NetArchTest.Rules;
 using NetArchTest.TestStructure.File;
+using NetArchTest.TestStructure.File.Correct;
+using NetArchTest.TestStructure.File.Incorrect.Yabadabado;
 using NetArchTest.TestStructure.NameMatching.Namespace1;
 using NetArchTest.TestStructure.Stateless;
 using Xunit;
@@ -186,5 +188,31 @@ public void HaveSourceFilePathMatchingTypeNamespace_ShouldNot()
 
             Assert.True(result.IsSuccessful);
         }
+
+        [Fact(DisplayName = "HaveMatchingTypeWithName_Should")]
+        public void HaveMatchingTypeWithName_Should()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()
+                .AreOfType(typeof(CorrectSourceFileNameType))
+                .Should()
+                .HaveMatchingTypeWithName(x => x.Name + "Tests").GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "HaveMatchingTypeWithName_ShouldNot")]
+        public void HaveMatchingTypeWithName_ShouldNot()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()               
+                .AreNotOfType(typeof(CorrectSourceFileNameType))
+                .ShouldNot()
+                .HaveMatchingTypeWithName(x => x.Name + "Tests").GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
     }
 }

test/NetArchTest.TestStructure/File/Tests/CorrectSourceFileNameTypeTests.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.TestStructure.File.Tests
+{
+    internal class CorrectSourceFileNameTypeTests
+    {
+    }
+}