Switch generic argument tests to be isolated from fluent tests

Signed-off-by: Pete Forrest <petemforrest@gmail.com>

Author: Itzalive

ArchUnitNETTests/AssemblyTestHelper/DependencyAssemblyTestHelpers.cs

@@ -57,13 +57,6 @@ public class DependencyAssemblyTestHelper : AssemblyTestHelper
     public Class OtherClassWithoutDependencies;
     public Type OtherClassWithoutDependenciesSystemType = typeof(OtherClassWithoutDependencies);
 
-    public Class GenericArgumentClass;
-    public Type GenericArgumentClassSystemType =
-        typeof(TypeDependencyNamespace.GenericArgumentClass);
-
-    public Class ClassWithGenericMethodCallDependency;
-    public Type ClassWithGenericMethodCallDependencySystemType = typeof(ClassWithGenericMethodCall);
-
     public MethodMember MethodWithSingleDependency;
 
     public MethodMember CalledMethod;
@@ -100,15 +93,9 @@ public DependencyAssemblyTestHelper()
         GenericBaseClass = Architecture.GetClassOfType(typeof(GenericBaseClass<>));
         ChildClassOfGeneric = Architecture.GetClassOfType(typeof(ChildClassOfGeneric));
         ClassWithoutDependencies = Architecture.GetClassOfType(typeof(ClassWithoutDependencies));
-        ClassWithGenericMethodCallDependency = Architecture.GetClassOfType(
-            typeof(ClassWithGenericMethodCall)
-        );
         OtherClassWithoutDependencies = Architecture.GetClassOfType(
             typeof(OtherClassWithoutDependencies)
         );
-        GenericArgumentClass = Architecture.GetClassOfType(
-            typeof(TypeDependencyNamespace.GenericArgumentClass)
-        );
         MethodWithSingleDependency = Architecture
             .MethodMembers.WhereNameIs("MethodWithSingleDependency()")
             .First();

ArchUnitNETTests/Dependencies/GenericMemberDependenciesTests.cs

@@ -1,13 +1,38 @@
-namespace ArchUnitNETTests.Dependencies
+using System.Linq;
+using ArchUnitNET.Domain;
+using ArchUnitNET.Domain.Dependencies;
+using ArchUnitNET.Domain.Extensions;
+using Xunit;
+
+namespace ArchUnitNETTests.Dependencies
 {
-    public class GenericMemberDependenciesTests { }
+    public class GenericMemberDependenciesTests
+    {
+        [Fact]
+        public void GenericArgumentsFromMethodCallTest()
+        {
+            var architecture = StaticTestArchitectures.ArchUnitNETTestArchitecture;
+            var classWithGenericMethodCall = architecture.GetClassOfType(
+                typeof(ClassWithGenericMethodCall)
+            );
+            var genericArgumentClass = architecture.GetClassOfType(
+                typeof(GenericArgumentClass)
+            );
+            var methodMember = (MethodMember)classWithGenericMethodCall.Members
+                .WhereNameIs("OuterFunc()")
+                .First();
+            Assert.Contains(methodMember.Dependencies, dependency => dependency is MethodSignatureDependency bodyTypeMemberDependency &&
+                                                                     bodyTypeMemberDependency.Target.Equals(genericArgumentClass));
+        }
+    }
 
-    internal class GenericClass<T>
+    public class ClassWithGenericMethodCall
     {
-        public M GenericMethod<M>(T t)
-            where M : new()
+        public void OuterFunc()
         {
-            return new M();
+            LocalFunc<GenericArgumentClass>();
+
+            void LocalFunc<T>() { }
         }
     }
 }

ArchUnitNETTests/Fluent/Syntax/Elements/ObjectSyntaxElementsTests.cs

@@ -482,18 +482,6 @@ public async Task DependOnAnyTest()
         Types().That().Are(helper.ChildClass1, helper.ChildClass2).Should().BeTypesThat().DependOnAny(helper.BaseClassWithMultipleDependenciesSystemType).AssertNoViolations(helper);
         Types().That().Are(helper.ChildClass, helper.BaseClass).Should().BeTypesThat().DependOnAny(helper.ClassWithoutDependencies).AssertOnlyViolations(helper);
 
-        helper.AddSnapshotHeader("Type with generic argument");
-        should = Types().That().Are(helper.ClassWithGenericMethodCallDependency).Should();
-
-        helper.AddSnapshotSubHeader("Conditions");
-        should.DependOnAny(helper.GenericArgumentClass).AssertNoViolations(helper);
-
-        helper.AddSnapshotSubHeader("Predicates");
-        should.Be(Types().That().DependOnAny(helper.GenericArgumentClass)).AssertNoViolations(helper);
-
-        helper.AddSnapshotSubHeader("Predicates as conditions");
-        should.BeTypesThat().DependOnAny(helper.GenericArgumentClass).AssertNoViolations(helper);
-
         await helper.AssertSnapshotMatches();
     }
 

ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ObjectSyntaxElementsTests.DependOnAnyTest.verified.txt

@@ -591,29 +591,3 @@ Message:
 
 
 
-===== Type with generic argument =====
-
------ Conditions -----
-
-Query: Types that are "TypeDependencyNamespace.ClassWithGenericMethodCall" should depend on "TypeDependencyNamespace.GenericArgumentClass"
-Result: True
-Description: TypeDependencyNamespace.ClassWithGenericMethodCall passed
-Message: 
-All Evaluations passed
-
------ Predicates -----
-
-Query: Types that are "TypeDependencyNamespace.ClassWithGenericMethodCall" should be Types that depend on "TypeDependencyNamespace.GenericArgumentClass"
-Result: True
-Description: TypeDependencyNamespace.ClassWithGenericMethodCall passed
-Message: 
-All Evaluations passed
-
------ Predicates as conditions -----
-
-Query: Types that are "TypeDependencyNamespace.ClassWithGenericMethodCall" should be types that depend on "TypeDependencyNamespace.GenericArgumentClass"
-Result: True
-Description: TypeDependencyNamespace.ClassWithGenericMethodCall passed
-Message: 
-All Evaluations passed
-