BenMorris/NetArchTest#147 - add user option: SerachForDependencyInFieldConstant = false

NeVeSpl · NeVeSpl · commit 6d7cfe5580ec · 2024-10-06T14:24:21.000+02:00
diff --git a/sources/NetArchTest/Dependencies/DependencySearch.cs b/sources/NetArchTest/Dependencies/DependencySearch.cs
@@ -14,12 +14,14 @@ internal class DependencySearch
     {
         private readonly bool explainYourself;
         private readonly IDependencyFilter dependencyFilter;
+        private readonly bool serachForDependencyInFieldConstant;
 
 
-        public DependencySearch(bool explainYourself, IDependencyFilter dependencyFilter = null)
+        public DependencySearch(bool explainYourself, bool serachForDependencyInFieldConstant = false, IDependencyFilter dependencyFilter = null)
         {
             this.explainYourself = explainYourself;
             this.dependencyFilter = dependencyFilter;
+            this.serachForDependencyInFieldConstant = serachForDependencyInFieldConstant;
         }
 
 
@@ -28,42 +30,42 @@ public DependencySearch(bool explainYourself, IDependencyFilter dependencyFilter
         /// </summary>
         public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
-            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAny, dependencies, true);           
+            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAny, dependencies);           
         }
 
         /// <summary>
         /// Finds types that have a dependency on every item in the given list of dependencies.
         /// </summary>      
         public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
-            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAll, dependencies, true);         
+            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAll, dependencies);         
         }
 
         /// <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>             
         public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAnyOrNone(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {           
-            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAnyOrNone, dependencies, false);
+            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAnyOrNone, dependencies);
         }
 
         /// <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>      
         public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
-            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAny, dependencies, false);
+            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAny, dependencies);
         }
 
         /// <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>
         public IEnumerable<TypeSpec> FindTypesThatOnlyOnlyHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
-            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAll, dependencies, false);
+            return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAll, dependencies);
         }
 
-        private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDependency_CheckingStrategy.TypeOfCheck typeOfCheck, IEnumerable<string> dependencies, bool serachForDependencyInFieldConstant)
+        private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDependency_CheckingStrategy.TypeOfCheck typeOfCheck, IEnumerable<string> dependencies)
         {           
             var searchTree = new CachedNamespaceTree(dependencies);
             var context = new TypeCheckingContext(serachForDependencyInFieldConstant, explainYourself, dependencyFilter);
@@ -82,7 +84,7 @@ private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDepende
         public IEnumerable<TypeSpec> FindTypesThatAreUsedByAny(IEnumerable<TypeSpec> input, IEnumerable<string> users, IEnumerable<TypeSpec> allTypes)
         {
             var filterTree = new CachedNamespaceTree(users);
-            var context = new TypeCheckingContext(false, explainYourself, dependencyFilter);
+            var context = new TypeCheckingContext(serachForDependencyInFieldConstant, explainYourself, dependencyFilter);
             var strategy = new AreUsedBy_CheckingStrategy();
 
 
diff --git a/sources/NetArchTest/Functions/FunctionDelegates_Dependencies.cs b/sources/NetArchTest/Functions/FunctionDelegates_Dependencies.cs
@@ -12,7 +12,7 @@ internal static partial class FunctionDelegates
         internal static IEnumerable<TypeSpec> HaveDependencyOnAny(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)
         {
             // Get the types that contain the dependencies
-            var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);
+            var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);
             var results = search.FindTypesThatHaveDependencyOnAny(input, dependencies);
             return input.Where(t => t.IsPassing == condition);
         }
@@ -21,7 +21,7 @@ internal static IEnumerable<TypeSpec> HaveDependencyOnAny(FunctionSequenceExecut
         internal static IEnumerable<TypeSpec> HaveDependencyOnAll(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)
         {
             // Get the types that contain the dependencies
-            var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);
+            var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);
             var results = search.FindTypesThatHaveDependencyOnAll(input, dependencies);
 
             return input.Where(t => t.IsPassing == condition);
@@ -30,7 +30,7 @@ internal static IEnumerable<TypeSpec> HaveDependencyOnAll(FunctionSequenceExecut
         /// <summary> Function for finding types that have a dependency on type other than one of the supplied types.</summary>
         internal static IEnumerable<TypeSpec> OnlyHaveDependenciesOnAnyOrNone(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)
         {
-            var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);
+            var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);
             var results = search.FindTypesThatOnlyHaveDependencyOnAnyOrNone(input, dependencies);
 
             return input.Where(t => t.IsPassing == condition);
@@ -40,7 +40,7 @@ internal static IEnumerable<TypeSpec> OnlyHaveDependenciesOnAnyOrNone(FunctionSe
 
         internal static IEnumerable<TypeSpec> AreUsedByAny(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)
         {
-            var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);
+            var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);
             var results = search.FindTypesThatAreUsedByAny(input, dependencies, context.AllTypes);
             return input.Where(t => t.IsPassing == condition);
         }
diff --git a/sources/NetArchTest/Options.cs b/sources/NetArchTest/Options.cs
@@ -10,7 +10,15 @@ public record class Options
         public static readonly Options Default = new Options();
 
 
+        /// <summary>
+        /// Allows to specify how strings will be compared, default: InvariantCultureIgnoreCase
+        /// </summary>
         public StringComparison Comparer { get; init; } = StringComparison.InvariantCultureIgnoreCase;
 
+
+        /// <summary>
+        /// Determines if dependency analysis should look for dependency in string field constant, default: false
+        /// </summary>
+        public bool SerachForDependencyInFieldConstant { get; init; } = false;
     }
-}
+}
diff --git a/sources/NetArchTest/Slices/Model/Filters/HaveDependenciesBetweenSlices.cs b/sources/NetArchTest/Slices/Model/Filters/HaveDependenciesBetweenSlices.cs
@@ -9,7 +9,7 @@ internal sealed class HaveDependenciesBetweenSlices : IFilter
     {
         public IEnumerable<TypeTestResult> Execute(SlicedTypes slicedTypes)
         {
-            var dependencySearch = new DependencySearch(false);
+            var dependencySearch = new DependencySearch(false, false);
             var result = new List<TypeTestResult>(slicedTypes.TypeCount);
 
             for (int i = 0; i < slicedTypes.Slices.Count; i++)
diff --git a/tests/NetArchTest.Rules.UnitTests/DependencySearch/Utils/DependencySearchUtils.cs b/tests/NetArchTest.Rules.UnitTests/DependencySearch/Utils/DependencySearchUtils.cs
@@ -63,7 +63,7 @@ public static IEnumerable<TypeSpec> GetTypesThatResideInTheSameNamespaceButWitho
         private static void FindTypesWithAnyDependencies(IEnumerable<TypeSpec> subjects, IEnumerable<string> dependencies, bool expectToFind)
         {
             // Arrange
-            var search = new global::NetArchTest.Dependencies.DependencySearch(false);
+            var search = new global::NetArchTest.Dependencies.DependencySearch(false, true);
 
             // Act
             // Search against the dependencies
diff --git a/tests/NetArchTest.Rules.UnitTests/NetArchTest.UnitTests.csproj b/tests/NetArchTest.Rules.UnitTests/NetArchTest.UnitTests.csproj
@@ -8,8 +8,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="xunit" Version="2.6.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.4">
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,14 @@ internal class DependencySearch`
`14`	`14`	`{`
`15`	`15`	`private readonly bool explainYourself;`
`16`	`16`	`private readonly IDependencyFilter dependencyFilter;`
	`17`	`+ private readonly bool serachForDependencyInFieldConstant;`
`17`	`18`
`18`	`19`
`19`		`- public DependencySearch(bool explainYourself, IDependencyFilter dependencyFilter = null)`
	`20`	`+ public DependencySearch(bool explainYourself, bool serachForDependencyInFieldConstant = false, IDependencyFilter dependencyFilter = null)`
`20`	`21`	`{`
`21`	`22`	`this.explainYourself = explainYourself;`
`22`	`23`	`this.dependencyFilter = dependencyFilter;`
	`24`	`+ this.serachForDependencyInFieldConstant = serachForDependencyInFieldConstant;`
`23`	`25`	`}`
`24`	`26`
`25`	`27`
`@@ -28,42 +30,42 @@ public DependencySearch(bool explainYourself, IDependencyFilter dependencyFilter`
`28`	`30`	`/// </summary>`
`29`	`31`	`public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)`
`30`	`32`	`{`
`31`		`- return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAny, dependencies, true);`
	`33`	`+ return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAny, dependencies);`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`/// <summary>`
`35`	`37`	`/// Finds types that have a dependency on every item in the given list of dependencies.`
`36`	`38`	`/// </summary>`
`37`	`39`	`public IEnumerable<TypeSpec> FindTypesThatHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)`
`38`	`40`	`{`
`39`		`- return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAll, dependencies, true);`
	`41`	`+ return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.HaveDependencyOnAll, dependencies);`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`/// <summary>`
`43`	`45`	`/// 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.`
`44`	`46`	`/// </summary>`
`45`	`47`	`public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAnyOrNone(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)`
`46`	`48`	`{`
`47`		`- return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAnyOrNone, dependencies, false);`
	`49`	`+ return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAnyOrNone, dependencies);`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`/// <summary>`
`51`	`53`	`/// 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.`
`52`	`54`	`/// </summary>`
`53`	`55`	`public IEnumerable<TypeSpec> FindTypesThatOnlyHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)`
`54`	`56`	`{`
`55`		`- return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAny, dependencies, false);`
	`57`	`+ return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAny, dependencies);`
`56`	`58`	`}`
`57`	`59`
`58`	`60`	`/// <summary>`
`59`	`61`	`/// 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.`
`60`	`62`	`/// </summary>`
`61`	`63`	`public IEnumerable<TypeSpec> FindTypesThatOnlyOnlyHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)`
`62`	`64`	`{`
`63`		`- return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAll, dependencies, false);`
	`65`	`+ return FindTypes(input, HaveDependency_CheckingStrategy.TypeOfCheck.OnlyHaveDependenciesOnAll, dependencies);`
`64`	`66`	`}`
`65`	`67`
`66`		`- private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDependency_CheckingStrategy.TypeOfCheck typeOfCheck, IEnumerable<string> dependencies, bool serachForDependencyInFieldConstant)`
	`68`	`+ private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDependency_CheckingStrategy.TypeOfCheck typeOfCheck, IEnumerable<string> dependencies)`
`67`	`69`	`{`
`68`	`70`	`var searchTree = new CachedNamespaceTree(dependencies);`
`69`	`71`	`var context = new TypeCheckingContext(serachForDependencyInFieldConstant, explainYourself, dependencyFilter);`
`@@ -82,7 +84,7 @@ private IEnumerable<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, HaveDepende`
`82`	`84`	`public IEnumerable<TypeSpec> FindTypesThatAreUsedByAny(IEnumerable<TypeSpec> input, IEnumerable<string> users, IEnumerable<TypeSpec> allTypes)`
`83`	`85`	`{`
`84`	`86`	`var filterTree = new CachedNamespaceTree(users);`
`85`		`- var context = new TypeCheckingContext(false, explainYourself, dependencyFilter);`
	`87`	`+ var context = new TypeCheckingContext(serachForDependencyInFieldConstant, explainYourself, dependencyFilter);`
`86`	`88`	`var strategy = new AreUsedBy_CheckingStrategy();`
`87`	`89`
`88`	`90`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal static partial class FunctionDelegates`
`12`	`12`	`internal static IEnumerable<TypeSpec> HaveDependencyOnAny(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)`
`13`	`13`	`{`
`14`	`14`	`// Get the types that contain the dependencies`
`15`		`- var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);`
	`15`	`+ var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);`
`16`	`16`	`var results = search.FindTypesThatHaveDependencyOnAny(input, dependencies);`
`17`	`17`	`return input.Where(t => t.IsPassing == condition);`
`18`	`18`	`}`
`@@ -21,7 +21,7 @@ internal static IEnumerable<TypeSpec> HaveDependencyOnAny(FunctionSequenceExecut`
`21`	`21`	`internal static IEnumerable<TypeSpec> HaveDependencyOnAll(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)`
`22`	`22`	`{`
`23`	`23`	`// Get the types that contain the dependencies`
`24`		`- var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);`
	`24`	`+ var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);`
`25`	`25`	`var results = search.FindTypesThatHaveDependencyOnAll(input, dependencies);`
`26`	`26`
`27`	`27`	`return input.Where(t => t.IsPassing == condition);`
`@@ -30,7 +30,7 @@ internal static IEnumerable<TypeSpec> HaveDependencyOnAll(FunctionSequenceExecut`
`30`	`30`	`/// <summary> Function for finding types that have a dependency on type other than one of the supplied types.</summary>`
`31`	`31`	`internal static IEnumerable<TypeSpec> OnlyHaveDependenciesOnAnyOrNone(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)`
`32`	`32`	`{`
`33`		`- var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);`
	`33`	`+ var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);`
`34`	`34`	`var results = search.FindTypesThatOnlyHaveDependencyOnAnyOrNone(input, dependencies);`
`35`	`35`
`36`	`36`	`return input.Where(t => t.IsPassing == condition);`
`@@ -40,7 +40,7 @@ internal static IEnumerable<TypeSpec> OnlyHaveDependenciesOnAnyOrNone(FunctionSe`
`40`	`40`
`41`	`41`	`internal static IEnumerable<TypeSpec> AreUsedByAny(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, IEnumerable<string> dependencies, bool condition)`
`42`	`42`	`{`
`43`		`- var search = new DependencySearch(context.IsFailPathRun, context.DependencyFilter);`
	`43`	`+ var search = new DependencySearch(context.IsFailPathRun, context.UserOptions.SerachForDependencyInFieldConstant, context.DependencyFilter);`
`44`	`44`	`var results = search.FindTypesThatAreUsedByAny(input, dependencies, context.AllTypes);`
`45`	`45`	`return input.Where(t => t.IsPassing == condition);`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ internal sealed class HaveDependenciesBetweenSlices : IFilter`
`9`	`9`	`{`
`10`	`10`	`public IEnumerable<TypeTestResult> Execute(SlicedTypes slicedTypes)`
`11`	`11`	`{`
`12`		`- var dependencySearch = new DependencySearch(false);`
	`12`	`+ var dependencySearch = new DependencySearch(false, false);`
`13`	`13`	`var result = new List<TypeTestResult>(slicedTypes.TypeCount);`
`14`	`14`
`15`	`15`	`for (int i = 0; i < slicedTypes.Slices.Count; i++)`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public static IEnumerable<TypeSpec> GetTypesThatResideInTheSameNamespaceButWitho`
`63`	`63`	`private static void FindTypesWithAnyDependencies(IEnumerable<TypeSpec> subjects, IEnumerable<string> dependencies, bool expectToFind)`
`64`	`64`	`{`
`65`	`65`	`// Arrange`
`66`		`- var search = new global::NetArchTest.Dependencies.DependencySearch(false);`
	`66`	`+ var search = new global::NetArchTest.Dependencies.DependencySearch(false, true);`
`67`	`67`
`68`	`68`	`// Act`
`69`	`69`	`// Search against the dependencies`