ArchUnit Verifies Structure Guidelines for Java Purposes

ArchUnit permits builders to implement structure guidelines equivalent to naming conventions, class entry to different lessons, and the prevention of cycles. The library was initially created in 2017 by Peter Gafert and model 1.0.0 was launched in October.

ArchUnit works with all Java check frameworks and affords particular dependencies for JUnit. The next dependency needs to be used for JUnit 5:

<dependency>
    <groupId>com.tngtech.archunit</groupId>
    <artifactId>archunit-junit5</artifactId>
    <model>1.0.0</model>
    <scope>check</scope>
</dependency>

Now the ClassFileImporter can be utilized to import Java bytecode into Java code. For instance, to import all lessons within the org.instance package deal:

JavaClasses javaClasses = new ClassFileImporter().importPackages("org.instance");

Now the ArchRule class could also be used to outline architectural guidelines for the imported Java lessons in a Area Particular Language (DSL). There are numerous forms of checks out there, the primary one is for package deal dependencies. The examine specifies that no lessons inside repository packages ought to use lessons inside controller packages:

ArchRule rule = noClasses()
    .that().resideInAPackage("..repository..")
    .ought to().dependOnClassesThat().resideInAPackage("..controller..");

Two lessons are used to confirm the foundations, a CourseController class inside a controller package deal and a CourseRepository class inside a repository package deal:

public class CourseController {
	personal CourseRepository courseRepository;
}

public class CourseRepository {
	CourseController courseController;
}

This isn’t allowed by the ArchRule outlined earlier than, which will be examined mechanically with JUnit:

AssertionError assertionError =

    Assertions.assertThrows(AssertionError.class, () -> {
        rule.examine(javaClasses);
});

String expectedMessage = """
	Structure Violation [Priority: MEDIUM] - 
        Rule 'no lessons that reside in a package deal 
        '..repository..' ought to rely on lessons that reside in a package deal 
        '..controller..'' was violated (1 instances):
	Subject <org.instance.repository.CourseRepository.courseController> has sort 
        <org.instance.controller.CourseController> in (CourseRepository.java:0)""";

assertEquals(expectedMessage, assertionError.getMessage());

The CourseController and CourseRepository rely on one another, which frequently is a design flaw. The cycle examine detects cycles between lessons and packages:

ArchRule rule = slices()

    .matching("org.instance.(*)..")
    .ought to().beFreeOfCycles();

AssertionError assertionError =     
    Assertions.assertThrows(AssertionError.class, () -> {
        rule.examine(javaClasses);
});

String expectedMessage = """
	Structure Violation [Priority: MEDIUM] - Rule 'slices matching 
        'org.instance.(*)..' needs to be freed from cycles' was violated (1 instances):
	Cycle detected: Slice controller ->s
                	Slice repository ->s
                	Slice controller
  	1. Dependencies of Slice controller
    	- Subject <org.instance.controller.CourseController.courseRepository> has sort 
            <org.instance.repository.CourseRepository> in (CourseController.java:0)
  	2. Dependencies of Slice repository
    	- Subject <org.instance.repository.CourseRepository.courseController> has sort 
            <org.instance.controller.CourseController> in (CourseRepository.java:0)""";

assertEquals(expectedMessage, assertionError.getMessage());

Class and Bundle containment checks enable the verification of naming and placement conventions. For instance, to confirm that no interfaces are positioned inside implementation packages:

noClasses()
    .that().resideInAPackage("..implementation..")
    .ought to().beInterfaces().examine(lessons);

Or to confirm that each one interfaces have a reputation containing “Interface”:

noClasses()
    .that().areInterfaces()
    .ought to().haveSimpleNameContaining("Interface").examine(lessons);

These containment checks could also be mixed with an annotation examine. For instance, to confirm that each one lessons within the controller package deal with a RestController annotation have a reputation ending with Controller:

lessons()
    .that().resideInAPackage("..controller..")
    .and().areAnnotatedWith(RestController.class)
    .ought to().haveSimpleNameEndingWith("Controller");

Inheritance checks enable, for instance, to confirm that each one lessons implementing the Repository interface have a reputation ending with Repository:

lessons().that().implement(Repository.class)
    .ought to().haveSimpleNameEndingWith("Repository")

With the layer checks, it is attainable to outline the structure layers of an software after which outline the foundations between the layers:

Architectures.LayeredArchitecture rule = layeredArchitecture()
    .consideringAllDependencies()
    // Outline layers
    .layer("Controller").definedBy("..controller..")
    .layer("Repository").definedBy("..Repository..")
    // Add constraints
    .whereLayer("Controller").mayNotBeAccessedByAnyLayer()
    .whereLayer("Repository").mayOnlyBeAccessedByLayers("Controller");

AssertionError assertionError = 
    Assertions.assertThrows(AssertionError.class, () -> {
        rule.examine(javaClasses);
});

String expectedMessage = """
	Structure Violation [Priority: MEDIUM] - Rule 'Layered structure 
        contemplating all dependencies, consisting of
	layer 'Controller' ('..controller..')
	layer 'Repository' ('..Repository..')
	the place layer 'Controller' might not be accessed by any layer
	the place layer 'Repository' might solely be accessed by layers ['Controller']' 
        was violated (2 instances):
	Subject <org.instance.repository.CourseRepository.courseController> has sort 
        <org.instance.controller.CourseController> in (CourseRepository.java:0)
	Layer 'Repository' is empty""";

assertEquals(expectedMessage, assertionError.getMessage());

Extra data will be discovered within the in depth consumer information and official examples from ArchUnit can be found on GitHub.