This rule class enforces cycle freedom inside configured adapter and domain-model
+ * package roots. Layer boundary checks can miss cycles inside a single layer, so these
+ * rules prevent tightly coupled package graphs that are hard to evolve and test.
+ *
+ *
This class is discovered and included in the rule-pack suite by the Architecture Validator
+ * plugin. Each test method defines a separate validation rule.
+ *
+ * @see RulePackConfiguration
+ * @since 1.0.0
+ */
+class CycleFreedomTest {
+
+ private final JavaClasses classes = new ClassFileImporter()
+ .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+ .importPackages(RulePackConfiguration.basePackage());
+
+ /**
+ * Validates that configured adapter package trees are free of package cycles.
+ */
+ @Test
+ void adapterPackagesShouldBeFreeOfCycles() {
+ assertConfiguredSlicesAreCycleFree(
+ RulePackConfiguration.adapters(),
+ "Adapter packages should remain acyclic to keep infrastructure boundaries maintainable");
+ }
+
+ /**
+ * Validates that configured domain model package trees are free of package cycles.
+ */
+ @Test
+ void domainModelShouldBeFreeOfCycles() {
+ assertConfiguredSlicesAreCycleFree(
+ RulePackConfiguration.domainModel(),
+ "Domain model packages should remain acyclic to preserve a clear core model structure");
+ }
+
+ private void assertConfiguredSlicesAreCycleFree(String[] packageRoots, String reason) {
+ if (packageRoots.length == 0) {
+ return;
+ }
+
+ Arrays.stream(packageRoots)
+ .map(CycleFreedomTest::toSlicePattern)
+ .forEach(slicePattern -> slices()
+ .matching(slicePattern)
+ .should().beFreeOfCycles()
+ .because(reason)
+ .allowEmptyShould(true)
+ .check(classes));
+ }
+
+ private static String toSlicePattern(String packageRoot) {
+ String trimmed = packageRoot.trim();
+ boolean matchesAnyPrefix = trimmed.startsWith("..");
+
+ String normalized = trimmed;
+ while (normalized.startsWith("..")) {
+ normalized = normalized.substring(2);
+ }
+
+ while (normalized.endsWith("..")) {
+ normalized = normalized.substring(0, normalized.length() - 2);
+ }
+
+ if (normalized.endsWith(".")) {
+ normalized = normalized.substring(0, normalized.length() - 1);
+ }
+
+ if (normalized.isEmpty()) {
+ return "(**)";
+ }
+
+ // ArchUnit slice patterns anchor to the start of the fully-qualified class name unless
+ // prefixed with "..", so a leading ".." in the configured package root must be preserved,
+ // otherwise nested packages (the normal case) never match and the check passes vacuously.
+ return (matchesAnyPrefix ? ".." : "") + normalized + ".(**)";
+ }
+}
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyDirectionTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyDirectionTest.java
index 88b747b..2d82e0f 100644
--- a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyDirectionTest.java
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyDirectionTest.java
@@ -3,6 +3,7 @@
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
@@ -43,6 +44,10 @@ class DependencyDirectionTest {
*/
@Test
void coreApplicationLayerShouldNotDependOnAdapters() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DependencyDirectionTest.coreApplicationLayerShouldNotDependOnAdapters"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
noClasses()
.that().resideOutsideOfPackage("..adapter..")
.and().resideOutsideOfPackage("..adapters..")
@@ -60,6 +65,10 @@ void coreApplicationLayerShouldNotDependOnAdapters() {
*/
@Test
void adaptersShouldNotDependOnServiceImplementations() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DependencyDirectionTest.adaptersShouldNotDependOnServiceImplementations"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
noClasses()
.that().resideInAnyPackage(RulePackConfiguration.adapters())
.should().dependOnClassesThat().resideInAnyPackage(RulePackConfiguration.applicationServices())
@@ -78,6 +87,10 @@ void adaptersShouldNotDependOnServiceImplementations() {
*/
@Test
void onlyConfigurationMayDependOnServiceImplementations() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DependencyDirectionTest.onlyConfigurationMayDependOnServiceImplementations"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
noClasses()
.that().resideOutsideOfPackage("..configuration..")
.and().resideOutsideOfPackage("..application.domain.service..")
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyInjectionStyleTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyInjectionStyleTest.java
new file mode 100644
index 0000000..0f5ebde
--- /dev/null
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DependencyInjectionStyleTest.java
@@ -0,0 +1,57 @@
+package com.arc_e_tect.gradle.architecture.spring;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Test;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noFields;
+
+/**
+ * Dependency injection style validation rules for Hexagonal architecture.
+ *
+ *
This rule class enforces constructor-injection-friendly design by forbidding
+ * Spring field injection annotations in core application and adapter layers.
+ *
+ *
This class is discovered and included in the rule-pack suite by the Architecture Validator
+ * plugin. Each test method defines a separate validation rule.
+ *
+ * @see RulePackConfiguration
+ * @since 0.4.0
+ */
+class DependencyInjectionStyleTest {
+
+ private final JavaClasses classes = new ClassFileImporter()
+ .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+ .importPackages(RulePackConfiguration.basePackage());
+
+ private String[] targetPackages() {
+ return RulePackConfiguration.merge(
+ RulePackConfiguration.domainModel(),
+ RulePackConfiguration.merge(
+ RulePackConfiguration.adapters(),
+ RulePackConfiguration.applicationServices())
+ );
+ }
+
+ /**
+ * Validates that classes in core and adapter layers do not use field injection.
+ *
+ *
Field injection hides required dependencies and makes classes harder to test in isolation.
+ * Constructor injection keeps dependencies explicit and supports framework-agnostic design.
+ */
+ @Test
+ void fieldsShouldNotBeAutowired() {
+ noFields()
+ .that().areDeclaredInClassesThat().resideInAnyPackage(targetPackages())
+ .should().beAnnotatedWith("org.springframework.beans.factory.annotation.Autowired")
+ .because("Constructor injection keeps dependencies explicit and testable without a Spring context")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+}
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DomainIsolationTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DomainIsolationTest.java
index e6430e1..8ee464f 100644
--- a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DomainIsolationTest.java
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/DomainIsolationTest.java
@@ -3,6 +3,7 @@
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
@@ -43,11 +44,22 @@ class DomainIsolationTest {
*/
@Test
void domainModelShouldOnlyDependOnJavaCoreAndDomainModel() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DomainIsolationTest.domainModelShouldOnlyDependOnJavaCoreAndDomainModel"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().resideInAnyPackage(RulePackConfiguration.domainModel())
.should().onlyDependOnClassesThat()
.resideInAnyPackage(RulePackConfiguration.merge(
RulePackConfiguration.domainModel(),
+ "java.util..",
+ "java.lang..",
+ "java.time.."))
+ .because("Domain model classes must stay framework free")
+ .check(classes);
+ }
+
/**
* Validates that the core application layer has no Spring or persistence framework dependencies.
*
@@ -56,15 +68,12 @@ void domainModelShouldOnlyDependOnJavaCoreAndDomainModel() {
* This ensures the business logic remains framework-agnostic and can be evolved
* independently of infrastructure choices.
*/
- "java.util..",
- "java.lang..",
- "java.time.."))
- .because("Domain model classes must stay framework free")
- .check(classes);
- }
-
@Test
void coreApplicationLayerShouldHaveNoFrameworkDependencies() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DomainIsolationTest.coreApplicationLayerShouldHaveNoFrameworkDependencies"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
noClasses()
.that().resideInAnyPackage(RulePackConfiguration.domainModel())
.should().dependOnClassesThat()
@@ -89,6 +98,10 @@ void coreApplicationLayerShouldHaveNoFrameworkDependencies() {
*/
@Test
void applicationServicesShouldNotCarrySpringStereotypes() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("DomainIsolationTest.applicationServicesShouldNotCarrySpringStereotypes"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
noClasses()
.that().resideInAnyPackage(RulePackConfiguration.applicationServices())
.should().beAnnotatedWith("org.springframework.stereotype.Service")
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/NamingConventionTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/NamingConventionTest.java
new file mode 100644
index 0000000..0b2d905
--- /dev/null
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/NamingConventionTest.java
@@ -0,0 +1,108 @@
+package com.arc_e_tect.gradle.architecture.spring;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.Test;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+
+/**
+ * Optional naming convention validation rules for Spring Hexagonal architecture.
+ *
+ *
This rule class enforces naming suffix conventions for ports and adapters to keep
+ * architectural roles obvious in code review and IDE navigation.
+ *
+ *
This class is discovered and included in the rule-pack suite by the Architecture Validator
+ * plugin. Each test method defines a separate validation rule.
+ *
+ * @see RulePackConfiguration
+ * @since 0.4.0
+ */
+class NamingConventionTest {
+
+ private static final String OPT_IN_MESSAGE = "Naming convention rules are opt-in; set architectureValidator.namingConventions.enabled=true to activate";
+
+ private final JavaClasses classes = new ClassFileImporter()
+ .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+ .importPackages(RulePackConfiguration.basePackage());
+
+ /**
+ * Validates that in-port types use a consistent role suffix.
+ *
+ *
Using {@code UseCase} or {@code Port} suffixes makes inbound application
+ * contracts instantly recognizable and reinforces Hexagonal boundaries.
+ */
+ @Test
+ void inputPortsShouldHaveConsistentSuffix() {
+ Assumptions.assumeTrue(RulePackConfiguration.namingConventionsEnabled(), OPT_IN_MESSAGE);
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.inPorts())
+ .should().haveNameMatching(".*UseCase$")
+ .orShould().haveNameMatching(".*Port$")
+ .because("Consistent in-port naming makes application entry-point contracts explicit")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+
+ /**
+ * Validates that out-port types end with {@code Port}.
+ *
+ *
A stable suffix for outbound contracts clarifies that adapter implementations
+ * are behind an abstraction owned by the application core.
+ */
+ @Test
+ void outputPortsShouldHaveConsistentSuffix() {
+ Assumptions.assumeTrue(RulePackConfiguration.namingConventionsEnabled(), OPT_IN_MESSAGE);
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.outPorts())
+ .should().haveSimpleNameEndingWith("Port")
+ .because("Consistent out-port naming keeps infrastructure boundaries self-documenting")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+
+ /**
+ * Validates that adapter stereotypes use role-aligned suffixes.
+ *
+ *
Repository stereotypes should read as repository/adapter implementations,
+ * and web controllers should read as controller entry points.
+ */
+ @Test
+ void adaptersShouldHaveConsistentSuffix() {
+ Assumptions.assumeTrue(RulePackConfiguration.namingConventionsEnabled(), OPT_IN_MESSAGE);
+
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.adapters())
+ .and().areAnnotatedWith("org.springframework.stereotype.Repository")
+ .should().haveSimpleNameEndingWith("Repository")
+ .orShould().haveSimpleNameEndingWith("Adapter")
+ .because("Repository adapters should use repository-oriented suffixes to signal their role")
+ .allowEmptyShould(true)
+ .check(classes);
+
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.adapters())
+ .and().areAnnotatedWith("org.springframework.web.bind.annotation.RestController")
+ .should().haveSimpleNameEndingWith("Controller")
+ .because("Web adapters should use Controller suffixes to make request-entry components obvious")
+ .allowEmptyShould(true)
+ .check(classes);
+
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.adapters())
+ .and().areAnnotatedWith("org.springframework.stereotype.Controller")
+ .should().haveSimpleNameEndingWith("Controller")
+ .because("Web adapters should use Controller suffixes to make request-entry components obvious")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+}
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/PortContractTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/PortContractTest.java
index 49062a6..0daf099 100644
--- a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/PortContractTest.java
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/PortContractTest.java
@@ -3,6 +3,7 @@
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
@@ -43,6 +44,10 @@ class PortContractTest {
*/
@Test
void inputPortsShouldBeInterfaces() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("PortContractTest.inputPortsShouldBeInterfaces"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().resideInAnyPackage(RulePackConfiguration.inPorts())
.should().beInterfaces()
@@ -61,6 +66,10 @@ void inputPortsShouldBeInterfaces() {
*/
@Test
void outputPortsShouldBeInterfaces() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("PortContractTest.outputPortsShouldBeInterfaces"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().resideInAnyPackage(RulePackConfiguration.outPorts())
.should().beInterfaces()
@@ -79,6 +88,10 @@ void outputPortsShouldBeInterfaces() {
*/
@Test
void portsShouldOnlyDependOnJavaCoreAndDomainModel() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("PortContractTest.portsShouldOnlyDependOnJavaCoreAndDomainModel"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().resideInAnyPackage(RulePackConfiguration.inPorts())
.or().resideInAnyPackage(RulePackConfiguration.outPorts())
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfiguration.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfiguration.java
index 31ed607..377da98 100644
--- a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfiguration.java
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfiguration.java
@@ -2,6 +2,7 @@
import java.util.Arrays;
import java.util.List;
+import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -19,8 +20,12 @@
*
disabledRules() {
+ return Arrays.stream(property("architectureValidator.rules.disabled", "").split(","))
+ .map(String::trim)
+ .filter(value -> !value.isEmpty())
+ .collect(Collectors.toSet());
+ }
}
\ No newline at end of file
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfigurationTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfigurationTest.java
new file mode 100644
index 0000000..5043068
--- /dev/null
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/RulePackConfigurationTest.java
@@ -0,0 +1,24 @@
+package com.arc_e_tect.gradle.architecture.spring;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Fail-fast configuration validation for the Spring rule pack.
+ *
+ * This rule ensures the consuming project configures the minimum
+ * Architecture Validator properties so architecture checks do not pass
+ * vacuously with empty class imports.
+ *
+ * @see RulePackConfiguration
+ * @since 1.0.0
+ */
+class RulePackConfigurationTest {
+
+ /**
+ * Validates that required architecture properties are configured.
+ */
+ @Test
+ void requiredArchitecturePropertiesShouldBeConfigured() {
+ RulePackConfiguration.requireConfigured();
+ }
+}
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/SpringHexagonalArchitectureTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/SpringHexagonalArchitectureTest.java
index 43a5ef9..8618355 100644
--- a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/SpringHexagonalArchitectureTest.java
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/SpringHexagonalArchitectureTest.java
@@ -3,9 +3,11 @@
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
/**
* Spring Hexagonal architecture validation rules.
@@ -56,6 +58,10 @@ private String[] mergeAll(String[] first, String[] second, String... fixed) {
*/
@Test
void controllersShouldOnlyCallInPorts() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("SpringHexagonalArchitectureTest.controllersShouldOnlyCallInPorts"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().areAnnotatedWith("org.springframework.stereotype.Controller")
.or().areAnnotatedWith("org.springframework.web.bind.annotation.RestController")
@@ -71,22 +77,27 @@ void controllersShouldOnlyCallInPorts() {
/**
* Validates that Spring services do not directly access repositories or adapters.
- *
+ *
*
Services must communicate with external systems through out-ports only.
* Direct repository access couples the business logic to persistence details
* and prevents flexibility in choosing adapter implementations.
+ *
+ *
This is a deny-list check on the adapter packages specifically, rather than an
+ * allow-list of every legitimate dependency: a {@code @Service} implementing its own
+ * in-port (the standard Hexagonal pattern) is a real dependency ArchUnit can see, and an
+ * allow-list would have to special-case it. The actual concern is adapter/repository
+ * access, so only that is checked.
*/
@Test
void servicesShouldNotAccessRepositoriesDirectly() {
- classes()
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("SpringHexagonalArchitectureTest.servicesShouldNotAccessRepositoriesDirectly"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
+ noClasses()
.that().areAnnotatedWith("org.springframework.stereotype.Service")
- .should().onlyDependOnClassesThat()
- .resideInAnyPackage(mergeAll(
- RulePackConfiguration.outPorts(),
- RulePackConfiguration.applicationServices(),
- RulePackConfiguration.domainModel(),
- "java..",
- "org.springframework.."))
+ .should().dependOnClassesThat()
+ .resideInAnyPackage(RulePackConfiguration.adapters())
.because("Spring services should not access repositories directly; use out-ports instead")
.allowEmptyShould(true)
.check(classes);
@@ -101,6 +112,10 @@ void servicesShouldNotAccessRepositoriesDirectly() {
*/
@Test
void repositoriesShouldOnlyBeAccessedViaOutPorts() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("SpringHexagonalArchitectureTest.repositoriesShouldOnlyBeAccessedViaOutPorts"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().areAnnotatedWith("org.springframework.stereotype.Repository")
.should().onlyBeAccessed().byClassesThat()
@@ -122,6 +137,10 @@ void repositoriesShouldOnlyBeAccessedViaOutPorts() {
*/
@Test
void springComponentsShouldFollowHexagonalLayers() {
+ Assumptions.assumeFalse(
+ RulePackConfiguration.isRuleDisabled("SpringHexagonalArchitectureTest.springComponentsShouldFollowHexagonalLayers"),
+ "Rule disabled via architectureValidator.rules.disabled"
+ );
classes()
.that().areAnnotatedWith("org.springframework.stereotype.Component")
.or().areAnnotatedWith("org.springframework.stereotype.Service")
diff --git a/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/TypeLeakageTest.java b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/TypeLeakageTest.java
new file mode 100644
index 0000000..b32cc44
--- /dev/null
+++ b/hexagonal-spring-rules/src/main/java/com/arc_e_tect/gradle/architecture/spring/TypeLeakageTest.java
@@ -0,0 +1,166 @@
+package com.arc_e_tect.gradle.architecture.spring;
+
+import com.tngtech.archunit.core.domain.Dependency;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.domain.JavaMethod;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.lang.ArchCondition;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.SimpleConditionEvent;
+import org.junit.jupiter.api.Test;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+
+/**
+ * Type leakage validation rules for Spring Hexagonal architecture.
+ *
+ *
This rule class enforces that persistence and web transport details do not leak
+ * into ports or the domain model. Ports and the core model must depend on stable
+ * business types, not JPA entities or web DTOs.
+ *
+ *
Rules validate:
+ *
+ * - In-ports and out-ports do not expose JPA entities
+ * - Domain model does not reference JPA entities
+ * - Ports do not expose web DTO-style types
+ *
+ *
+ * This class is discovered and included in the rule-pack suite by the Architecture Validator
+ * plugin. Each test method defines a separate validation rule.
+ *
+ * @see RulePackConfiguration
+ * @since 1.0.0
+ */
+class TypeLeakageTest {
+
+ private static final String JAKARTA_ENTITY = "jakarta.persistence.Entity";
+ private static final String JAVAX_ENTITY = "javax.persistence.Entity";
+
+ private final JavaClasses classes = new ClassFileImporter()
+ .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+ .importPackages(RulePackConfiguration.basePackage());
+
+ /**
+ * Validates that ports do not expose JPA entity types.
+ *
+ *
Ports define application contracts and must stay persistence-agnostic.
+ * Referencing JPA entities in port contracts leaks adapter concerns into
+ * the application boundary and couples core use cases to persistence models.
+ */
+ @Test
+ void portsShouldNotExposeJpaEntities() {
+ methods()
+ .that().areDeclaredInClassesThat().resideInAnyPackage(RulePackConfiguration.inPorts())
+ .or().areDeclaredInClassesThat().resideInAnyPackage(RulePackConfiguration.outPorts())
+ .should(notExposeJpaEntityTypesInMethodSignatures())
+ .because("Ports must not expose JPA entity types; use domain model contracts instead")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+
+ /**
+ * Validates that domain model types do not reference JPA entities.
+ *
+ *
The domain model must remain persistence-independent so business
+ * behavior can evolve independently from ORM mappings and storage concerns.
+ */
+ @Test
+ void domainModelShouldNotReferenceJpaEntities() {
+ classes()
+ .that().resideInAnyPackage(RulePackConfiguration.domainModel())
+ .should(notDependOnJpaEntityTypes())
+ .because("Domain model must not depend on JPA entity types")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+
+ /**
+ * Validates that ports do not expose web DTO/request/response transport types.
+ *
+ *
Port contracts should model business interactions, not HTTP transport payloads.
+ * Using web DTO packages in ports leaks adapter concerns into the application core.
+ */
+ @Test
+ void portsShouldNotExposeWebDtos() {
+ methods()
+ .that().areDeclaredInClassesThat().resideInAnyPackage(RulePackConfiguration.inPorts())
+ .or().areDeclaredInClassesThat().resideInAnyPackage(RulePackConfiguration.outPorts())
+ .should(notExposeWebDtoTypesInMethodSignatures())
+ .because("Ports must not expose web transport DTOs; map them at adapter boundaries")
+ .allowEmptyShould(true)
+ .check(classes);
+ }
+
+ private static ArchCondition notExposeJpaEntityTypesInMethodSignatures() {
+ return new ArchCondition<>("not expose JPA entity types in method signatures") {
+ @Override
+ public void check(JavaMethod method, ConditionEvents events) {
+ verifySignatureTypeIsNotJpaEntity(method, method.getRawReturnType(), "return type", events);
+ method.getRawParameterTypes().forEach(parameterType ->
+ verifySignatureTypeIsNotJpaEntity(method, parameterType, "parameter type", events));
+ }
+ };
+ }
+
+ private static ArchCondition notDependOnJpaEntityTypes() {
+ return new ArchCondition<>("not depend on JPA entity types") {
+ @Override
+ public void check(JavaClass javaClass, ConditionEvents events) {
+ for (Dependency dependency : javaClass.getDirectDependenciesFromSelf()) {
+ JavaClass targetClass = dependency.getTargetClass();
+ if (isJpaEntityType(targetClass)) {
+ events.add(SimpleConditionEvent.violated(
+ javaClass,
+ javaClass.getName() + " depends on JPA entity type " + targetClass.getName()));
+ }
+ }
+ }
+ };
+ }
+
+ private static ArchCondition notExposeWebDtoTypesInMethodSignatures() {
+ return new ArchCondition<>("not expose web DTO types in method signatures") {
+ @Override
+ public void check(JavaMethod method, ConditionEvents events) {
+ verifySignatureTypeIsNotWebDto(method, method.getRawReturnType(), "return type", events);
+ method.getRawParameterTypes().forEach(parameterType ->
+ verifySignatureTypeIsNotWebDto(method, parameterType, "parameter type", events));
+ }
+ };
+ }
+
+ private static void verifySignatureTypeIsNotJpaEntity(JavaMethod method, JavaClass signatureType, String role, ConditionEvents events) {
+ if (isJpaEntityType(signatureType)) {
+ events.add(SimpleConditionEvent.violated(
+ method,
+ method.getOwner().getName() + "#" + method.getName() + " exposes JPA entity "
+ + signatureType.getName() + " as " + role));
+ }
+ }
+
+ private static void verifySignatureTypeIsNotWebDto(JavaMethod method, JavaClass signatureType, String role, ConditionEvents events) {
+ if (isWebDtoType(signatureType)) {
+ events.add(SimpleConditionEvent.violated(
+ method,
+ method.getOwner().getName() + "#" + method.getName() + " exposes web DTO type "
+ + signatureType.getName() + " as " + role));
+ }
+ }
+
+ private static boolean isJpaEntityType(JavaClass javaClass) {
+ return javaClass.getAnnotations().stream()
+ .map(annotation -> annotation.getRawType().getName())
+ .anyMatch(annotationName -> JAKARTA_ENTITY.equals(annotationName) || JAVAX_ENTITY.equals(annotationName));
+ }
+
+ private static boolean isWebDtoType(JavaClass javaClass) {
+ String typeName = javaClass.getName().toLowerCase();
+ return typeName.contains(".web.")
+ && (typeName.contains(".dto.")
+ || typeName.contains(".request.")
+ || typeName.contains(".response."));
+ }
+}
diff --git a/hexagonal-spring-rules/src/test/java/com/arc_e_tect/gradle/architecture/spring/RulePackSelfTest.java b/hexagonal-spring-rules/src/test/java/com/arc_e_tect/gradle/architecture/spring/RulePackSelfTest.java
new file mode 100644
index 0000000..2a73e40
--- /dev/null
+++ b/hexagonal-spring-rules/src/test/java/com/arc_e_tect/gradle/architecture/spring/RulePackSelfTest.java
@@ -0,0 +1,466 @@
+package com.arc_e_tect.gradle.architecture.spring;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Self-tests for the Spring Hexagonal rule pack.
+ *
+ * This test suite executes rule classes against in-repo fixture packages to prove
+ * that compliant structures pass while targeted violations fail.
+ *
+ * @since 0.4.0
+ */
+class RulePackSelfTest {
+
+ private static final String BASE_PACKAGE_KEY = "architectureValidator.basePackage";
+ private static final String IN_PORTS_KEY = "architectureValidator.inPorts";
+ private static final String OUT_PORTS_KEY = "architectureValidator.outPorts";
+ private static final String DOMAIN_MODEL_KEY = "architectureValidator.domainModel";
+ private static final String ADAPTERS_KEY = "architectureValidator.adapters";
+ private static final String INBOUND_ADAPTERS_KEY = "architectureValidator.inboundAdapters";
+ private static final String OUTBOUND_ADAPTERS_KEY = "architectureValidator.outboundAdapters";
+ private static final String APPLICATION_SERVICES_KEY = "architectureValidator.applicationServices";
+
+ private static final String COMPLIANT_BASE = "com.arc_e_tect.fixtures.compliant";
+ private static final String SERVICE_IMPLEMENTS_PORT_BASE = "com.arc_e_tect.fixtures.regression.serviceImplementsPort";
+
+ private static final String SPRING_CONTROLLERS_BASE = "com.arc_e_tect.fixtures.violating.spring.controllers";
+ private static final String SPRING_SERVICES_BASE = "com.arc_e_tect.fixtures.violating.spring.services";
+ private static final String SPRING_REPOSITORIES_BASE = "com.arc_e_tect.fixtures.violating.spring.repositories";
+ private static final String SPRING_COMPONENTS_BASE = "com.arc_e_tect.fixtures.violating.spring.components";
+
+ private static final String DOMAIN_DEPENDENCY_BASE = "com.arc_e_tect.fixtures.violating.domain.domainDependency";
+ private static final String DOMAIN_FRAMEWORK_BASE = "com.arc_e_tect.fixtures.violating.domain.frameworkDependency";
+ private static final String DOMAIN_SERVICE_STEREOTYPE_BASE = "com.arc_e_tect.fixtures.violating.domain.applicationServiceStereotype";
+
+ private static final String DEPENDENCY_CORE_BASE = "com.arc_e_tect.fixtures.violating.dependency.coreDependsOnAdapter";
+ private static final String DEPENDENCY_ADAPTER_BASE = "com.arc_e_tect.fixtures.violating.dependency.adapterDependsOnService";
+ private static final String DEPENDENCY_NON_CONFIG_BASE = "com.arc_e_tect.fixtures.violating.dependency.nonConfigDependsOnService";
+
+ private static final String PORT_INPUT_BASE = "com.arc_e_tect.fixtures.violating.port.inputNotInterface";
+ private static final String PORT_OUTPUT_BASE = "com.arc_e_tect.fixtures.violating.port.outputNotInterface";
+ private static final String PORT_SIGNATURE_BASE = "com.arc_e_tect.fixtures.violating.port.signatureLeak";
+
+ private static final String CYCLE_BASE = "com.arc_e_tect.fixtures.violating.cycle";
+
+ private final Map originalProperties = new HashMap<>();
+
+ @BeforeEach
+ void captureOriginalArchitectureProperties() {
+ capture(BASE_PACKAGE_KEY);
+ capture(IN_PORTS_KEY);
+ capture(OUT_PORTS_KEY);
+ capture(DOMAIN_MODEL_KEY);
+ capture(ADAPTERS_KEY);
+ capture(INBOUND_ADAPTERS_KEY);
+ capture(OUTBOUND_ADAPTERS_KEY);
+ capture(APPLICATION_SERVICES_KEY);
+ }
+
+ @AfterEach
+ void restoreOriginalArchitectureProperties() {
+ restore(BASE_PACKAGE_KEY);
+ restore(IN_PORTS_KEY);
+ restore(OUT_PORTS_KEY);
+ restore(DOMAIN_MODEL_KEY);
+ restore(ADAPTERS_KEY);
+ restore(INBOUND_ADAPTERS_KEY);
+ restore(OUTBOUND_ADAPTERS_KEY);
+ restore(APPLICATION_SERVICES_KEY);
+ }
+
+ @Test
+ void rulePackShouldPassAllCoreRulesWhenFixturesAreCompliant() {
+ configure(
+ COMPLIANT_BASE,
+ COMPLIANT_BASE + ".application.port.inbound..",
+ COMPLIANT_BASE + ".application.port.outbound..",
+ COMPLIANT_BASE + ".domain.model..",
+ COMPLIANT_BASE + ".adapters.web..," + COMPLIANT_BASE + ".adapters.persistence..",
+ COMPLIANT_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest springRules = new SpringHexagonalArchitectureTest();
+ DomainIsolationTest domainRules = new DomainIsolationTest();
+ DependencyDirectionTest dependencyRules = new DependencyDirectionTest();
+ PortContractTest portRules = new PortContractTest();
+
+ CycleFreedomTest cycleRules = new CycleFreedomTest();
+
+ assertAll(
+ () -> assertDoesNotThrow(springRules::controllersShouldOnlyCallInPorts),
+ () -> assertDoesNotThrow(springRules::servicesShouldNotAccessRepositoriesDirectly),
+ () -> assertDoesNotThrow(springRules::repositoriesShouldOnlyBeAccessedViaOutPorts),
+ () -> assertDoesNotThrow(springRules::springComponentsShouldFollowHexagonalLayers),
+ () -> assertDoesNotThrow(domainRules::domainModelShouldOnlyDependOnJavaCoreAndDomainModel),
+ () -> assertDoesNotThrow(domainRules::coreApplicationLayerShouldHaveNoFrameworkDependencies),
+ () -> assertDoesNotThrow(domainRules::applicationServicesShouldNotCarrySpringStereotypes),
+ () -> assertDoesNotThrow(dependencyRules::coreApplicationLayerShouldNotDependOnAdapters),
+ () -> assertDoesNotThrow(dependencyRules::adaptersShouldNotDependOnServiceImplementations),
+ () -> assertDoesNotThrow(dependencyRules::onlyConfigurationMayDependOnServiceImplementations),
+ () -> assertDoesNotThrow(portRules::inputPortsShouldBeInterfaces),
+ () -> assertDoesNotThrow(portRules::outputPortsShouldBeInterfaces),
+ () -> assertDoesNotThrow(portRules::portsShouldOnlyDependOnJavaCoreAndDomainModel),
+ () -> assertDoesNotThrow(cycleRules::adapterPackagesShouldBeFreeOfCycles),
+ () -> assertDoesNotThrow(cycleRules::domainModelShouldBeFreeOfCycles)
+ );
+ }
+
+ @Test
+ void springHexagonalArchitectureShouldPassServicesRuleWhenServiceImplementsItsOwnInPort() {
+ configure(
+ SERVICE_IMPLEMENTS_PORT_BASE,
+ SERVICE_IMPLEMENTS_PORT_BASE + ".application.port.inbound..",
+ SERVICE_IMPLEMENTS_PORT_BASE + ".application.port.outbound..",
+ SERVICE_IMPLEMENTS_PORT_BASE + ".domain.model..",
+ SERVICE_IMPLEMENTS_PORT_BASE + ".adapters..",
+ SERVICE_IMPLEMENTS_PORT_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest rules = new SpringHexagonalArchitectureTest();
+
+ // Regression test: a @Service implementing its own in-port (the standard Hexagonal
+ // pattern) must not be flagged as reaching into a repository/adapter merely because
+ // interface implementation is itself a dependency ArchUnit can see. Previously this
+ // rule used an allow-list that omitted in-ports, so this exact case failed.
+ assertDoesNotThrow(rules::servicesShouldNotAccessRepositoriesDirectly);
+ }
+
+ @Test
+ void cycleFreedomTestShouldFailAdapterRuleWhenAdapterPackagesFormACycle() {
+ configure(
+ CYCLE_BASE,
+ CYCLE_BASE + ".application.port.inbound..",
+ CYCLE_BASE + ".application.port.outbound..",
+ CYCLE_BASE + ".domain.model..",
+ // Deliberately a floating "..X.." wildcard, not anchored to CYCLE_BASE like the
+ // other fixture configuration in this file: this matches how the real Architecture
+ // Validator plugin sends its default adapters pattern (e.g. "..adapter..",
+ // "..adapters.."). An anchored, fully-qualified value would not exercise the
+ // leading-".." handling this test is targeting.
+ "..adapters..",
+ CYCLE_BASE + ".application.service.."
+ );
+
+ CycleFreedomTest rules = new CycleFreedomTest();
+
+ // Regression test for a bug where CycleFreedomTest stripped the leading ".." from
+ // configured package roots before building the ArchUnit slice pattern, anchoring it to
+ // the start of the fully-qualified class name so nested packages (the normal case, as
+ // exercised here by a base package several segments deep) never matched and the check
+ // passed vacuously regardless of real cycles.
+ assertThrows(AssertionError.class, rules::adapterPackagesShouldBeFreeOfCycles);
+ }
+
+ @Test
+ void springHexagonalArchitectureShouldFailControllersRuleWhenControllerDependsOnService() {
+ configure(
+ SPRING_CONTROLLERS_BASE,
+ SPRING_CONTROLLERS_BASE + ".application.port.inbound..",
+ SPRING_CONTROLLERS_BASE + ".application.port.outbound..",
+ SPRING_CONTROLLERS_BASE + ".domain.model..",
+ SPRING_CONTROLLERS_BASE + ".adapters..",
+ SPRING_CONTROLLERS_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest rules = new SpringHexagonalArchitectureTest();
+
+ assertThrows(AssertionError.class, rules::controllersShouldOnlyCallInPorts);
+ assertDoesNotThrow(rules::servicesShouldNotAccessRepositoriesDirectly);
+ assertDoesNotThrow(rules::repositoriesShouldOnlyBeAccessedViaOutPorts);
+ assertDoesNotThrow(rules::springComponentsShouldFollowHexagonalLayers);
+ }
+
+ @Test
+ void springHexagonalArchitectureShouldFailServicesRuleWhenServiceDependsOnRepository() {
+ configure(
+ SPRING_SERVICES_BASE,
+ SPRING_SERVICES_BASE + ".application.port.inbound..",
+ SPRING_SERVICES_BASE + ".application.port.outbound..",
+ SPRING_SERVICES_BASE + ".domain.model..",
+ SPRING_SERVICES_BASE + ".adapters..",
+ SPRING_SERVICES_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest rules = new SpringHexagonalArchitectureTest();
+
+ assertDoesNotThrow(rules::controllersShouldOnlyCallInPorts);
+ assertThrows(AssertionError.class, rules::servicesShouldNotAccessRepositoriesDirectly);
+ assertDoesNotThrow(rules::repositoriesShouldOnlyBeAccessedViaOutPorts);
+ assertDoesNotThrow(rules::springComponentsShouldFollowHexagonalLayers);
+ }
+
+ @Test
+ void springHexagonalArchitectureShouldFailRepositoryAccessRuleWhenRepositoryIsUsedOutsideAllowedLayers() {
+ configure(
+ SPRING_REPOSITORIES_BASE,
+ SPRING_REPOSITORIES_BASE + ".application.port.inbound..",
+ SPRING_REPOSITORIES_BASE + ".application.port.outbound..",
+ SPRING_REPOSITORIES_BASE + ".domain.model..",
+ SPRING_REPOSITORIES_BASE + ".adapters..",
+ SPRING_REPOSITORIES_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest rules = new SpringHexagonalArchitectureTest();
+
+ assertDoesNotThrow(rules::controllersShouldOnlyCallInPorts);
+ assertDoesNotThrow(rules::servicesShouldNotAccessRepositoriesDirectly);
+ assertThrows(AssertionError.class, rules::repositoriesShouldOnlyBeAccessedViaOutPorts);
+ assertDoesNotThrow(rules::springComponentsShouldFollowHexagonalLayers);
+ }
+
+ @Test
+ void springHexagonalArchitectureShouldFailComponentLayerRuleWhenComponentIsOutsideHexagonalPackages() {
+ configure(
+ SPRING_COMPONENTS_BASE,
+ SPRING_COMPONENTS_BASE + ".application.port.inbound..",
+ SPRING_COMPONENTS_BASE + ".application.port.outbound..",
+ SPRING_COMPONENTS_BASE + ".domain.model..",
+ SPRING_COMPONENTS_BASE + ".adapters..",
+ SPRING_COMPONENTS_BASE + ".application.service.."
+ );
+
+ SpringHexagonalArchitectureTest rules = new SpringHexagonalArchitectureTest();
+
+ assertDoesNotThrow(rules::controllersShouldOnlyCallInPorts);
+ assertDoesNotThrow(rules::servicesShouldNotAccessRepositoriesDirectly);
+ assertDoesNotThrow(rules::repositoriesShouldOnlyBeAccessedViaOutPorts);
+ assertThrows(AssertionError.class, rules::springComponentsShouldFollowHexagonalLayers);
+ }
+
+ @Test
+ void domainIsolationShouldFailDomainDependencyRuleWhenDomainDependsOnPortContract() {
+ configure(
+ DOMAIN_DEPENDENCY_BASE,
+ DOMAIN_DEPENDENCY_BASE + ".application.port.inbound..",
+ DOMAIN_DEPENDENCY_BASE + ".application.port.outbound..",
+ DOMAIN_DEPENDENCY_BASE + ".domain.model..",
+ DOMAIN_DEPENDENCY_BASE + ".adapters..",
+ DOMAIN_DEPENDENCY_BASE + ".application.service.."
+ );
+
+ DomainIsolationTest rules = new DomainIsolationTest();
+
+ assertThrows(AssertionError.class, rules::domainModelShouldOnlyDependOnJavaCoreAndDomainModel);
+ assertDoesNotThrow(rules::coreApplicationLayerShouldHaveNoFrameworkDependencies);
+ assertDoesNotThrow(rules::applicationServicesShouldNotCarrySpringStereotypes);
+ }
+
+ @Test
+ void domainIsolationShouldFailFrameworkDependencyRuleWhenDomainUsesSpringTypes() {
+ configure(
+ DOMAIN_FRAMEWORK_BASE,
+ DOMAIN_FRAMEWORK_BASE + ".application.port.inbound..",
+ DOMAIN_FRAMEWORK_BASE + ".application.port.outbound..",
+ DOMAIN_FRAMEWORK_BASE + ".domain.model..",
+ DOMAIN_FRAMEWORK_BASE + ".adapters..",
+ DOMAIN_FRAMEWORK_BASE + ".application.service.."
+ );
+
+ DomainIsolationTest baselineRules = new DomainIsolationTest();
+ assertDoesNotThrow(baselineRules::domainModelShouldOnlyDependOnJavaCoreAndDomainModel);
+ assertDoesNotThrow(baselineRules::applicationServicesShouldNotCarrySpringStereotypes);
+
+ configure(
+ DOMAIN_FRAMEWORK_BASE,
+ DOMAIN_FRAMEWORK_BASE + ".application.port.inbound..",
+ DOMAIN_FRAMEWORK_BASE + ".application.port.outbound..",
+ DOMAIN_FRAMEWORK_BASE + ".domain.framework..",
+ DOMAIN_FRAMEWORK_BASE + ".adapters..",
+ DOMAIN_FRAMEWORK_BASE + ".application.service.."
+ );
+
+ DomainIsolationTest violatingRules = new DomainIsolationTest();
+
+ assertThrows(AssertionError.class, violatingRules::coreApplicationLayerShouldHaveNoFrameworkDependencies);
+ assertDoesNotThrow(violatingRules::applicationServicesShouldNotCarrySpringStereotypes);
+ }
+
+ @Test
+ void domainIsolationShouldFailServiceStereotypeRuleWhenApplicationServiceIsAnnotatedWithService() {
+ configure(
+ DOMAIN_SERVICE_STEREOTYPE_BASE,
+ DOMAIN_SERVICE_STEREOTYPE_BASE + ".application.port.inbound..",
+ DOMAIN_SERVICE_STEREOTYPE_BASE + ".application.port.outbound..",
+ DOMAIN_SERVICE_STEREOTYPE_BASE + ".domain.model..",
+ DOMAIN_SERVICE_STEREOTYPE_BASE + ".adapters..",
+ DOMAIN_SERVICE_STEREOTYPE_BASE + ".application.service.."
+ );
+
+ DomainIsolationTest rules = new DomainIsolationTest();
+
+ assertDoesNotThrow(rules::domainModelShouldOnlyDependOnJavaCoreAndDomainModel);
+ assertDoesNotThrow(rules::coreApplicationLayerShouldHaveNoFrameworkDependencies);
+ assertThrows(AssertionError.class, rules::applicationServicesShouldNotCarrySpringStereotypes);
+ }
+
+ @Test
+ void dependencyDirectionShouldFailCoreRuleWhenCoreDependsOnAdapters() {
+ configure(
+ DEPENDENCY_CORE_BASE,
+ DEPENDENCY_CORE_BASE + ".application.port.inbound..",
+ DEPENDENCY_CORE_BASE + ".application.port.outbound..",
+ DEPENDENCY_CORE_BASE + ".domain.model..",
+ DEPENDENCY_CORE_BASE + ".adapters..",
+ DEPENDENCY_CORE_BASE + ".application.service.."
+ );
+
+ DependencyDirectionTest rules = new DependencyDirectionTest();
+
+ assertThrows(AssertionError.class, rules::coreApplicationLayerShouldNotDependOnAdapters);
+ assertDoesNotThrow(rules::adaptersShouldNotDependOnServiceImplementations);
+ assertDoesNotThrow(rules::onlyConfigurationMayDependOnServiceImplementations);
+ }
+
+ @Test
+ void dependencyDirectionShouldFailCoreRuleWhenOnlySplitAdapterPropertiesAreConfigured() {
+ configure(
+ DEPENDENCY_CORE_BASE,
+ DEPENDENCY_CORE_BASE + ".application.port.inbound..",
+ DEPENDENCY_CORE_BASE + ".application.port.outbound..",
+ DEPENDENCY_CORE_BASE + ".domain.model..",
+ "",
+ DEPENDENCY_CORE_BASE + ".application.service.."
+ );
+ // Deliberately leave the legacy ADAPTERS_KEY empty (set above) and only configure the
+ // split inboundAdapters property, mirroring a consumer who follows the Architecture
+ // Validator plugin's preferred split layout without also setting the legacy aggregate.
+ System.setProperty(INBOUND_ADAPTERS_KEY, DEPENDENCY_CORE_BASE + ".adapters..");
+ System.setProperty(OUTBOUND_ADAPTERS_KEY, "");
+
+ DependencyDirectionTest rules = new DependencyDirectionTest();
+
+ // Regression test: RulePackConfiguration.adapters() must also honor inboundAdapters/
+ // outboundAdapters, not only the legacy aggregate architectureValidator.adapters
+ // property; otherwise this violation would pass vacuously for split-layout consumers.
+ assertThrows(AssertionError.class, rules::coreApplicationLayerShouldNotDependOnAdapters);
+ }
+
+ @Test
+ void dependencyDirectionShouldFailAdapterRuleWhenAdapterDependsOnServiceImplementation() {
+ configure(
+ DEPENDENCY_ADAPTER_BASE,
+ DEPENDENCY_ADAPTER_BASE + ".application.port.inbound..",
+ DEPENDENCY_ADAPTER_BASE + ".application.port.outbound..",
+ DEPENDENCY_ADAPTER_BASE + ".domain.model..",
+ DEPENDENCY_ADAPTER_BASE + ".application.domain.service.adapter..",
+ DEPENDENCY_ADAPTER_BASE + ".application.domain.service.impl.."
+ );
+
+ DependencyDirectionTest rules = new DependencyDirectionTest();
+
+ assertDoesNotThrow(rules::coreApplicationLayerShouldNotDependOnAdapters);
+ assertThrows(AssertionError.class, rules::adaptersShouldNotDependOnServiceImplementations);
+ assertDoesNotThrow(rules::onlyConfigurationMayDependOnServiceImplementations);
+ }
+
+ @Test
+ void dependencyDirectionShouldFailConfigurationRuleWhenNonConfigurationDependsOnServiceImplementation() {
+ configure(
+ DEPENDENCY_NON_CONFIG_BASE,
+ DEPENDENCY_NON_CONFIG_BASE + ".application.port.inbound..",
+ DEPENDENCY_NON_CONFIG_BASE + ".application.port.outbound..",
+ DEPENDENCY_NON_CONFIG_BASE + ".domain.model..",
+ DEPENDENCY_NON_CONFIG_BASE + ".adapters..",
+ DEPENDENCY_NON_CONFIG_BASE + ".application.service.."
+ );
+
+ DependencyDirectionTest rules = new DependencyDirectionTest();
+
+ assertDoesNotThrow(rules::coreApplicationLayerShouldNotDependOnAdapters);
+ assertDoesNotThrow(rules::adaptersShouldNotDependOnServiceImplementations);
+ assertThrows(AssertionError.class, rules::onlyConfigurationMayDependOnServiceImplementations);
+ }
+
+ @Test
+ void portContractShouldFailInputPortRuleWhenInputPortIsAConcreteClass() {
+ configure(
+ PORT_INPUT_BASE,
+ PORT_INPUT_BASE + ".application.port.inbound..",
+ PORT_INPUT_BASE + ".application.port.outbound..",
+ PORT_INPUT_BASE + ".domain.model..",
+ PORT_INPUT_BASE + ".adapters..",
+ PORT_INPUT_BASE + ".application.service.."
+ );
+
+ PortContractTest rules = new PortContractTest();
+
+ assertThrows(AssertionError.class, rules::inputPortsShouldBeInterfaces);
+ assertDoesNotThrow(rules::outputPortsShouldBeInterfaces);
+ assertDoesNotThrow(rules::portsShouldOnlyDependOnJavaCoreAndDomainModel);
+ }
+
+ @Test
+ void portContractShouldFailOutputPortRuleWhenOutputPortIsAConcreteClass() {
+ configure(
+ PORT_OUTPUT_BASE,
+ PORT_OUTPUT_BASE + ".application.port.inbound..",
+ PORT_OUTPUT_BASE + ".application.port.outbound..",
+ PORT_OUTPUT_BASE + ".domain.model..",
+ PORT_OUTPUT_BASE + ".adapters..",
+ PORT_OUTPUT_BASE + ".application.service.."
+ );
+
+ PortContractTest rules = new PortContractTest();
+
+ assertDoesNotThrow(rules::inputPortsShouldBeInterfaces);
+ assertThrows(AssertionError.class, rules::outputPortsShouldBeInterfaces);
+ assertDoesNotThrow(rules::portsShouldOnlyDependOnJavaCoreAndDomainModel);
+ }
+
+ @Test
+ void portContractShouldFailSignatureRuleWhenPortExposesFrameworkType() {
+ configure(
+ PORT_SIGNATURE_BASE,
+ PORT_SIGNATURE_BASE + ".application.port.inbound..",
+ PORT_SIGNATURE_BASE + ".application.port.outbound..",
+ PORT_SIGNATURE_BASE + ".domain.model..",
+ PORT_SIGNATURE_BASE + ".adapters..",
+ PORT_SIGNATURE_BASE + ".application.service.."
+ );
+
+ PortContractTest rules = new PortContractTest();
+
+ assertDoesNotThrow(rules::inputPortsShouldBeInterfaces);
+ assertDoesNotThrow(rules::outputPortsShouldBeInterfaces);
+ assertThrows(AssertionError.class, rules::portsShouldOnlyDependOnJavaCoreAndDomainModel);
+ }
+
+ private void capture(String key) {
+ originalProperties.put(key, System.getProperty(key));
+ }
+
+ private void restore(String key) {
+ String value = originalProperties.get(key);
+ if (value == null) {
+ System.clearProperty(key);
+ return;
+ }
+ System.setProperty(key, value);
+ }
+
+ private void configure(
+ String basePackage,
+ String inPorts,
+ String outPorts,
+ String domainModel,
+ String adapters,
+ String applicationServices
+ ) {
+ System.setProperty(BASE_PACKAGE_KEY, basePackage);
+ System.setProperty(IN_PORTS_KEY, inPorts);
+ System.setProperty(OUT_PORTS_KEY, outPorts);
+ System.setProperty(DOMAIN_MODEL_KEY, domainModel);
+ System.setProperty(ADAPTERS_KEY, adapters);
+ System.setProperty(APPLICATION_SERVICES_KEY, applicationServices);
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/persistence/OrderStoreRepositoryAdapter.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/persistence/OrderStoreRepositoryAdapter.java
new file mode 100644
index 0000000..aaa932f
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/persistence/OrderStoreRepositoryAdapter.java
@@ -0,0 +1,12 @@
+package com.arc_e_tect.fixtures.compliant.adapters.persistence;
+
+import com.arc_e_tect.fixtures.compliant.application.port.outbound.OrderStorePort;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class OrderStoreRepositoryAdapter implements OrderStorePort {
+
+ @Override
+ public void save() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/web/CreateOrderController.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/web/CreateOrderController.java
new file mode 100644
index 0000000..38ad82b
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/adapters/web/CreateOrderController.java
@@ -0,0 +1,18 @@
+package com.arc_e_tect.fixtures.compliant.adapters.web;
+
+import com.arc_e_tect.fixtures.compliant.application.port.inbound.CreateOrderUseCase;
+import org.springframework.stereotype.Controller;
+
+@Controller
+public class CreateOrderController {
+
+ private final CreateOrderUseCase createOrderUseCase;
+
+ public CreateOrderController(CreateOrderUseCase createOrderUseCase) {
+ this.createOrderUseCase = createOrderUseCase;
+ }
+
+ public void create() {
+ createOrderUseCase.create();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/inbound/CreateOrderUseCase.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/inbound/CreateOrderUseCase.java
new file mode 100644
index 0000000..b99d18f
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/inbound/CreateOrderUseCase.java
@@ -0,0 +1,5 @@
+package com.arc_e_tect.fixtures.compliant.application.port.inbound;
+
+public interface CreateOrderUseCase {
+ void create();
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/outbound/OrderStorePort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/outbound/OrderStorePort.java
new file mode 100644
index 0000000..32361b0
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/port/outbound/OrderStorePort.java
@@ -0,0 +1,5 @@
+package com.arc_e_tect.fixtures.compliant.application.port.outbound;
+
+public interface OrderStorePort {
+ void save();
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/service/CreateOrderService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/service/CreateOrderService.java
new file mode 100644
index 0000000..e1a57d8
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/application/service/CreateOrderService.java
@@ -0,0 +1,18 @@
+package com.arc_e_tect.fixtures.compliant.application.service;
+
+import com.arc_e_tect.fixtures.compliant.application.port.inbound.CreateOrderUseCase;
+import com.arc_e_tect.fixtures.compliant.application.port.outbound.OrderStorePort;
+
+public class CreateOrderService implements CreateOrderUseCase {
+
+ private final OrderStorePort orderStorePort;
+
+ public CreateOrderService(OrderStorePort orderStorePort) {
+ this.orderStorePort = orderStorePort;
+ }
+
+ @Override
+ public void create() {
+ orderStorePort.save();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/configuration/ApplicationConfiguration.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/configuration/ApplicationConfiguration.java
new file mode 100644
index 0000000..107a7d6
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/configuration/ApplicationConfiguration.java
@@ -0,0 +1,11 @@
+package com.arc_e_tect.fixtures.compliant.configuration;
+
+import com.arc_e_tect.fixtures.compliant.application.port.outbound.OrderStorePort;
+import com.arc_e_tect.fixtures.compliant.application.service.CreateOrderService;
+
+public class ApplicationConfiguration {
+
+ public CreateOrderService createOrderService(OrderStorePort orderStorePort) {
+ return new CreateOrderService(orderStorePort);
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/domain/model/Order.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/domain/model/Order.java
new file mode 100644
index 0000000..71ba8f0
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/compliant/domain/model/Order.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.compliant.domain.model;
+
+import java.util.UUID;
+
+public class Order {
+
+ private final UUID id;
+
+ public Order(UUID id) {
+ this.id = id;
+ }
+
+ public UUID id() {
+ return id;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/inbound/CreateOrderUseCase.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/inbound/CreateOrderUseCase.java
new file mode 100644
index 0000000..d241cbd
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/inbound/CreateOrderUseCase.java
@@ -0,0 +1,6 @@
+package com.arc_e_tect.fixtures.regression.serviceImplementsPort.application.port.inbound;
+
+public interface CreateOrderUseCase {
+
+ void create();
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/outbound/OrderStorePort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/outbound/OrderStorePort.java
new file mode 100644
index 0000000..3a0d0a0
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/port/outbound/OrderStorePort.java
@@ -0,0 +1,6 @@
+package com.arc_e_tect.fixtures.regression.serviceImplementsPort.application.port.outbound;
+
+public interface OrderStorePort {
+
+ void save();
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/service/CreateOrderService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/service/CreateOrderService.java
new file mode 100644
index 0000000..69b793b
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/regression/serviceImplementsPort/application/service/CreateOrderService.java
@@ -0,0 +1,26 @@
+package com.arc_e_tect.fixtures.regression.serviceImplementsPort.application.service;
+
+import com.arc_e_tect.fixtures.regression.serviceImplementsPort.application.port.inbound.CreateOrderUseCase;
+import com.arc_e_tect.fixtures.regression.serviceImplementsPort.application.port.outbound.OrderStorePort;
+import org.springframework.stereotype.Service;
+
+/**
+ * A {@code @Service} that implements its own in-port, the standard Hexagonal wiring.
+ * Regression fixture for {@code servicesShouldNotAccessRepositoriesDirectly}: implementing
+ * an in-port is a real ArchUnit-visible dependency and must not be mistaken for reaching
+ * into an adapter/repository package.
+ */
+@Service
+public class CreateOrderService implements CreateOrderUseCase {
+
+ private final OrderStorePort orderStorePort;
+
+ public CreateOrderService(OrderStorePort orderStorePort) {
+ this.orderStorePort = orderStorePort;
+ }
+
+ @Override
+ public void create() {
+ orderStorePort.save();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/notification/OrderNotifierAdapter.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/notification/OrderNotifierAdapter.java
new file mode 100644
index 0000000..66554d5
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/notification/OrderNotifierAdapter.java
@@ -0,0 +1,12 @@
+package com.arc_e_tect.fixtures.violating.cycle.adapters.notification;
+
+import com.arc_e_tect.fixtures.violating.cycle.adapters.persistence.OrderRepositoryAdapter;
+
+public class OrderNotifierAdapter {
+
+ private final OrderRepositoryAdapter repository;
+
+ public OrderNotifierAdapter(OrderRepositoryAdapter repository) {
+ this.repository = repository;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/persistence/OrderRepositoryAdapter.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/persistence/OrderRepositoryAdapter.java
new file mode 100644
index 0000000..6c0c396
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/cycle/adapters/persistence/OrderRepositoryAdapter.java
@@ -0,0 +1,12 @@
+package com.arc_e_tect.fixtures.violating.cycle.adapters.persistence;
+
+import com.arc_e_tect.fixtures.violating.cycle.adapters.notification.OrderNotifierAdapter;
+
+public class OrderRepositoryAdapter {
+
+ private final OrderNotifierAdapter notifier;
+
+ public OrderRepositoryAdapter(OrderNotifierAdapter notifier) {
+ this.notifier = notifier;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/adapter/AdapterCallsService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/adapter/AdapterCallsService.java
new file mode 100644
index 0000000..f3805bb
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/adapter/AdapterCallsService.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.violating.dependency.adapterDependsOnService.application.domain.service.adapter;
+
+import com.arc_e_tect.fixtures.violating.dependency.adapterDependsOnService.application.domain.service.impl.AppServiceImpl;
+
+public class AdapterCallsService {
+
+ private final AppServiceImpl appService;
+
+ public AdapterCallsService(AppServiceImpl appService) {
+ this.appService = appService;
+ }
+
+ public void execute() {
+ appService.execute();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/impl/AppServiceImpl.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/impl/AppServiceImpl.java
new file mode 100644
index 0000000..5557f50
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/adapterDependsOnService/application/domain/service/impl/AppServiceImpl.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.dependency.adapterDependsOnService.application.domain.service.impl;
+
+public class AppServiceImpl {
+
+ public void execute() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/adapters/persistence/AdapterThing.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/adapters/persistence/AdapterThing.java
new file mode 100644
index 0000000..3d3524c
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/adapters/persistence/AdapterThing.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.dependency.coreDependsOnAdapter.adapters.persistence;
+
+public class AdapterThing {
+
+ public void execute() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/domain/model/CoreUsesAdapter.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/domain/model/CoreUsesAdapter.java
new file mode 100644
index 0000000..6df8df9
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/coreDependsOnAdapter/domain/model/CoreUsesAdapter.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.violating.dependency.coreDependsOnAdapter.domain.model;
+
+import com.arc_e_tect.fixtures.violating.dependency.coreDependsOnAdapter.adapters.persistence.AdapterThing;
+
+public class CoreUsesAdapter {
+
+ private final AdapterThing adapterThing;
+
+ public CoreUsesAdapter(AdapterThing adapterThing) {
+ this.adapterThing = adapterThing;
+ }
+
+ public void execute() {
+ adapterThing.execute();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/application/service/AppService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/application/service/AppService.java
new file mode 100644
index 0000000..10490c2
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/application/service/AppService.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.dependency.nonConfigDependsOnService.application.service;
+
+public class AppService {
+
+ public void execute() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/domain/model/DomainCallsService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/domain/model/DomainCallsService.java
new file mode 100644
index 0000000..b0bd7d1
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/dependency/nonConfigDependsOnService/domain/model/DomainCallsService.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.violating.dependency.nonConfigDependsOnService.domain.model;
+
+import com.arc_e_tect.fixtures.violating.dependency.nonConfigDependsOnService.application.service.AppService;
+
+public class DomainCallsService {
+
+ private final AppService appService;
+
+ public DomainCallsService(AppService appService) {
+ this.appService = appService;
+ }
+
+ public void execute() {
+ appService.execute();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/application/service/AnnotatedService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/application/service/AnnotatedService.java
new file mode 100644
index 0000000..8dc118d
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/application/service/AnnotatedService.java
@@ -0,0 +1,10 @@
+package com.arc_e_tect.fixtures.violating.domain.applicationServiceStereotype.application.service;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class AnnotatedService {
+
+ public void execute() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/domain/model/GoodDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/domain/model/GoodDomain.java
new file mode 100644
index 0000000..84ab553
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/applicationServiceStereotype/domain/model/GoodDomain.java
@@ -0,0 +1,14 @@
+package com.arc_e_tect.fixtures.violating.domain.applicationServiceStereotype.domain.model;
+
+public class GoodDomain {
+
+ private final String value;
+
+ public GoodDomain(String value) {
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/application/port/outbound/ForbiddenPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/application/port/outbound/ForbiddenPort.java
new file mode 100644
index 0000000..66bdee8
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/application/port/outbound/ForbiddenPort.java
@@ -0,0 +1,5 @@
+package com.arc_e_tect.fixtures.violating.domain.domainDependency.application.port.outbound;
+
+public interface ForbiddenPort {
+ void send();
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/domain/model/BadDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/domain/model/BadDomain.java
new file mode 100644
index 0000000..b730082
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/domainDependency/domain/model/BadDomain.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.violating.domain.domainDependency.domain.model;
+
+import com.arc_e_tect.fixtures.violating.domain.domainDependency.application.port.outbound.ForbiddenPort;
+
+public class BadDomain {
+
+ private final ForbiddenPort forbiddenPort;
+
+ public BadDomain(ForbiddenPort forbiddenPort) {
+ this.forbiddenPort = forbiddenPort;
+ }
+
+ public void execute() {
+ forbiddenPort.send();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/framework/FrameworkBoundDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/framework/FrameworkBoundDomain.java
new file mode 100644
index 0000000..de813c7
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/framework/FrameworkBoundDomain.java
@@ -0,0 +1,17 @@
+package com.arc_e_tect.fixtures.violating.domain.frameworkDependency.domain.framework;
+
+import org.springframework.util.Assert;
+
+public class FrameworkBoundDomain {
+
+ private final String value;
+
+ public FrameworkBoundDomain(String value) {
+ Assert.hasText(value, "value must not be empty");
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/model/GoodDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/model/GoodDomain.java
new file mode 100644
index 0000000..4cc58b5
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/domain/frameworkDependency/domain/model/GoodDomain.java
@@ -0,0 +1,14 @@
+package com.arc_e_tect.fixtures.violating.domain.frameworkDependency.domain.model;
+
+public class GoodDomain {
+
+ private final String value;
+
+ public GoodDomain(String value) {
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/inbound/NotInterfaceInputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/inbound/NotInterfaceInputPort.java
new file mode 100644
index 0000000..137402d
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/inbound/NotInterfaceInputPort.java
@@ -0,0 +1,10 @@
+package com.arc_e_tect.fixtures.violating.port.inputNotInterface.application.port.inbound;
+
+import com.arc_e_tect.fixtures.violating.port.inputNotInterface.domain.model.PortDomain;
+
+public class NotInterfaceInputPort {
+
+ public PortDomain execute(PortDomain domain) {
+ return domain;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/outbound/GoodOutputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/outbound/GoodOutputPort.java
new file mode 100644
index 0000000..f05af9e
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/application/port/outbound/GoodOutputPort.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.port.inputNotInterface.application.port.outbound;
+
+import com.arc_e_tect.fixtures.violating.port.inputNotInterface.domain.model.PortDomain;
+
+public interface GoodOutputPort {
+ PortDomain load(String id);
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/domain/model/PortDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/domain/model/PortDomain.java
new file mode 100644
index 0000000..98f2c1e
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/inputNotInterface/domain/model/PortDomain.java
@@ -0,0 +1,14 @@
+package com.arc_e_tect.fixtures.violating.port.inputNotInterface.domain.model;
+
+public class PortDomain {
+
+ private final String value;
+
+ public PortDomain(String value) {
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/inbound/GoodInputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/inbound/GoodInputPort.java
new file mode 100644
index 0000000..bed941d
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/inbound/GoodInputPort.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.port.outputNotInterface.application.port.inbound;
+
+import com.arc_e_tect.fixtures.violating.port.outputNotInterface.domain.model.PortDomain;
+
+public interface GoodInputPort {
+ PortDomain execute(PortDomain domain);
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/outbound/NotInterfaceOutputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/outbound/NotInterfaceOutputPort.java
new file mode 100644
index 0000000..73250da
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/application/port/outbound/NotInterfaceOutputPort.java
@@ -0,0 +1,10 @@
+package com.arc_e_tect.fixtures.violating.port.outputNotInterface.application.port.outbound;
+
+import com.arc_e_tect.fixtures.violating.port.outputNotInterface.domain.model.PortDomain;
+
+public class NotInterfaceOutputPort {
+
+ public PortDomain load(String id) {
+ return new PortDomain(id);
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/domain/model/PortDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/domain/model/PortDomain.java
new file mode 100644
index 0000000..990aecf
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/outputNotInterface/domain/model/PortDomain.java
@@ -0,0 +1,14 @@
+package com.arc_e_tect.fixtures.violating.port.outputNotInterface.domain.model;
+
+public class PortDomain {
+
+ private final String value;
+
+ public PortDomain(String value) {
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/inbound/LeakyInputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/inbound/LeakyInputPort.java
new file mode 100644
index 0000000..cf425ba
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/inbound/LeakyInputPort.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.port.signatureLeak.application.port.inbound;
+
+import org.springframework.context.ApplicationContext;
+
+public interface LeakyInputPort {
+ void execute(ApplicationContext context);
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/outbound/GoodOutputPort.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/outbound/GoodOutputPort.java
new file mode 100644
index 0000000..4a213c8
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/application/port/outbound/GoodOutputPort.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.port.signatureLeak.application.port.outbound;
+
+import com.arc_e_tect.fixtures.violating.port.signatureLeak.domain.model.PortDomain;
+
+public interface GoodOutputPort {
+ PortDomain load(String id);
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/domain/model/PortDomain.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/domain/model/PortDomain.java
new file mode 100644
index 0000000..0cf18b2
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/port/signatureLeak/domain/model/PortDomain.java
@@ -0,0 +1,14 @@
+package com.arc_e_tect.fixtures.violating.port.signatureLeak.domain.model;
+
+public class PortDomain {
+
+ private final String value;
+
+ public PortDomain(String value) {
+ this.value = value;
+ }
+
+ public String value() {
+ return value;
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/components/misc/BadComponent.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/components/misc/BadComponent.java
new file mode 100644
index 0000000..0763ade
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/components/misc/BadComponent.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.spring.components.misc;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class BadComponent {
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/adapters/web/BadController.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/adapters/web/BadController.java
new file mode 100644
index 0000000..30d7be0
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/adapters/web/BadController.java
@@ -0,0 +1,18 @@
+package com.arc_e_tect.fixtures.violating.spring.controllers.adapters.web;
+
+import com.arc_e_tect.fixtures.violating.spring.controllers.application.service.ConcreteService;
+import org.springframework.stereotype.Controller;
+
+@Controller
+public class BadController {
+
+ private final ConcreteService concreteService;
+
+ public BadController(ConcreteService concreteService) {
+ this.concreteService = concreteService;
+ }
+
+ public void execute() {
+ concreteService.execute();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/application/service/ConcreteService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/application/service/ConcreteService.java
new file mode 100644
index 0000000..32b77fd
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/controllers/application/service/ConcreteService.java
@@ -0,0 +1,7 @@
+package com.arc_e_tect.fixtures.violating.spring.controllers.application.service;
+
+public class ConcreteService {
+
+ public void execute() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/adapters/persistence/BadRepository.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/adapters/persistence/BadRepository.java
new file mode 100644
index 0000000..6c587ff
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/adapters/persistence/BadRepository.java
@@ -0,0 +1,10 @@
+package com.arc_e_tect.fixtures.violating.spring.repositories.adapters.persistence;
+
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class BadRepository {
+
+ public void save() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/application/service/RepositoryConsumer.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/application/service/RepositoryConsumer.java
new file mode 100644
index 0000000..876dcb2
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/repositories/application/service/RepositoryConsumer.java
@@ -0,0 +1,16 @@
+package com.arc_e_tect.fixtures.violating.spring.repositories.application.service;
+
+import com.arc_e_tect.fixtures.violating.spring.repositories.adapters.persistence.BadRepository;
+
+public class RepositoryConsumer {
+
+ private final BadRepository badRepository;
+
+ public RepositoryConsumer(BadRepository badRepository) {
+ this.badRepository = badRepository;
+ }
+
+ public void execute() {
+ badRepository.save();
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/persistence/BadRepository.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/persistence/BadRepository.java
new file mode 100644
index 0000000..37a7ef3
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/persistence/BadRepository.java
@@ -0,0 +1,10 @@
+package com.arc_e_tect.fixtures.violating.spring.services.adapters.persistence;
+
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class BadRepository {
+
+ public void save() {
+ }
+}
diff --git a/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/service/BadService.java b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/service/BadService.java
new file mode 100644
index 0000000..28d051b
--- /dev/null
+++ b/hexagonal-spring-rules/src/testFixtures/java/com/arc_e_tect/fixtures/violating/spring/services/adapters/service/BadService.java
@@ -0,0 +1,18 @@
+package com.arc_e_tect.fixtures.violating.spring.services.adapters.service;
+
+import com.arc_e_tect.fixtures.violating.spring.services.adapters.persistence.BadRepository;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BadService {
+
+ private final BadRepository badRepository;
+
+ public BadService(BadRepository badRepository) {
+ this.badRepository = badRepository;
+ }
+
+ public void execute() {
+ badRepository.save();
+ }
+}