BenMorris/NetArchTest#133 - add rules: AreInheritedByAnyType, AreNotInheritedByAnyType

Author: NeVeSpl

src/NetArchTest.Rules/Functions/FunctionDelegates.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using Mono.Cecil;
 using NetArchTest.Assemblies;
+using NetArchTest.RuleEngine;
 using NetArchTest.Rules;
 
 namespace NetArchTest.Functions
@@ -48,7 +49,20 @@ internal static IEnumerable<TypeSpec> Inherit(IEnumerable<TypeSpec> input, Type
                 return input.Where(c => !c.Definition.IsSubclassOf(target));
             }
         }
-        
+
+        internal static IEnumerable<TypeSpec> BeInherited(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
+        {
+            var InheritedTypes = new HashSet<string>(context.AllTypes.Select(x => x.Definition.BaseType?.FullName).Where(x => x is not null));
+            if (condition)
+            {
+                return input.Where(c => InheritedTypes.Contains(c.Definition.FullName));
+            }
+            else
+            {
+                return input.Where(c => !InheritedTypes.Contains(c.Definition.FullName));
+            }
+        }
+
         internal static IEnumerable<TypeSpec> ImplementInterface(IEnumerable<TypeSpec> input, Type typeInterface, bool condition)
         {
             if (!typeInterface.IsInterface)

src/NetArchTest.Rules/Predicate.cs

@@ -133,6 +133,27 @@ public PredicateList Inherit<T>()
             return Inherit(typeof(T));
         }
 
+        /// <summary>
+        /// Selects types that are inherited by any type
+        /// </summary>        
+        /// <returns>An updated set of predicates that can be applied to a list of types.</returns>
+        public PredicateList AreInheritedByAnyType()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.BeInherited(context, inputTypes, true));
+            return CreatePredicateList();
+        }
+
+        /// <summary>
+        /// Selects types that are not inherited by any type
+        /// </summary>        
+        /// <returns>An updated set of predicates that can be applied to a list of types.</returns>
+        public PredicateList AreNotInheritedByAnyType()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.BeInherited(context, inputTypes, false));
+            return CreatePredicateList();
+        }
+
+
         /// <summary>
         /// Selects types that do not inherit a particular type.
         /// </summary>

test/NetArchTest.Rules.UnitTests/PredicateTests.cs

@@ -123,6 +123,38 @@ public void DoNotInherit()
             Assert.Contains<Type>(typeof(NotDerivedClass), result);
         }
 
+
+        [Fact(DisplayName = "AreInheritedByAnyType")]
+        public void AreInheritedByAnyType()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Inheritance")
+                .And()
+                .AreInheritedByAnyType().GetReflectionTypes();
+
+            Assert.Equal(2, result.Count());
+            Assert.Contains<Type>(typeof(BaseClass), result);
+            Assert.Contains<Type>(typeof(DerivedClass), result);
+        }
+
+        [Fact(DisplayName = "AreNotInheritedByAnyType")]
+        public void AreNotInheritedByAnyType()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Inheritance")
+                .And()
+                .AreNotInheritedByAnyType().GetReflectionTypes();
+
+            Assert.Equal(2, result.Count());
+            Assert.Contains<Type>(typeof(DerivedDerivedClass), result);
+            Assert.Contains<Type>(typeof(NotDerivedClass), result);
+        }
+
+
         [Fact(DisplayName = "ImplementInterface")]
         public void ImplementInterface()
         {