BenMorris/NetArchTest#97 - add rules: HaveSourceFileNameMatchingName, HaveSourceFilePathMatchingNamespace

Author: NeVeSpl

src/NetArchTest.Rules/Condition_Special.cs

@@ -74,5 +74,32 @@ public ConditionList OnlyHaveNonNullableMembers()
             AddFunctionCall(x => FunctionDelegates.OnlyHaveNonNullableMembers(x, true));
             return CreateConditionList();
         }
+
+
+        /// <summary>
+        /// Check if the name of a type is consistent with its source file name
+        /// </summary>
+        /// <remarks>
+        /// StringComparison.InvariantCultureIgnoreCase is used for comparing, can be changed through Options
+        /// </remarks>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList HaveSourceFileNameMatchingName()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveFileNameMatchingTypeName(context, inputTypes, true));
+            return CreateConditionList();
+        }
+
+        /// <summary>
+        /// Check if the namespace of a type is consistent with its source file path
+        /// </summary>
+        /// <remarks>
+        /// StringComparison.InvariantCultureIgnoreCase is used for comparing, can be changed through Options
+        /// </remarks>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList HaveSourceFilePathMatchingNamespace()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveFilePathMatchingTypeNamespace(context, inputTypes, true));
+            return CreateConditionList();
+        }
     }
 }

src/NetArchTest.Rules/Functions/FunctionDelegates_Special.cs

@@ -1,7 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using Mono.Cecil;
 using NetArchTest.Assemblies;
+using NetArchTest.RuleEngine;
 
 namespace NetArchTest.Functions
 {
@@ -67,5 +70,47 @@ internal static IEnumerable<TypeSpec> BeStateless(IEnumerable<TypeSpec> input, b
                 return input.Where(c => !c.Definition.IsStateless());
             }
         }
+
+        internal static IEnumerable<TypeSpec> HaveFileNameMatchingTypeName(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => IsMatching(c.SourceFilePath, c.Definition.GetName(), context.UserOptions.Comparer));
+            }
+            else
+            {
+                return input.Where(c => !IsMatching(c.SourceFilePath, c.Definition.GetName(), context.UserOptions.Comparer));
+            }
+
+            static bool IsMatching(string sourceFilePath, string typeName, StringComparison comparer)
+            {
+                if (string.IsNullOrEmpty(sourceFilePath)) return true;
+
+                var fileName = Path.GetFileNameWithoutExtension(sourceFilePath);
+                return fileName.Equals(typeName, comparer);
+            }
+        }
+
+        internal static IEnumerable<TypeSpec> HaveFilePathMatchingTypeNamespace(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => IsMatching(c.SourceFilePath, c.Definition.GetNamespace(), context.UserOptions.Comparer));
+            }
+            else
+            {
+                return input.Where(c => !IsMatching(c.SourceFilePath, c.Definition.GetNamespace(), context.UserOptions.Comparer));
+            }
+
+            static bool IsMatching(string sourceFilePath, string @namespace, StringComparison comparer)
+            {
+                if (string.IsNullOrEmpty(sourceFilePath)) return true;
+
+                var fullPath = Path.GetDirectoryName(sourceFilePath);
+                var pathAsNamespace = fullPath.Replace(Path.DirectorySeparatorChar, '.');                
+
+                return pathAsNamespace.EndsWith(@namespace, comparer);
+            }
+        }
     }
 }

test/NetArchTest.Rules.UnitTests/ConditionTests_Special.cs

@@ -1,6 +1,7 @@
 using System.Linq;
 using System.Reflection;
 using NetArchTest.Rules;
+using NetArchTest.TestStructure.File;
 using NetArchTest.TestStructure.NameMatching.Namespace1;
 using NetArchTest.TestStructure.Stateless;
 using Xunit;
@@ -123,5 +124,67 @@ public void OnlyHaveNonNullableMembers()
 
             Assert.True(result.IsSuccessful);
         }
+
+
+        [Fact(DisplayName = "HaveFileNameMatchingTypeName_Should")]
+        public void HaveFileNameMatchingTypeName_Should()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()
+                .ResideInNamespace(namespaceof<SourceFileNameType>())
+                .And()
+                .DoNotHaveNameStartingWith("Incorrect")
+                .Should()
+                .HaveSourceFileNameMatchingName().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "HaveFileNameMatchingTypeName_ShouldNot")]
+        public void HaveFileNameMatchingTypeName_ShouldNot()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()
+                .ResideInNamespace(namespaceof<SourceFileNameType>())
+                .And()
+                .HaveNameStartingWith("Incorrect")
+                .ShouldNot()
+                .HaveSourceFileNameMatchingName().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+
+        [Fact(DisplayName = "HaveSourceFilePathMatchingTypeNamespace_Should")]
+        public void HaveSourceFilePathMatchingTypeNamespace_Should()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()
+                .ResideInNamespace(namespaceof<SourceFileNameType>())
+                .And()
+                .ResideInNamespaceContaining(@"\.Correct")
+                .Should()
+                .HaveSourceFilePathMatchingNamespace().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "HaveSourceFilePathMatchingTypeNamespace_ShouldNot")]
+        public void HaveSourceFilePathMatchingTypeNamespace_ShouldNot()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(SourceFileNameType)))
+                .That()
+                .ResideInNamespace(namespaceof<SourceFileNameType>())
+                .And()
+                .ResideInNamespaceContaining(".Incorrect")
+                .ShouldNot()
+                .HaveSourceFilePathMatchingNamespace().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
     }
 }

test/NetArchTest.TestStructure/File/Correct/IncorrectSourceFileNameType.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.TestStructure.File.Correct
+{
+    internal class IncorrectSourceFileNameTypeFoo
+    {
+        public IncorrectSourceFileNameTypeFoo()
+        {
+
+        }
+    }
+}

test/NetArchTest.TestStructure/File/Incorrect/CorrectSourceFileNameType.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.TestStructure.File.Incorrect.Yabadabado
+{
+    internal class CorrectSourceFileNameType
+    {
+        public CorrectSourceFileNameType()
+        {
+
+        }
+    }
+}

test/NetArchTest.TestStructure/File/SourceFileNameType.cs

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