Improving test coverage, and added implementations

Author: NickHarvey2

.gitignore

@@ -258,4 +258,9 @@ paket-files/
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
-*.pyc
+*.pyc
+
+# Visual Studio Code files
+*.code-workspace
+launch.json
+tasks.json

src/NetArchTest.Rules/Extensions/FieldDefinitionExtensions.cs

@@ -0,0 +1,23 @@
+namespace NetArchTest.Rules.Extensions
+{
+    using System;
+    using System.Linq;
+    using System.Collections.Generic;
+    using Mono.Cecil;
+
+    /// <summary>
+    /// Extensions for the <see cref="FieldDefinition"/> class.
+    /// </summary>
+    static internal class FieldDefinitionExtensions
+    {
+        /// <summary>
+        /// Tests whether a field is readonly
+        /// </summary>
+        /// <param name="fieldDefinition">The field to test.</param>
+        /// <returns>An indication of whether the field is readonly.</returns>
+        public static bool IsReadonly(this FieldDefinition fieldDefinition)
+        {
+            return !fieldDefinition.IsPublic || fieldDefinition.IsInitOnly || fieldDefinition.HasConstant;
+        }
+    }
+}

src/NetArchTest.Rules/Extensions/PropertyDefinitionExtensions.cs

@@ -0,0 +1,23 @@
+namespace NetArchTest.Rules.Extensions
+{
+    using System;
+    using System.Linq;
+    using System.Collections.Generic;
+    using Mono.Cecil;
+
+    /// <summary>
+    /// Extensions for the <see cref="PropertyDefinition"/> class.
+    /// </summary>
+    static internal class PropertyDefinitionExtensions
+    {
+        /// <summary>
+        /// Tests whether a property is readonly
+        /// </summary>
+        /// <param name="propertyDefinition">The property to test.</param>
+        /// <returns>An indication of whether the property is readonly.</returns>
+        public static bool IsReadonly(this PropertyDefinition propertyDefinition)
+        {
+            return propertyDefinition.SetMethod == null || !propertyDefinition.SetMethod.IsPublic;
+        }
+    }
+}

src/NetArchTest.Rules/Extensions/TypeDefinitionExtensions.cs

@@ -4,6 +4,7 @@
     using System.Linq;
     using System.Collections.Generic;
     using Mono.Cecil;
+    using System.Reflection;
 
     /// <summary>
     /// Extensions for the <see cref="TypeDefinition"/> class.
@@ -54,5 +55,17 @@ public static Type ToType(this TypeDefinition typeDefinition)
             var fullName = typeDefinition.FullName.Replace("/", "+");
             return Type.GetType(string.Concat(fullName, ", ", typeDefinition.Module.Assembly.FullName), true);
         }
+
+        /// <summary>
+        /// Tests whether a class is immutable, i.e. all public fields are readonly and properties have no set method
+        /// </summary>
+        /// <param name="typeDefinition">The class to test.</param>
+        /// <returns>An indication of whether the type is immutable</returns>
+        public static bool IsImmutable(this TypeDefinition typeDefinition)
+        {
+            var propertiesAreReadonly = typeDefinition.Properties.All(p => p.IsReadonly());
+            var fieldsAreReadonly = typeDefinition.Fields.All(f => f.IsReadonly());
+            return propertiesAreReadonly && fieldsAreReadonly;
+        }
     }
 }

src/NetArchTest.Rules/FunctionDelegates.cs

@@ -224,7 +224,14 @@ internal static class FunctionDelegates
         /// <summary> Function for finding sealed classes. </summary>
         internal static FunctionDelegate<bool> BeImmutable = delegate (IEnumerable<TypeDefinition> input, bool dummmy, bool condition)
         {
-            throw new NotImplementedException();
+            if (condition)
+            {
+                return input.Where(c => c.IsImmutable());
+            }
+            else
+            {
+                return input.Where(c => !c.IsImmutable());
+            }
         };
 
         /// <summary> Function for finding types in a particular namespace. </summary>

src/NetArchTest.Rules/NetArchTest.Rules.xml

@@ -422,7 +422,7 @@ public void AreImmutable_MatchesFound_ClassSelected()
                 .That()
                 .ResideInNamespace("NetArchTest.TestStructure.Mutability")
                 .And()
-                .HaveName("ImmutableClass")
+                .HaveNameStartingWith("ImmutableClass")
                 .Should()
                 .BeImmutable().GetResult();
 
@@ -437,7 +437,7 @@ public void AreMutable_MatchesFound_ClassSelected()
                 .That()
                 .ResideInNamespace("NetArchTest.TestStructure.Mutability")
                 .And()
-                .DoNotHaveName("ImmutableClass")
+                .DoNotHaveNameStartingWith("ImmutableClass")
                 .Should()
                 .BeMutable().GetResult();
 

test/NetArchTest.Rules.UnitTests/ConditionTests.cs

@@ -444,8 +444,10 @@ public void AreImmutable_MatchesFound_ClassSelected()
                 .And()
                 .AreImmutable().GetTypes();
 
-            Assert.Single(result); // One result
-            Assert.Contains<Type>(typeof(ImmutableClass), result);
+            Assert.Equal(3, result.Count()); // Three types found
+            Assert.Contains<Type>(typeof(ImmutableClass1), result);
+            Assert.Contains<Type>(typeof(ImmutableClass2), result);
+            Assert.Contains<Type>(typeof(ImmutableClass3), result);
         }
 
         [Fact(DisplayName = "Types can be selected for being mutable.")]

test/NetArchTest.Rules.UnitTests/PredicateTests.cs

@@ -0,0 +1,12 @@
+namespace NetArchTest.TestStructure.Mutability
+{
+    /// <summary>
+    /// An example class that has has no mutable members.
+    /// </summary>
+    public class ImmutableClass1
+    {
+        public object GetOnlyProperty {get;}
+
+        public readonly object readonlyField;
+    }
+}

test/NetArchTest.TestStructure/Mutability/ImmutableClass1.cs

@@ -0,0 +1,12 @@
+namespace NetArchTest.TestStructure.Mutability
+{
+    /// <summary>
+    /// An example class that has has no mutable members.
+    /// </summary>
+    public class ImmutableClass2
+    {
+        public object PrivateSetProperty {get; private set;}
+
+        public const object constField = null;
+    }
+}

test/NetArchTest.TestStructure/Mutability/ImmutableClass2.cs

@@ -3,10 +3,10 @@ namespace NetArchTest.TestStructure.Mutability
     /// <summary>
     /// An example class that has has no mutable members.
     /// </summary>
-    public class ImmutableClass
+    public class ImmutableClass3
     {
-        public object Property {get;}
+        protected object Property {get; set;}
 
-        public readonly object field;
+        private object privateField;
     }
 }