add rules: HaveParameterlessConstructor/ DoNotHaveParameterlessConstructor

Author: NeVeSpl

sources/NetArchTest/Condition_Special.cs

@@ -126,7 +126,7 @@ public ConditionList HaveMatchingTypeWithName(Func<TypeDefinition, string> getMa
 
 
         /// <summary>
-        /// Selects types that have at least one public constructor.
+        /// Selects types that have at least one instance public constructor.
         /// </summary>
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList HavePublicConstructor()
@@ -136,13 +136,33 @@ public ConditionList HavePublicConstructor()
         }
 
         /// <summary>
-        /// Selects types that do not have a public constructor.
+        /// Selects types that do not have a instance public constructor.
         /// </summary>
         /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
         public ConditionList NotHavePublicConstructor()
         {
             AddFunctionCall((context, inputTypes) => FunctionDelegates.HavePublicConstructor(context, inputTypes, false));
             return CreateConditionList();
         }
+
+        /// <summary>
+        /// Selects types that have at least one instance parameterless  constructor.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList HaveParameterlessConstructor()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveParameterlessConstructor(context, inputTypes, true));
+            return CreateConditionList();
+        }
+
+        /// <summary>
+        /// Selects types that do not have a instance parameterless constructor.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList NotHaveParameterlessConstructor()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveParameterlessConstructor(context, inputTypes, false));
+            return CreateConditionList();
+        }
     }
 }

sources/NetArchTest/Functions/FunctionDelegates_Special.cs

@@ -153,7 +153,24 @@ internal static IEnumerable<TypeSpec> HavePublicConstructor(FunctionSequenceExec
 
             static bool PublicConstructorExists(TypeDefinition definition)
             {
-                return definition.GetConstructors().Any(c => c.IsPublic);
+                return definition.GetConstructors().Any(c => c.IsPublic && !c.IsStatic);
+            }
+        }
+
+        internal static IEnumerable<TypeSpec> HaveParameterlessConstructor(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => ParameterlessConstructorExists(c.Definition));
+            }
+            else
+            {
+                return input.Where(c => !ParameterlessConstructorExists(c.Definition));
+            }
+
+            static bool ParameterlessConstructorExists(TypeDefinition definition)
+            {
+                return definition.GetConstructors().Any(c => c.HasParameters == false && !c.IsStatic);
             }
         }
     }

sources/NetArchTest/Predicate_Special.cs

@@ -104,5 +104,26 @@ public PredicateList DoNotHavePublicConstructor()
             AddFunctionCall((context, inputTypes) => FunctionDelegates.HavePublicConstructor(context, inputTypes, false));
             return CreatePredicateList();
         }
+
+
+        /// <summary>
+        /// Selects types that have at least one instance parameterless constructor.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList HaveParameterlessConstructor()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveParameterlessConstructor(context, inputTypes, true));
+            return CreatePredicateList();
+        }
+
+        /// <summary>
+        /// Selects types that do not have public instance parameterless constructor.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList DoNotHaveParameterlessConstructor()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveParameterlessConstructor(context, inputTypes, false));
+            return CreatePredicateList();
+        }
     }
 }

tests/NetArchTest.Rules.UnitTests/ConditionTests_Special.cs

@@ -225,5 +225,33 @@ public void NotHavePublicConstructor()
 
             Assert.True(result.IsSuccessful);
         }
+
+        [Fact(DisplayName = "HaveParameterlessConstructor")]
+        public void HaveParameterlessConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Constructors")
+                .And()
+                .DoNotHaveNameEndingWith("Argument")
+                .Should()
+                .HaveParameterlessConstructor().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "NotHaveParameterlessConstructor")]
+        public void NotHaveParameterlessConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Constructors")
+                .And()
+                .HaveNameEndingWith("Argument")
+                .Should()
+                .NotHaveParameterlessConstructor().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
     }
 }

tests/NetArchTest.Rules.UnitTests/PredicateTests_Special.cs

@@ -175,9 +175,40 @@ public void DoNotHavePublicConstructor()
                 .And()
                 .DoNotHavePublicConstructor().GetReflectionTypes();
 
-            Assert.Equal(2, result.Count());
+            Assert.Equal(3, result.Count());
             Assert.Contains<Type>(typeof(InternalConstructor), result);
-            Assert.Contains<Type>(typeof(PrivateConstructor), result);           
+            Assert.Contains<Type>(typeof(PrivateConstructor), result);
+            Assert.Contains<Type>(typeof(StaticConstructor), result);
+        }
+
+        [Fact(DisplayName = "HaveParameterlessConstructor")]
+        public void HaveParameterlessConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace(namespaceof<PublicConstructor>())
+                .And()
+                .HaveParameterlessConstructor().GetReflectionTypes();
+
+            Assert.Equal(5, result.Count());
+            Assert.Contains<Type>(typeof(DefaultConstructor), result);
+            Assert.Contains<Type>(typeof(InternalConstructor), result);
+            Assert.Contains<Type>(typeof(PrivateConstructor), result);
+            Assert.Contains<Type>(typeof(PublicConstructor), result);
+            Assert.Contains<Type>(typeof(StaticConstructor), result);
+        }
+
+        [Fact(DisplayName = "DoNotHaveParameterlessConstructor")]
+        public void DoNotHaveParameterlessConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace(namespaceof<PublicConstructor>())
+                .And()
+                .DoNotHaveParameterlessConstructor().GetReflectionTypes();
+
+            Assert.Equal(1, result.Count());
+            Assert.Contains<Type>(typeof(PublicConstructorOneArgument), result);            
         }
     }
 }

tests/NetArchTest.TestStructure/Constructors/StaticConstructor.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.TestStructure.Constructors
+{
+    internal class StaticConstructor
+    {
+        StaticConstructor()
+        {
+
+        }
+    }
+}