BenMorris/NetArchTest#105 - Highlighting "why" a type fails test

Author: NeVeSpl

README.md

@@ -1,14 +1,22 @@
-# NetArchTest.eNhancedEdition
+[![Nuget](https://img.shields.io/nuget/v/NetArchTest.eNhancedEdition?color=%23004880&label=NetArchTest.eNhancedEdition%20nuget)](https://www.nuget.org/packages/NetArchTest.eNhancedEdition)
+
+# NetArchTest.eNhancedEdition
 
 A fluent API for .Net Standard that can enforce architectural rules in unit tests and create a *self-testing architecture*. Inspired by the [ArchUnit](https://www.archunit.org/) library for Java.
 
 NetArchTest.eNhancedEdition is based on [NetArchTest v1.3.2](https://github.com/BenMorris/NetArchTest). If you are not familiar with NetArchTest, you should start by reading [introduction on Ben's blog](https://www.ben-morris.com/writing-archunit-style-tests-for-net-and-c-for-self-testing-architectures).
 
 ### Rationale
 
-NetArchTest is well established mature library, but in order to push things forward, a few breaking changes had to be made, and that is how  **eNhancedEdition** was born. eNhancedEdition uses almost identical Fluent API as a base library, but it is not 100% backward compatible, and it will never be. The main goal is to offer more, and not to be only a replacement.
+NetArchTest is well established mature library, but in order to push things forward, a few breaking changes had to be made, and that is how  **eNhancedEdition** was born. eNhancedEdition uses almost identical Fluent API as a base library, but it is not 100% backward compatible, and it will never be. 
+
+What **eNhancedEdition** has to offer:
+ - [Slices](#slices)
+ - solved BenMorris/NetArchTest#105 - dependency search functions: HaveDependencyOnAny/OnlyHaveDependencyOn explain why a type fails test  
+
+
 
-### Index
+## Index
 
 * [Getting started](#getting-started)
     * [Examples](#examples)

src/NetArchTest.Rules/Assemblies/TypeSpec.cs

@@ -6,7 +6,11 @@ internal sealed class TypeSpec
     {
         public TypeDefinition Definition { get; }
         public string FullName => Definition.FullName;
+        // Only for use by FunctionSequence
         internal bool IsSelected { get; set;  }
+        // Can be use by any function
+        internal bool IsPassing { get; set; }
+        public string Explanation { get; set; }
 
 
         public TypeSpec(TypeDefinition definition)
@@ -18,7 +22,7 @@ public TypeSpec(TypeDefinition definition)
 
         public TypeWrapper CreateWrapper()
         {
-            return new TypeWrapper(Definition);
+            return new TypeWrapper(Definition, Explanation);
         }
     }
 }

src/NetArchTest.Rules/Assemblies/TypeWrapper.cs

@@ -13,7 +13,7 @@ internal sealed class TypeWrapper : IType
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private readonly Lazy<Type> _type;
 
-        internal TypeWrapper(TypeDefinition monoTypeDefinition)
+        internal TypeWrapper(TypeDefinition monoTypeDefinition, string explanation)
         {
             _monoTypeDefinition = monoTypeDefinition;
             _type = new Lazy<Type>(() =>
@@ -26,12 +26,14 @@ internal TypeWrapper(TypeDefinition monoTypeDefinition)
                 catch { }
                 return type;
             });
+            Explanation = explanation;
         }
 
 
         public Type ReflectionType => _type.Value;  
         public string FullName => _monoTypeDefinition.FullName;     
         public string Name => _monoTypeDefinition.Name;
+        public string Explanation { get; }
 
 
         public static implicit operator System.Type(TypeWrapper type)

src/NetArchTest.Rules/Condition.Dependencies.cs

@@ -11,7 +11,7 @@ public sealed partial class Condition
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList HaveDependencyOnAny(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.HaveDependencyOnAny(x, dependencies, true));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveDependencyOnAny(context, inputTypes, dependencies, true));
             return new ConditionList(_types, _should, _sequence);
         }
 
@@ -22,7 +22,7 @@ public ConditionList HaveDependencyOnAny(params string[] dependencies)
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList HaveDependencyOnAll(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.HaveDependencyOnAll(x, dependencies, true));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveDependencyOnAll(context, inputTypes, dependencies, true));
             return new ConditionList(_types, _should, _sequence);
         }
 
@@ -33,7 +33,7 @@ public ConditionList HaveDependencyOnAll(params string[] dependencies)
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList OnlyHaveDependencyOn(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.OnlyHaveDependenciesOnAnyOrNone(x, dependencies, true));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.OnlyHaveDependenciesOnAnyOrNone(context, inputTypes, dependencies, true));
             return new ConditionList(_types, _should, _sequence);
         }
 
@@ -44,7 +44,7 @@ public ConditionList OnlyHaveDependencyOn(params string[] dependencies)
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList NotHaveDependencyOnAny(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.HaveDependencyOnAny(x, dependencies, false));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveDependencyOnAny(context, inputTypes, dependencies, false));
             return new ConditionList(_types, _should, _sequence);
         }
 
@@ -55,7 +55,7 @@ public ConditionList NotHaveDependencyOnAny(params string[] dependencies)
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList NotHaveDependencyOnAll(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.HaveDependencyOnAll(x, dependencies, false));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveDependencyOnAll(context, inputTypes, dependencies, false));
             return new ConditionList(_types, _should, _sequence);
         }
 
@@ -66,7 +66,7 @@ public ConditionList NotHaveDependencyOnAll(params string[] dependencies)
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList HaveDependencyOtherThan(params string[] dependencies)
         {
-            _sequence.AddFunctionCall(x => FunctionDelegates.OnlyHaveDependenciesOnAnyOrNone(x, dependencies, false));
+            _sequence.AddFunctionCall((context, inputTypes) => FunctionDelegates.OnlyHaveDependenciesOnAnyOrNone(context, inputTypes, dependencies, false));
             return new ConditionList(_types, _should, _sequence);
         }
     }

src/NetArchTest.Rules/ConditionList.cs

@@ -53,7 +53,7 @@ public TestResult GetResult()
             }
 
             // If we've failed, get a collection of failing types so these can be reported in a failing test.
-            var failedTypes = _sequence.ExecuteExtended(_types, selected: !_should);
+            var failedTypes = _sequence.ExecuteToGetFailingTypes(_types, selected: !_should);
             return TestResult.Failure(failedTypes);
         }
 

src/NetArchTest.Rules/Dependencies/DependencySearch.cs

@@ -9,76 +9,64 @@ namespace NetArchTest.Dependencies
     /// </summary>
     internal class DependencySearch
     {
+        private readonly bool explainYourself;
+
+        public DependencySearch(bool explainYourself)
+        {
+            this.explainYourself = explainYourself;
+        }
+
         /// <summary>
         /// Finds types that have a dependency on any item in the given list of dependencies.
         /// </summary>
-        /// <param name="input">The set of type definitions to search.</param>
-        /// <param name="dependencies">The set of dependencies to look for.</param>
-        /// <returns>A list of found types.</returns>
         public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.HaveDependencyOnAny, dependencies, true);           
         }
 
         /// <summary>
         /// Finds types that have a dependency on every item in the given list of dependencies.
-        /// </summary>
-        /// <param name="input">The set of type definitions to search.</param>
-        /// <param name="dependencies">The set of dependencies to look for.</param>
-        /// <returns>A list of found types.</returns>
+        /// </summary>      
         public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.HaveDependencyOnAll, dependencies, true);         
         }
 
         /// <summary>
         /// Finds types that may have a dependency on any item in the given list of dependencies, but cannot have a dependency that is not in the list.
-        /// </summary>
-        /// <param name="input">The set of type definitions to search.</param>
-        /// <param name="dependencies">The set of dependencies to look for.</param>
-        /// <returns>A list of found types.</returns>
-        public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependenciesOnAnyOrNone(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
+        /// </summary>             
+        public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAnyOrNone(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {           
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAnyOrNone, dependencies, false);
         }
 
         /// <summary>
         /// Finds types that have a dependency on any item in the given list of dependencies, but cannot have a dependency that is not in the list.
-        /// </summary>
-        /// <param name="input">The set of type definitions to search.</param>
-        /// <param name="dependencies">The set of dependencies to look for.</param>
-        /// <returns>A list of found types.</returns>
-        public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependenciesOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
+        /// </summary>      
+        public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAny, dependencies, false);
         }
 
         /// <summary>
         /// Finds types that have a dependency on every item in the given list of dependencies, but cannot have a dependency that is not in the list.
         /// </summary>
-        /// <param name="input">The set of type definitions to search.</param>
-        /// <param name="dependencies">The set of dependencies to look for.</param>
-        /// <returns>A list of found types.</returns>
-        public IEnumerable<TypeSpec> FindTypesThatOnlyOnlyHaveDependenciesOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
+        public IEnumerable<TypeSpec> FindTypesThatOnlyOnlyHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAll, dependencies, false);
         }
 
         private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, TypeDefinitionCheckingResult.SearchType searchType, IEnumerable<string> dependencies, bool serachForDependencyInFieldConstant)
-        {
-            var output = new List<TypeSpec>();
-            var searchTree = new CachedNamespaceTree(dependencies);
+        {           
+            var searchTree = new CachedNamespaceTree(dependencies);           
 
             foreach (var type in input)
             {
-                var context = new TypeDefinitionCheckingContext(type, searchType, searchTree, serachForDependencyInFieldConstant);
-                if (context.IsTypeFound())
-                {
-                    output.Add(type);
-                }
+                var context = new TypeDefinitionCheckingContext(type, searchType, searchTree, serachForDependencyInFieldConstant, explainYourself);               
+                type.IsPassing = context.IsTypeFound();                
             }
 
-            return output;
+            return input;
         }       
     }
 }

src/NetArchTest.Rules/Dependencies/TypeDefinitionCheckingContext.cs

@@ -6,20 +6,26 @@ namespace NetArchTest.Dependencies
 {
     internal class TypeDefinitionCheckingContext
     {
-        private readonly TypeDefinition _typeToCheck;
+        private readonly TypeSpec _typeToCheck;
         private readonly TypeDefinitionCheckingResult _result;        
         private readonly bool _serachForDependencyInFieldConstant;
+        private readonly bool explainYourself;
 
-        public TypeDefinitionCheckingContext(TypeSpec typeToCheck, TypeDefinitionCheckingResult.SearchType searchType, ISearchTree searchTree, bool serachForDependencyInFieldConstant = false)
+        public TypeDefinitionCheckingContext(TypeSpec typeToCheck, TypeDefinitionCheckingResult.SearchType searchType, ISearchTree searchTree, bool serachForDependencyInFieldConstant = false, bool explainYourself = false)
         {
-            _typeToCheck = typeToCheck.Definition;
+            _typeToCheck = typeToCheck;
             _result = new TypeDefinitionCheckingResult(searchType, searchTree);
             _serachForDependencyInFieldConstant = serachForDependencyInFieldConstant;
+            this.explainYourself = explainYourself;
         }
 
         public bool IsTypeFound()
         {
-            CheckType(_typeToCheck);
+            CheckType(_typeToCheck.Definition);
+            if (explainYourself)
+            {
+                _typeToCheck.Explanation = _result.ExplainWhy();
+            }
             return _result.IsTypeFound();
         }
 
@@ -224,13 +230,13 @@ private void CheckMethodBodyInstructions(MethodDefinition methodToCheck)
                             }
                             break;
                         case FieldReference fieldReference:
-                            if (fieldReference.DeclaringType != _typeToCheck)
+                            if (fieldReference.DeclaringType != _typeToCheck.Definition)
                             {
                                 CheckTypeReference(fieldReference.DeclaringType);
                             }
                             break;
                         case MethodReference methodReference:
-                            if (methodReference.DeclaringType != _typeToCheck)
+                            if (methodReference.DeclaringType != _typeToCheck.Definition)
                             {
                                 CheckTypeReference(methodReference.DeclaringType);
                             }
@@ -276,7 +282,7 @@ private void CheckTypeReference(TypeReference reference)
         }
         private void CheckDependency(TypeReference dependency)
         {
-            _result.CheckDependency(dependency);
+            _result.CheckDependency(dependency);           
         }
     }
 }

src/NetArchTest.Rules/Dependencies/TypeDefinitionCheckingResult.cs

@@ -7,9 +7,6 @@
 
 namespace NetArchTest.Dependencies
 {
-    /// <summary>
-    /// Manages the results of dependency search.
-    /// </summary>
     internal class TypeDefinitionCheckingResult
     {
         public enum SearchType 
@@ -26,7 +23,9 @@ public enum SearchType
         /// <summary> The list of dependencies that have been found in the search.</summary>
         private HashSet<string> _foundDependencies = new HashSet<string>();
         private bool _hasDependencyFromOutsideOfSearchTree;
-       
+
+        TypeReference lastFoundDependency = null;
+        TypeReference lastFoundDependencyOutsideOfSearchTree = null;
 
         public TypeDefinitionCheckingResult(SearchType searchType, ISearchTree searchTree)
         {
@@ -54,6 +53,42 @@ public bool IsTypeFound()
                     throw new NotImplementedException();
             }
         }
+        public string ExplainWhy()
+        {
+            var isTypeFound = IsTypeFound();
+            switch (_searchType)
+            {
+                case SearchType.HaveDependencyOnAll:
+                    if (isTypeFound)
+                    {
+                        return "Has dependency on all provided inputs";
+                    }
+                    else
+                    {
+                        return string.Empty;
+                    }                    
+                case SearchType.HaveDependencyOnAny:
+                    if (isTypeFound)
+                    {
+                        return $"Has dependency on: {lastFoundDependency}";
+                    }
+                    else
+                    {
+                        return "Does not have a dependency on any provided inputs";
+                    }                    
+                case SearchType.OnlyHaveDependenciesOnAnyOrNone:
+                    if (isTypeFound)
+                    {
+                        return "Does not have a dependency outside of provided inputs";
+                    }
+                    else
+                    {
+                        return $"Has dependency on: {lastFoundDependencyOutsideOfSearchTree}";
+                    }
+                    break;
+            }
+            throw new NotImplementedException();
+        }
 
         /// <summary>
         /// If we already know the final answer to the question if type was found,
@@ -96,6 +131,7 @@ public void CheckDependency(TypeReference dependency)
                 {
                     _foundDependencies.Add(match);
                 }
+                lastFoundDependency = dependency;
             } 
             else
             {
@@ -109,6 +145,7 @@ public void CheckDependency(TypeReference dependency)
                     if (!isGlobalAnonymousCompilerGeneratedType)
                     {
                         _hasDependencyFromOutsideOfSearchTree = true;
+                        lastFoundDependencyOutsideOfSearchTree = dependency;
                     }
                 }
             }