Automatically verify that team rules are met using Architectural Tests

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Only_AggregateRoots_end_with_root_in_the_name()
    {
        IArchRule classesToEndWithRoot = Classes()
            .That()
            .ResideInNamespace("Domain")
            .And()
            .ImplementInterface(typeof(IAggegrateRoot))
            .Should()
            .HaveNameEndingWith("Root");
 
        IArchRule classesDontEndWithRoot = Classes()
            .That()
            .ResideInNamespace("Domain")
            .And()
            .HaveNameEndingWith("Root")
            .Should()
            .ImplementInterface(typeof(IAggegrateRoot))
            .Because("To prevent confusion, only aggregate roots can end with 'Root'.")
            .AndShould()
            .BeSealed();
 
        IArchRule rootRules = classesToEndWithRoot
                .And(classesDontEndWithRoot);
 
        rootRules.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly,
        ).Build();
 
    [Test]
    public void Core_doesnt_have_a_dependency_on_infrastructure()
    {
         IObjectProvider<IType> forbiddenLayer = Types()
             .That()
             .ResideInNamespace("Infrastructure")
             .As("Infrastructure Layer");
 
        TypesShouldConjunction violations = Types()
            .That()
            .ResideInAssembly(typeof(Domain.Domain).Assembly)
            .Should()
            .NotDependOnAny(forbiddenLayer);
 
        violations.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Migrations.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Migrations_are_annotated_with_the_MigrationsAttribute_and_follow_the_agreed_upon_name_convention()
    {
        IArchRule migrationConventionRule = Classes()
            .That()
            .ResideInNamespace("Migrations.Migrations")
            .Should()
            .HaveAnyAttributes(typeof(FluentMigrator.MigrationAttribute))
            .Because("Otherwise the migration isn't run")
            .AndShould()
            .HaveFullName("^Migration_\\d{12}_[A-Za-z0-9_]+?$", true)
            .Because("The filename impacts the order of execution");
 
        migrationConventionRule.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly,
            typeof(WebApi.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Empty_classes_are_not_allowed()
    {
        var classesWithoutBody = Classes()
            .GetObjects(Architecture)
            .Where(clazz =>
            {
                return !clazz.GetFieldMembers().Any()
                       && !clazz.GetPropertyMembers().Any()
                       && clazz.GetMethodMembers().All(methodMember => methodMember.IsConstructor());
            });
 
        Assert.Multiple(() =>
        {
            foreach (var clazz in classesWithoutBody)
            {
                Assert.Fail($"The class '{clazz.Name}' doesn't have a body, did you forget to clean this up?");
            }
        });
    }
 
    [Test]
    public void Models_always_have_an_empty_internal_constructor()
    {
        var modelsWithoutCtor = Classes()
            .That()
            .ResideInNamespace("Models")
            .GetObjects(Architecture)
            .Where(clazz =>
            {
                var internalCtors = clazz.Constructors.Where(c => c.Visibility == Visibility.Internal);
                return !internalCtors.Any() || internalCtors.All(c => c.Parameters.Count() != 0);
            });
 
        Assert.Multiple(() =>
        {
            foreach (var model in modelsWithoutCtor)
            {
                Assert.Fail($"Make sure that '{model.Name}' has an empty constructor it's serializable.");
            }
        });
    }
}