feat: Add HavePrivateParameterlessConstructor and NotHavePrivateParameterlessConstructor conditions

Add support for checking if classes have private parameterless constructors,
which is essential for enforcing Domain-Driven Design patterns and ORM requirements.

Signed-off-by: Ahmed Mohamed El Ahmar <ahmedmohamedelahmar@gmail.com>

Author: Redestros

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using ArchUnitNET.Domain;
+using ArchUnitNET.Domain.Extensions;
 using ArchUnitNET.Fluent.Conditions;
 
 namespace ArchUnitNET.Fluent.Syntax.Elements.Types.Classes
@@ -43,6 +44,16 @@ public static ICondition<Class> BeImmutable()
                 "is not immutable"
             );
         }
+        
+        public static ICondition<Class> HavePrivateParameterlessConstructor()
+        {
+            return new SimpleCondition<Class>(
+                cls => (cls.IsAbstract.HasValue && cls.IsAbstract.Value) || cls.GetConstructors().Any(c => 
+                    c.Visibility == Visibility.Private && !c.Parameters.Any()),
+                "have private parameterless constructor",
+                "does not have private parameterless constructor"
+            );
+        }
 
         //Negations
 
@@ -81,5 +92,15 @@ public static ICondition<Class> NotBeImmutable()
                 "is immutable"
             );
         }
+
+        public static ICondition<Class> NotHavePrivateParameterlessConstructor()
+        {
+            return new SimpleCondition<Class>(
+                cls => (cls.IsAbstract.HasValue && cls.IsAbstract.Value) || !cls.GetConstructors().Any(c => 
+                    c.Visibility == Visibility.Private && !c.Parameters.Any()),
+                "not have private parameterless constructor",
+                "has private parameterless constructor"
+            );
+        }
     }
 }

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassesShould.cs

@@ -33,6 +33,12 @@ public ClassesShouldConjunction BeImmutable()
             return new ClassesShouldConjunction(_ruleCreator);
         }
 
+        public ClassesShouldConjunction HavePrivateParameterlessConstructor()
+        {
+            _ruleCreator.AddCondition(ClassConditionsDefinition.HavePrivateParameterlessConstructor());
+            return new ClassesShouldConjunction(_ruleCreator);
+        }
+
         //Negations
 
         public ClassesShouldConjunction NotBeAbstract()
@@ -58,5 +64,11 @@ public ClassesShouldConjunction NotBeImmutable()
             _ruleCreator.AddCondition(ClassConditionsDefinition.NotBeImmutable());
             return new ClassesShouldConjunction(_ruleCreator);
         }
+        
+        public ClassesShouldConjunction NotHavePrivateParameterlessConstructor()
+        {
+            _ruleCreator.AddCondition(ClassConditionsDefinition.NotHavePrivateParameterlessConstructor());
+            return new ClassesShouldConjunction(_ruleCreator);
+        }
     }
 }

ArchUnitNETTests/ArchUnitNETTests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
-    <LangVersion>latest</LangVersion>
+    <LangVersion>default</LangVersion>
     <Company>TNG Technology Consulting GmbH</Company>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

ArchUnitNETTests/Fluent/Syntax/Elements/ClassPrivateConstructorConditionTests.cs

@@ -0,0 +1,73 @@
+using ArchUnitNET.Domain;
+using ArchUnitNET.Loader;
+using TestAssembly.Domain.Entities;
+using Xunit;
+using static ArchUnitNET.Fluent.ArchRuleDefinition;
+
+namespace ArchUnitNETTests.Fluent.Syntax.Elements;
+
+public class ClassPrivateConstructorConditionTests
+{
+    private static readonly Architecture Architecture =
+        new ArchLoader().LoadAssembly(typeof(ClassWithPrivateParameterlessConstructor).Assembly).Build();
+
+    [Fact]
+    public void HavePrivateParameterlessConstructor_ClassWithPrivateParameterlessConstructor_DoesNotViolate()
+    {
+        var rule = Classes()
+            .That().HaveName(nameof(ClassWithPrivateParameterlessConstructor))
+            .Should().HavePrivateParameterlessConstructor();
+
+        Assert.True(rule.HasNoViolations(Architecture));
+    }
+
+    [Fact]
+    public void HavePrivateParameterlessConstructor_ClassWithoutPrivateParameterlessConstructor_Violates()
+    {
+        var rule = Classes()
+            .That().HaveName(nameof(ClassWithoutPrivateParameterlessConstructor))
+            .Should().HavePrivateParameterlessConstructor();
+
+        Assert.False(rule.HasNoViolations(Architecture));
+    }
+
+    [Fact]
+    public void NotHavePrivateParameterlessConstructor_ClassWithoutPrivateParameterlessConstructor_DoesNotViolate()
+    {
+        var rule = Classes()
+            .That().HaveName(nameof(ClassWithoutPrivateParameterlessConstructor))
+            .Should().NotHavePrivateParameterlessConstructor();
+
+        Assert.True(rule.HasNoViolations(Architecture));
+    }
+
+    [Fact]
+    public void NotHavePrivateParameterlessConstructor_ClassWithPrivateParameterlessConstructor_Violates()
+    {
+        var rule = Classes()
+            .That().HaveName(nameof(ClassWithPrivateParameterlessConstructor))
+            .Should().NotHavePrivateParameterlessConstructor();
+
+        Assert.False(rule.HasNoViolations(Architecture));
+    }
+
+    [Fact]
+    public void HavePrivateParameterlessConstructor_AbstractClass_DoesNotViolate()
+    {
+        var rule = Classes()
+            .That().AreAbstract()
+            .Should().HavePrivateParameterlessConstructor();
+
+        Assert.True(rule.HasNoViolations(Architecture));
+    }
+
+    [Fact]
+    public void HavePrivateParameterlessConstructor_ClassWithOnlyParameterizedConstructors_Violates()
+    {
+        var rule = Classes()
+            .That().HaveName(nameof(ClassWithOnlyParameterizedConstructors))
+            .Should().HavePrivateParameterlessConstructor();
+
+        Assert.False(rule.HasNoViolations(Architecture));
+    }
+}

TestAssembly/Domain/Entities/PrivateConstructorTestClasses.cs

@@ -0,0 +1,56 @@
+namespace TestAssembly.Domain.Entities;
+
+public class ClassWithPrivateParameterlessConstructor
+{
+    private ClassWithPrivateParameterlessConstructor()
+    {
+        // Private parameterless constructor for ORM
+    }
+
+    public ClassWithPrivateParameterlessConstructor(string name)
+    {
+        Name = name;
+    }
+
+    public string Name { get; private set; }
+}
+
+public class ClassWithoutPrivateParameterlessConstructor
+{
+    public ClassWithoutPrivateParameterlessConstructor()
+    {
+        // Public parameterless constructor
+    }
+
+    public ClassWithoutPrivateParameterlessConstructor(string name)
+    {
+        Name = name;
+    }
+
+    public string Name { get; private set; }
+}
+
+public class ClassWithOnlyParameterizedConstructors
+{
+    public ClassWithOnlyParameterizedConstructors(string name)
+    {
+        Name = name;
+    }
+
+    public ClassWithOnlyParameterizedConstructors(int id, string name)
+    {
+        Id = id;
+        Name = name;
+    }
+
+    public int Id { get; private set; }
+    public string Name { get; private set; }
+}
+
+public abstract class AbstractClassBase
+{
+    protected AbstractClassBase()
+    {
+        // Abstract classes should be excluded from checks
+    }
+}