Arc unit test

 

1. What is ArchUnit?

Answer:
ArchUnit is an open-source Java testing library used to validate and enforce application architecture rules (e.g., layered architecture, naming conventions, dependency rules) through unit-like tests.


3. What architectural violations are most important to catch with ArchUnit in enterprise systems?

Ideal Answer

  • Cyclic dependencies between modules

  • Service-to-service direct DB calls

  • Cross-domain leakage (bounded context breaches)

  • Avoiding util-god packages

  • Only domain layer uses domain entities

  • Enforce hexagonal architecture (ports/adapters)

  • REST controllers don’t call repositories directly


4. What type of rules can we enforce with ArchUnit?

Answer:

  • Layered architecture rules

  • Package structure rules

  • Naming conventions

  • Class dependency restrictions

  • Annotation usage rules

  • Cyclic dependency detection


2. Why do we use ArchUnit?

Answer:

  • To enforce architectural standards

  • Prevent bad dependencies

  • Ensure layered structure (Controller → Service → Repository)

  • Detect cyclic dependencies early

  • Improve long-term maintainability


    9. Can we integrate ArchUnit with CI/CD?

    Answer:
    Yes — run ArchUnit tests as part of your normal test pipeline in Maven/Gradle CI tools like GitHub Actions, Jenkins, GitLab CI, etc.

    10. What happens when rules fail?

    Answer:
    The test fails with a descriptive message, preventing merge/deployment if enforced in CI.

    11. Difference between ArchUnit and SonarLint/SonarQube?

    ArchUnitSonarLint/SonarQube
    Developer-defined rulesBuilt-in + custom rules
    Architecture test at unit levelMostly static code quality
    Runtime JUnit testStatic code scan

    3. How do you add ArchUnit dependency?

    Answer:
    Maven

    <dependency>
    <groupId>com.tngtech.archunit</groupId>
    <artifactId>archunit-junit5</artifactId>
    <version>1.2.0</version>
    <scope>test</scope>
</dependency>


    1. How would you ensure architectural governance in a large microservices ecosystem using ArchUnit?
    Expected Talking Points
    • Create reusable architectural rule library shared across repos
    • Validate:
      • Layer boundaries (Controller → Service → Domain → Persistence)
      • Avoid direct DB access in controllers
      • Rule-based module visibility & API boundaries
      • Annotation enforcement (e.g., @Transactional, @Service)
    • Integrate into CI so code violating architecture cannot merge
    5. Example: Enforce Controller naming convention
    Question: Write ArchUnit rule so that all controllers end with Controller.
    Answer:
    @AnalyzeClasses(packages = "com.app")
public class NamingConventionTest {

    @ArchTest
    static final ArchRule controllersShouldBeNamedProperly =
        classes().that().areAnnotatedWith(RestController.class)
        .should().haveSimpleNameEndingWith("Controller");
}
    6. Enforce layered architecture
    Question: Write rule where
    • Controllers only call services
    • Services only call repositories
    Answer:
    @AnalyzeClasses(packages = "com.app")
public class LayeredArchitectureTest {

    @ArchTest
    Static ArchRule layeredArchitecture = layeredArchitecture()
        .layer("Controller").definedBy("..controller..")
        .layer("Service").definedBy("..service..")
        .layer("Repository").definedBy("..repository..")

        .whereLayer("Controller").mayOnlyAccessLayers("Service")
        .whereLayer("Service").mayOnlyAccessLayers("Repository");
}

    7. How do you check for cyclic dependencies?
    Answer:
    @AnalyzeClasses(packages = "com.app")
class CyclicDependencyTest {

    @ArchTest
    static final ArchRule noCycles =
        slices().matching("com.app.(*)..")
        .should().beFreeOfCycles();
}

    8. Can ArchUnit test annotation usage?
    Answer: Yes
    Example: All services must have @Service annotation
    static ArchRule servicesShouldBeAnnotated =
    classes().that().resideInAPackage("..service..")
    .should().beAnnotatedWith(Service.class);

    2. How do you scale ArchUnit tests without slowing down builds in large mono-repos?
    Expected Answer
    • Test only architecture-critical modules
    • Use selective package scans (avoid scanning all classes)
    • Use @AnalyzeClasses(importOptions = ImportOption.DoNotIncludeTests.class)
    • Cache class scans
    • Run full architecture checks nightly; light checks per PR

Comments

Post a Comment

Popular posts from this blog

Archunit test

  ArchUnit  integrates nicely with the  JUnit  test framework, and so, they are typically used together.  All we have to do is add the  archunit-junit 5  dependency to match our  JUnit  version: < dependency > < groupId > com.tngtech.archunit </ groupId > < artifactId > archunit-junit5 </ artifactId > < version > 0.14.1 </ version > < scope > test </ scope > </ dependency > Step 1: The first step is to create a set of Java classes that will be checked for rules violations . We do this by instantiating the  ClassFileImporter  class and then using one of its  importXXX()  methods: JavaClasses jc = new ClassFileImporter () .importPackages( "com.baeldung.archunit.smurfs" ); Step 2:  Let’s try to implement the first rule defined above using this API. We’ll use the  classes()  method as our anchor and add additional constraints ...
Read more

Hexagonal Architecture

Image
  Hexagonal architecture is a model of  designing software applications around domain logic  to isolate it from external factors. The domain logic is specified in a business core, which we’ll call the inside part, with the rest being outside parts.  Access to domain logic from the outside is available through  ports  and  adapters .  here we divide our application into three layers:  application (outside), domain (inside), and infrastructure (outside): Through  the application layer, the user or any other program interacts  with the application. This area should contain things like user interfaces, RESTful controllers, and JSON serialization libraries. It includes anything  that exposes entry to our application, and orchestrates the execution of domain logic. In the domain layer, we keep the code that touches and implements business logic . This is the core of our application. This layer should be isolated from both the applica...
Read more

visitor design pattern

Image
  The Visitor design pattern is a  behavioral pattern  that allows you to add new operations to a group of related classes without modifying their structures. Real-World Example of Visitor Design Pattern A simple example of the Visitor design pattern is in an online shopping cart. Imagine you have different items like books, electronics, and clothing. Each item can accept a visitor that performs actions like calculating the total price or applying discounts. This way, you can add new features without changing the item classes, making the system easier to maintain and update. UML Class Diagram of Visitor design pattern Components of Visitor Design Pattern The Visitor design pattern consists of several key components that work together to enable its functionality. Here’s a breakdown of these components: Visitor Interface : This interface declares a visit method for each type of element in the object structure. Each method is designed to handle a specific element type. Concr...
Read more