ArchUnit, Unit Testing The Architecture

@ArchTest
static final ArchRule classesInXShouldOnlyDependOnClassesInY =
        ArchRuleDefinition
                .classes()
                .that().resideInAPackage("..x..")
                .should().onlyDependOnClassesThat()
                .resideInAnyPackage(
                        "..y..",
                        "java.."
                );

@Test
void testClassesInXShouldOnlyDependOnClassesInY() {
    ArchRule rule = classes()
            .that().resideInAPackage("..x..")
            .should().onlyDependOnClassesThat()
            .resideInAnyPackage(
                    "..y..",   
                    "java.."   
            );

    rule.check(IMPORTED_CLASSES);
}

@Test
void testClassesInXShouldOnlyDependOnClassesInY() {
    // Given: Define a rule that restricts classes in package '..x..' 
    // to depend only on classes in '..y..' or standard Java packages.
    ArchRule rule = classes()
            .that().resideInAPackage("..x..")
            .should().onlyDependOnClassesThat()
            .resideInAnyPackage(
                    "..y..",   // Allow dependency on package '..y..'
                    "java.."   // Allow dependency on Java standard library
            );

    // Then
    rule.check(IMPORTED_CLASSES);
}

@Test
void testServiceLayerShouldNotAccessControllers() {
    // Given: Define a rule that prevents the service layer
    // from depending on classes in the controller layer.
    ArchRule rule = noClasses()
            .that().resideInAPackage("..service..")
            .should().dependOnClassesThat()
            .resideInAPackage("..controller..");

    // Then
    rule.check(IMPORTED_CLASSES);
}

@Test
void testNoCyclicDependencies() {
    // Given: Define a rule to ensure there are no cyclic dependencies
    // between modules grouped by their first-level sub-packages under 'org.ps'.
    ArchRule rule = SlicesRuleDefinition.slices()
            .matching("org.ps.(*)..")  // Define slices by sub-packages under 'org.ps'
            .should()
            .beFreeOfCycles();         // Ensure there's no cyclic dependency between them

    // Then
    rule.check(IMPORTED_CLASSES);
}

@Test
void testNoFieldInjection() {
    // Given: Define a rule that disallows field injection using @Autowired.
    ArchRule noFieldInjectionRule = noFields()
            .should().beAnnotatedWith(Autowired.class)
            .because("Use constructor injection instead of field injection.");

    // Also define a rule that disallows setter injection using @Autowired.
    ArchRule noSetterInjectionRule = noMethods()
            .that().haveNameMatching("set[A-Z].*")
            .should().beAnnotatedWith(Autowired.class)
            .because("Use constructor injection instead of setter injection.");

    // When: Combine both rules into one composite rule.
    ArchRule compositeRule = CompositeArchRule.of(noFieldInjectionRule).and(noSetterInjectionRule);

    // Then
    compositeRule.check(IMPORTED_CLASSES);
}

@Test
void testTransactionalAnnotationOnlyInService() {
    // Given: Define a rule that ensures classes annotated with @Transactional
    // are located in the service layer.
    ArchRule classLevelTransactional = classes()
            .that().areAnnotatedWith(Transactional.class)
            .should().resideInAPackage("..service..")
            .because("Class-level @Transactional belongs in the service layer only.");

    // Also define a rule for methods annotated with @Transactional
    // to be declared only in service layer classes.
    ArchRule methodLevelTransactional = methods()
            .that().areAnnotatedWith(Transactional.class)
            .should().beDeclaredInClassesThat().resideInAPackage("..service..")
            .because("Method-level @Transactional belongs in the service layer only.");

    // When: Combine both rules into one composite rule.
    ArchRule compositeRule = CompositeArchRule.of(classLevelTransactional).and(methodLevelTransactional);

    // Then
    compositeRule.check(IMPORTED_CLASSES);
}

@Test
void testRepositoryAnnotationInRepositoryPackage() {
    // Given: Define a rule that ensures @Repository-annotated classes
    // are only located in the repository package.
    ArchRule rule = classes()
            .that().areAnnotatedWith(Repository.class)
            .should().resideInAPackage("..repository..");

    // Then
    rule.check(IMPORTED_CLASSES);
}

@Test
void testServiceAnnotationInServicePackage() {
    // Given: Define a rule that ensures @Service-annotated classes
    // are only located in the service package.
    ArchRule rule = classes()
            .that().areAnnotatedWith(Service.class)
            .should().resideInAPackage("..service..");

    // Then
    rule.check(IMPORTED_CLASSES);
}

org.ps
├─ domain
│   └─ ... (domain models and services)
├─ application
│   ├─ port
│   │   ├─ in
│   │   │   └─ ... (interfaces for incoming incoming requests and messages)
│   │   └─ out
│   │       └─ ... (interfaces for outgoing requests and messages)
│   └─ ... (application services, use case implementations)
├─ adapters
│   ├─ in (incoming requests and messages)
│   └─ out (outgoing requests and messages)
├─ infrastructure
│   └─ ... (external setups - DB connections, queues, metrics)
└─ config
└─ ... (configurations classes for all other packages)