add rules: HavePublicConstructor/ DoNotHavePublicConstructor

sources/NetArchTest/Condition_Special.cs

@@ -123,5 +123,26 @@ public ConditionList HaveMatchingTypeWithName(Func<TypeDefinition, string> getMa
             AddFunctionCall((context, inputTypes) => FunctionDelegates.HaveMatchingTypeWithName(context, inputTypes, getMatchingTypeName, true));
             return CreateConditionList();
         }
+
+
+        /// <summary>
+        /// Selects types that have at least one public constructor.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList HavePublicConstructor()
+        {
+            AddFunctionCall((context, inputTypes) => FunctionDelegates.HavePublicConstructor(context, inputTypes, true));
+            return CreateConditionList();
+        }
+
+        /// <summary>
+        /// Selects types that do not have a 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();
+        }
     }
 }

sources/NetArchTest/Functions/FunctionDelegates_Special.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using Mono.Cecil;
+using Mono.Cecil.Rocks;
 using NetArchTest.Assemblies;
 using NetArchTest.RuleEngine;
 
@@ -137,5 +138,23 @@ internal static IEnumerable<TypeSpec> HaveMatchingTypeWithName(FunctionSequenceE
                 return input.Where(c => !exisitingTypes.Contains(getMatchingTypeName(c.Definition)));
             }
         }
+
+
+        internal static IEnumerable<TypeSpec> HavePublicConstructor(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => PublicConstructorExists(c.Definition));
+            }
+            else
+            {
+                return input.Where(c => !PublicConstructorExists(c.Definition));
+            }
+
+            static bool PublicConstructorExists(TypeDefinition definition)
+            {
+                return definition.GetConstructors().Any(c => c.IsPublic);
+            }
+        }
     }
 }

sources/NetArchTest/Predicate_Special.cs

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

tests/NetArchTest.Rules.UnitTests/ConditionTests_Special.cs

@@ -197,5 +197,33 @@ public void HaveMatchingTypeWithName_ShouldNot()
 
             Assert.True(result.IsSuccessful);
         }
+
+        [Fact(DisplayName = "HavePublicConstructor")]
+        public void HavePublicConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Constructors")
+                .And()
+                .HaveNameStartingWith("Public", "Default")
+                .Should()
+                .HavePublicConstructor().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "DoNotHavePublicConstructor")]
+        public void NotHavePublicConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace("NetArchTest.TestStructure.Constructors")
+                .And()
+                .DoNotHaveNameStartingWith("Public", "Default")
+                .Should()
+                .NotHavePublicConstructor().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
     }
 }

tests/NetArchTest.Rules.UnitTests/PredicateTests_Special.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using NetArchTest.TestStructure.Constructors;
 using NetArchTest.TestStructure.Mutability;
 using NetArchTest.TestStructure.Nullable;
 using NetArchTest.TestStructure.Stateless;
@@ -148,5 +149,35 @@ public void OnlyHaveNonNullableMembers()
             Assert.Contains<Type>(typeof(NonNullableClass3), result);
             Assert.Contains<Type>(typeof(NonNullableClass4), result);
         }
+
+
+        [Fact(DisplayName = "HavePublicConstructor")]
+        public void HavePublicConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace(namespaceof<PublicConstructor>())
+                .And()
+                .HavePublicConstructor().GetReflectionTypes();
+
+            Assert.Equal(3, result.Count());
+            Assert.Contains<Type>(typeof(DefaultConstructor), result);
+            Assert.Contains<Type>(typeof(PublicConstructor), result);
+            Assert.Contains<Type>(typeof(PublicConstructorOneArgument), result);          
+        }
+
+        [Fact(DisplayName = "DoNotHavePublicConstructor")]
+        public void DoNotHavePublicConstructor()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace(namespaceof<PublicConstructor>())
+                .And()
+                .DoNotHavePublicConstructor().GetReflectionTypes();
+
+            Assert.Equal(2, result.Count());
+            Assert.Contains<Type>(typeof(InternalConstructor), result);
+            Assert.Contains<Type>(typeof(PrivateConstructor), result);           
+        }
     }
 }

tests/NetArchTest.TestStructure/Constructors/DefaultConstructor.cs

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

tests/NetArchTest.TestStructure/Constructors/InternalConstructor.cs

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

tests/NetArchTest.TestStructure/Constructors/PrivateConstructor.cs

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

tests/NetArchTest.TestStructure/Constructors/PublicConstructor.cs

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

tests/NetArchTest.TestStructure/Constructors/PublicConstructorOneArgument.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.TestStructure.Constructors
+{
+    internal class PublicConstructorOneArgument
+    {
+
+
+        public PublicConstructorOneArgument(int a)
+        {
+
+        }
+    }
+}