[Fact(DisplayName = "Lower layers can not depend on outer layers")]
public void CheckDependencyRule()
{
    // We declare our different layers
    var domain = ArchRuleDefinition
        .Types()
        .That()
        .ResideInNamespace("Domain", true);

    var useCases = ArchRuleDefinition
        .Types()
        .That()
        .ResideInNamespace("UseCases", true);

    var controllers = ArchRuleDefinition
        .Types()
        .That()
        .ResideInNamespace("Controllers", true);

    var repositories = ArchRuleDefinition
        .Types()
        .That()
        .ResideInNamespace("Repositories", true);

    // We define an Architecture Rule
    IArchRule rule = domain
        .Should()
        // Domain can only reference types in the Domain itself
        .OnlyDependOn(domain)
        .And(
            // Use Cases can only reference types in Domain and in itself
            useCases
                .Should()
                .NotDependOnAny(controllers).AndShould()
                .NotDependOnAny(repositories)
        )
        .And(
            // Controllers can reference types in Use Cases and Domain
            controllers
                .Should()
                .NotDependOnAny(repositories)
        );

    // We define what is the Architecture to check the rule "against"
    ArchUnitNET.Domain.Architecture architecture = new ArchLoader()
        .LoadAssemblies(typeof(GoatController).Assembly)
        .Build();

    // We run the check
    rule.Check(architecture);
}

public class SplitArchitecture
{
    private static readonly ArchUnitNET.Domain.Architecture Architecture =
        new ArchLoader()
            .LoadAssemblies(
                // We load the different Assemblies to run the Check
                typeof(Goat.Controllers.GoatController).Assembly,
                typeof(Goat.UseCases.FeedGoat).Assembly,
                typeof(Goat.Domain.Goat).Assembly,
                typeof(Goat.Repositories.GoatRepository).Assembly
            )
            .Build();

    private static GivenTypesConjunction TypesIn(string @namespace) =>
        ArchRuleDefinition.Types().That().ResideInNamespace(@namespace, true);

    private static GivenTypesConjunctionWithDescription Controllers() =>
        TypesIn("Controllers").As("Interface Adapters");

    private static GivenTypesConjunctionWithDescription UseCases() =>
        TypesIn("UseCases").As("Application Business Rules");

    private static GivenTypesConjunctionWithDescription Frameworks_Drivers() =>
        TypesIn("Repositories").As("Framework & Drivers");

    private static GivenTypesConjunctionWithDescription Domain() =>
        TypesIn("Domain").As("Enterprise Business Rules");

    [Fact(DisplayName = "Lower layers can not depend on outer layers")]
    public void CheckRule() =>
        Domain()
            .Should()
            .OnlyDependOn(Domain())
            .And(
                UseCases().Should()
                    .NotDependOnAny(Controllers()).AndShould()
                    .NotDependOnAny(Frameworks_Drivers())
            )
            .And(
                Controllers().Should()
                    .NotDependOnAny(Frameworks_Drivers())
            ).Check(Architecture);
}

public class LinguisticAntiPatterns
{
    private static GivenMethodMembersThat Methods() => MethodMembers().That().AreNoConstructors().And();

    [Fact]
    // A method starting with Get should return something
    public void NoGetMethodShouldReturnVoid() =>
        Methods()
            .HaveName("Get[A-Z].*", useRegularExpressions: true).Should()
            .NotHaveReturnType(typeof(void))
            .Check();

    [Fact]
    // A method starting with Is or Has should return a bool
    public void IserAndHaserShouldReturnBooleans() =>
        Methods()
            .HaveName("Is[A-Z].*|Has[A-Z].*", useRegularExpressions: true)
            .Should()
            .HaveReturnType(typeof(bool))
            .Check();
}

// Will detect those anti-patterns in Production code
public class ShittyMethods
{
    public bool IsShitty() => false;
    // Should return a bool
    public void IsCorrect() { }
    // Should return something
    public void GetShitty() { }
    public void HasShittyDef() { }
}

- A method must start by a capital letter
- An interface must start with I
- Every classes residing in the Services namespace must be suffixed with Service
- Every classes implementing the ICommandHandler interface must be suffixed with CommandHandler
...

public class NamingConvention
{
    [Fact]
    public void AllMethodsShouldStartWithACapitalLetter() =>
        // We exclude methods generated at compile time like get_EqualityContract for example
        MethodMembers()
            .That().AreNoConstructors()
            .And().DoNotHaveAnyAttributes("SpecialName|CompilerGenerated", true).Should()
            .HaveName(@"^[A-Z]", true)
            .Because("C# convention...")
            .Check();

    [Fact]
    public void InterfacesShouldStartWithI() =>
        Interfaces().Should()
            .HaveName("^I[A-Z].*", useRegularExpressions: true)
            .Because("C# convention...")
            .Check();

    [Fact]
    public void ServicesShouldBeSuffixedByService() =>
        Classes()
            .That()
            .ResideInNamespace("Services", true).Should()
            .HaveNameEndingWith("Service")
            .Check();

    [Fact]
    public void CommandHandlersShouldBeSuffixedByCommandHandler() =>
        Classes()
            .That()
            .ImplementInterface(typeof(ICommandHandler<>)).Should()
            .HaveNameEndingWith("CommandHandler")
            .Check();
}

// Will detect those code in Production code
public class Goat
{
    // Should start with a capital letter
    void poorName()
    {
    }
}

// Should start with an I
public interface AGoat { }

public abstract record Command(Guid Id) { }
public interface ICommandHandler<in TCommand>
    where TCommand : Command
{
    int Handle(TCommand command);
}

public record Order(Guid Id) : Command(Id) { }

// Should end with CommandHandler
public class OrderService : ICommandHandler<Order>
{
    public int Handle(Order command) => 42;
}

namespace Goat.Examples.Services
{
    // Should end with Service
    public class NotCompliantClass
    {
    }
}

- Controllers should reside only in the namespace "Controllers"
- The attribute ExcludeFromCoverage should not be used

public class Annotations
{
    private const string UseConfigFile = "You should use config file instead of ExcludeFromCodeCoverageAttribute";
    private static readonly Type ExcludeFromCoverage = typeof(ExcludeFromCodeCoverageAttribute);

    [Fact]
    public void AnnotatedClassesShouldResideInAGivenNamespace() =>
        Classes().That()
            .HaveAnyAttributes(typeof(ApiControllerAttribute)).Should()
            .ResideInNamespace("Controllers", true)
            .Check();

    [Fact]
    public void CoverageAttributesShouldNotBeUsedOnClasses() =>
        Classes()
            .That().HaveAnyAttributes(ExcludeFromCoverage).Should()
            .NotExist()
            .Because(UseConfigFile)
            .Check();

    [Fact]
    public void CoverageAttributesShouldNotBeUsedOnMethods() =>
        MethodMembers()
            .That().HaveAnyAttributes(ExcludeFromCoverage).Should()
            .NotExist()
            .Because(UseConfigFile)
            .Check();

    [Fact]
    public void CoverageAttributesShouldNotBeUsedOnProperties() =>
        PropertyMembers()
            .That()
            .HaveAnyAttributes(ExcludeFromCoverage).Should()
            .NotExist()
            .Because(UseConfigFile)
            .Check();
}

// Will detect those code in Production code
// This attributes should not be used
[ExcludeFromCodeCoverage]
public class Feed
{
    [ExcludeFromCodeCoverage] public string Name { get; set; }

    [ExcludeFromCodeCoverage]
    public void Again()
    {
    }
}

// Controllers should reside in "Controller" namespace
[ApiController]
public class GoatController
{
}

public class MethodReturnTypes
{
    [Fact]
    public void ControllersPublicMethodShouldOnlyReturnApiResponse() =>
        MethodMembers().That()
            .ArePublic().And()
            .AreNoConstructors().And()
            .AreDeclaredIn(Controllers()).Should()
            .HaveReturnType(typeof(ApiResponse<>))
            .Check();

    private static GivenClassesConjunction Controllers() =>
        Classes().That().HaveAnyAttributes(typeof(ApiControllerAttribute));
}

// Will detect those code in Production code
public record ApiError(string Code, string Message);\
public record ApiResponse<TData>(TData Data, ApiError[]? Errors = null);

[ApiController]
public class GoatControllerV2
{
    public ApiResponse<int> Matching() => new ApiResponse<int>(42);

    // This public method should return an ApiResponse
    public void NotMatching()
    {
    }
}