Test ‐ ArchUnit - thought-corner/backend-roadmap GitHub Wiki

// ⭕ Good(레이어드 아키텍처 검증 - 계층 간 의존 방향 강제)
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
import com.tngtech.archunit.library.Architectures;
import org.junit.jupiter.api.Test;

import static com.tngtech.archunit.library.Architectures.layeredArchitecture;

class LayeredArchitectureTest {

    private final JavaClasses classes = new ClassFileImporter()
            .importPackages("com.example.myapp");

    @Test
    void 계층_간_의존_방향을_지킨다() {
        layeredArchitecture()
                .consideringAllDependencies()
                .layer("Controller").definedBy("..controller..")
                .layer("Service").definedBy("..service..")
                .layer("Repository").definedBy("..repository..")
                .layer("Entity").definedBy("..entity..")

                .whereLayer("Controller").mayNotBeAccessedByAnyLayer()
                .whereLayer("Service").mayOnlyBeAccessedByLayers("Controller")
                .whereLayer("Repository").mayOnlyBeAccessedByLayers("Service")
                .whereLayer("Entity").mayOnlyBeAccessedByLayers("Service", "Repository")

                .check(classes);
    }
}

// ⭕ Good(특정 패키지 의존성 감지 - domain이 infrastructure를 참조하면 안 된다.)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

@Test
void domain_패키지는_infrastructure에_의존하지_않는다() {
    noClasses()
            .that().resideInAPackage("..domain..")
            .should().dependOnClassesThat().resideInAPackage("..infrastructure..")
            .check(classes);
}

// ⭕ Good(순환 참조 검증)
import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices;

@Test
void 패키지_간_순환_참조가_없어야_한다() {
    slices()
            .matching("com.example.myapp.(*)..")
            .should().beFreeOfCycles()
            .check(classes);
}

// ⭕ Good(네이밍 컨벤션 강제)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

@Test
void Repository로_끝나는_클래스는_인터페이스여야_한다() {
    classes()
            .that().haveSimpleNameEndingWith("Repository")
            .should().beInterfaces()
            .check(classes);
}

@Test
void Service_클래스는_Service_어노테이션이_붙어야_한다() {
    classes()
            .that().resideInAPackage("..service..")
            .and().areNotInterfaces()
            .should().beAnnotatedWith(org.springframework.stereotype.Service.class)
            .check(classes);
}

// ⭕ Good(필드 주입 금지 - 생성자 주입 강제)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noFields;

@Test
void Autowired_필드_주입을_금지한다() {
    noFields()
            .should().beAnnotatedWith(org.springframework.beans.factory.annotation.Autowired.class)
            .check(classes);
}

// ⭕ Good(DTO는 도메인 로직을 가지면 안 된다)
@Test
void DTO는_public_메서드를_최소화한다() {
    classes()
            .that().haveSimpleNameEndingWith("Dto")
            .should().onlyHaveDependentClassesThat().resideInAnyPackage("..controller..", "..service..")
            .check(classes);
}

// ⭕ Good(특정 클래스가 다른 특정 클래스에 의존하면 안 된다)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

@Test
void OrderService는_PaymentGateway를_직접_의존하지_않는다() {
    noClasses()
            .that().areAssignableTo(OrderService.class)
            .should().dependOnClassesThat().areAssignableTo(PaymentGateway.class)
            .check(classes);
}

// ⭕ Good(특정 클래스는 지정된 클래스에게만 접근을 허용한다 - 캡슐화 강제)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

@Test
void InternalOrderProcessor는_OrderFacade에서만_접근한다() {
    classes()
            .that().haveSimpleName("InternalOrderProcessor")
            .should().onlyBeAccessed().byClassesThat()
            .haveSimpleName("OrderFacade")
            .check(classes);
}

// ⭕ Good(특정 클래스는 지정한 클래스만 의존해야 한다 - 화이트리스트 방식)
@Test
void PaymentValidator는_허용된_클래스만_의존한다() {
    classes()
            .that().haveSimpleName("PaymentValidator")
            .should().onlyDependOnClassesThat()
            .resideInAnyPackage("java..", "..payment.validation..", "..payment.exception..")
            .check(classes);
}

// ⭕ Good(양방향 의존 금지 - A가 B를 의존하면 B는 A를 의존하면 안 된다)
@Test
void OrderService와_InventoryService는_서로_의존하지_않는다() {
    noClasses()
            .that().haveSimpleName("OrderService")
            .should().dependOnClassesThat().haveSimpleName("InventoryService")
            .andShould().onlyBeAccessed().byAnyPackage("..order..")
            .check(classes);

    noClasses()
            .that().haveSimpleName("InventoryService")
            .should().dependOnClassesThat().haveSimpleName("OrderService")
            .check(classes);
}

// ⭕ Good(구체 클래스가 아닌 인터페이스에만 의존해야 한다 - DIP 강제)
@Test
void Service는_Repository_구현체가_아닌_인터페이스에_의존한다() {
    noClasses()
            .that().resideInAPackage("..service..")
            .should().dependOnClassesThat()
            .haveNameMatching(".*RepositoryImpl")
            .check(classes);
}

// ⭕ Good(특정 클래스가 필드를 통해 직접 접근되는 것을 금지 - getter 강제)
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

@Test
void Order_필드에_외부에서_직접_접근하지_않는다() {
    noClasses()
            .that().resideOutsideOfPackage("..order..")
            .should().accessFieldWhere(field -> field.getOwner().isEquivalentTo(Order.class))
            .check(classes);
}