Enforce Go Architecture with ArcTest: Dependency Rules, Interface Checks, and More

Want to ensure your Go projects adhere to a clean, maintainable architecture? The go-arctest library brings the power of architecture testing to your Go codebase, similar to ArchUnit in Java. Let's examine how you can use go-arctest to validate architectural rules, dependencies, and interface implementations in your Go projects.

What is Go ArcTest?

go-arctest is a Go library that allows you to write tests that verify the architecture of your Go projects. It helps in enforcing architectural rules, such as allowed and disallowed dependencies between packages, interface implementations, and parameter type constraints.

Key Benefits of Using ArcTest for Go Architecture

Enforce Layered Architecture: Define and validate dependencies between layers.
Promote Loose Coupling: Ensure methods use interfaces instead of concrete types.
Automated Validation: Catch architectural violations early in the development cycle through automated tests.

Features: Go Architecture Testing with `go-arctest`

Package Dependency Analysis: Define rules for allowed and disallowed package dependencies.
Interface Implementation Validation: Ensure structs implement required interfaces.
Parameter Type Checking: Verify method parameters use interfaces.
Layered Architecture Support: Define layers and rules to enforce a clean architecture.
Layer-Specific Rules: Define architectural rules specific to individual layers.
Direct Layer Dependency Rules: Intuitively specify layer dependencies using an easy-to-use API.
Nested Package Support: Automatically analyze nested packages within layers.

Installation

Get started with go-arctest by running:

go get github.com/mstrYoda/go-arctest

Usage Examples: Validating Your Go Project's Architecture

Basic Architecture Analysis

First, initialize go-arctest with your project's root directory and parse the packages you want to analyze.

arch, err := arctest.New("./")
if err != nil {
    t.Fatalf("Failed to create architecture: %v", err)
}

err = arch.ParsePackages()
if err != nil {
    t.Fatalf("Failed to parse packages: %v", err)
}

Check Package Dependencies in Go

Create rules that define which packages should or should not depend on each other. This helps maintain a clear separation of concerns.

rule, err := arch.DoesNotDependOn("^domain/.*$", "^infrastructure/.*$")
if err != nil {
    t.Fatalf("Failed to create dependency rule: %v", err)
}

valid, violations := arch.ValidateDependenciesWithRules([]*arctest.DependencyRule{rule})
if !valid {
    for _, violation := range violations {
        t.Errorf("Dependency violation: %s", violation)
    }
}

Validate Interface Implementations in Go

Ensure that your structs correctly implement the interfaces they are supposed to. This promotes polymorphism and testability.

rule, err := arch.StructsImplementInterfaces(".*Repository$", ".*RepositoryInterface$")
if err != nil {
    t.Fatalf("Failed to create interface implementation rule: %v", err)
}

valid, violations := arch.ValidateInterfaceImplementations([]*arctest.InterfaceImplementationRule{rule})
if !valid {
    for _, violation := range violations {
        t.Errorf("Interface implementation violation: %s", violation)
    }
}

Enforce Interface Parameters in Go Methods

Encourage loose coupling by ensuring that methods use interfaces as parameters instead of concrete struct implementations.

rule, err := arch.MethodsShouldUseInterfaceParameters(".*Service$", ".*", ".*Repository$")
if err != nil {
    t.Fatalf("Failed to create parameter rule: %v", err)
}

valid, violations := arch.ValidateMethodParameters([]*arctest.ParameterRule{rule})
if !valid {
    for _, violation := range violations {
        t.Errorf("Parameter type violation: %s", violation)
    }
}

Example: Testing for Interface Parameter Violations in Go

func TestInterfaceParameterViolation(t *testing.T) {
    arch, _ := arctest.New("./example_project")
    arch.ParsePackages("domain", "utils")

    rule, _ := arch.MethodsShouldUseInterfaceParameters(".*Service.*", "Update.*", ".*Logger")
    valid, violations := arch.ValidateMethodParameters([]*arctest.ParameterRule{rule})

    if valid {
        t.Error("Expected interface parameter violations, but none were found!")
    } else {
        t.Logf("Successfully detected methods using concrete types instead of interfaces:")
        for _, violation := range violations {
            t.Logf(" ✓ %s", violation)
        }
    }
}

Defining and Checking a Layered Architecture

go-arctest allows you to define a layered architecture and enforce dependencies between layers.

domainLayer, _ := arctest.NewLayer("Domain", "^domain/.*$")
applicationLayer, _ := arctest.NewLayer("Application", "^application/.*$")
infrastructureLayer, _ := arctest.NewLayer("Infrastructure", "^infrastructure/.*$")
presentationLayer, _ := arctest.NewLayer("Presentation", "^presentation/.*$")

layeredArch := arch.NewLayeredArchitecture(
    domainLayer,
    applicationLayer,
    infrastructureLayer,
    presentationLayer,
)

applicationLayer.DependsOnLayer(domainLayer)
infrastructureLayer.DependsOnLayer(domainLayer)
presentationLayer.DependsOnLayer(domainLayer)
presentationLayer.DependsOnLayer(applicationLayer)

violations, err := layeredArch.Check()
if err != nil {
    t.Fatalf("Failed to check layered architecture: %v", err)
}

Enforcing Dependency Rules

Apply layer-specific rules to fine-tune your architecture validation.

rule1, err := domainLayer.DoesNotDependOn("^(application|infrastructure|presentation)$")
rule2, err := infrastructureLayer.StructsImplementInterfaces(".*Repository$", ".*RepositoryInterface$")
rule3, err := applicationLayer.MethodsShouldUseInterfaceParameters(".*Service$", "New.*", ".*Repository$")

valid1, violations1 := arch.ValidateDependenciesWithRules([]*arctest.DependencyRule{rule1})
valid2, violations2 := arch.ValidateInterfaceImplementations([]*arctest.InterfaceImplementationRule{rule2})
valid3, violations3 := arch.ValidateMethodParameters([]*arctest.ParameterRule{rule3})

Testing for Dependency Violations

These tests are crucial for enforcing architectural rules during development.

func TestDependencyViolation(t *testing.T) {
    arch, _ := arctest.New("./example_project")
    arch.ParsePackages("domain", "utils")

    domainLayer, _ := arctest.NewLayer("Domain", "^domain$")
    utilsLayer, _ := arctest.NewLayer("Utils", "^utils$")

    layeredArch := arch.NewLayeredArchitecture(domainLayer, utilsLayer)
    rule, _ := domainLayer.DoesNotDependOn("^utils$")

    valid, violations := arch.ValidateDependenciesWithRules([]*arctest.DependencyRule{rule})

    if valid {
        t.Error("Expected dependency violations, but none were found!")
    } else {
        t.Logf("Successfully detected dependency violations:")
        for _, violation := range violations {
            t.Logf(" ✓ %s", violation)
        }
    }
}

Go Architecture Testing: Get Started with ArcTest

go-arctest provides powerful tools to enforce and validate your Go project's architecture. By using it, you can ensure a clean, maintainable, and testable codebase. Start integrating go-arctest into your projects to catch architectural violations early and maintain a healthy architecture.