Detect feature packages dynamically via FeatureSliceConfiguration instead of hardcoded package pattern

The ArchUnit rule no longer requires features to live under a `*.features.*` package.
Instead, any package containing a concrete class implementing FeatureSliceConfiguration
(directly or via extending) is treated as a feature package. Interfaces extending
FeatureSliceConfiguration are excluded so shared interface packages are not flagged.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: vanrogu

sliceworkz-eventmodeling-testing/src/main/java/org/sliceworkz/eventmodeling/testing/AbstractBoundedContextArchUnitTest.java

@@ -19,10 +19,13 @@
 
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
 
-import java.util.regex.Pattern;
+import java.util.HashSet;
+import java.util.Set;
 
 import org.junit.jupiter.api.Test;
+import org.sliceworkz.eventmodeling.slices.FeatureSliceConfiguration;
 
+import com.tngtech.archunit.base.DescribedPredicate;
 import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.domain.JavaClasses;
 import com.tngtech.archunit.core.importer.ClassFileImporter;
@@ -32,81 +35,109 @@
 import com.tngtech.archunit.lang.SimpleConditionEvent;
 
 /**
- * Abstract Base Test to be overriden by a concrete Test Class in a root package for the overall application.
- * Checks 
-
+ * Abstract Base Test to be overridden by a concrete Test Class in a root package for the overall application.
+ * Checks
+ *
  * VSA - Vertical Slice Architecture:
- * 		- whether no feature packages (*.features._featureName_.*) depends on another one. 
- * 
- * 
- * 
+ * 		- whether no feature packages depend on another one.
+ *
+ * A feature package is any package that contains a class implementing
+ * {@link FeatureSliceConfiguration} (directly or via extending). Classes in
+ * subpackages of a feature package are considered part of the same feature.
+ *
  * Overriding is done with an empty class, in the right base package.
- * (see "CoursesArchUnitTest" in the "courses" example for reference) 
- * 
+ * (see "CoursesArchUnitTest" in the "courses" example for reference)
+ *
  * package com.mycompany.mycomponent;
- * 
+ *
  * public class MyDomainArchUnitTest extends AbstractBoundedContextArchUnitTest {
- * 
+ *
  * }
- * 
+ *
  */
 public abstract class AbstractBoundedContextArchUnitTest {
 
 	private JavaClasses CLASSES;
-	
+
 	public AbstractBoundedContextArchUnitTest ( ) {
 		 this.CLASSES = new ClassFileImporter().importPackages(packageName());
 	}
-	
+
 	private String packageName ( ) {
 		return this.getClass().getPackageName();
 	}
 
 	@Test
 	void featurePackagesShouldNotDependOnEachOther() {
-		ArchRule rule = noClasses().that().resideInAPackage("..features..*").should(dependOnClassesFromOtherFeatures())
+		Set<String> featurePackages = findFeaturePackages(CLASSES);
+
+		if (featurePackages.isEmpty()) {
+			return;
+		}
+
+		ArchRule rule = noClasses()
+				.that(resideInFeaturePackages(featurePackages))
+				.should(dependOnClassesFromOtherFeaturePackages(featurePackages))
 				.because("Features should be independent and not depend on classes in other feature packages");
 
 		rule.check(CLASSES);
 	}
 
-	private static ArchCondition<JavaClass> dependOnClassesFromOtherFeatures() {
-		return new ArchCondition<JavaClass>("depend on classes from other features") {
-			@Override
-			public void check(JavaClass javaClass, ConditionEvents events) {
-				System.err.println("checking " + javaClass);
+	private static Set<String> findFeaturePackages(JavaClasses classes) {
+		Set<String> featurePackages = new HashSet<>();
+		for (JavaClass javaClass : classes) {
+			if (!javaClass.isInterface() && javaClass.isAssignableTo(FeatureSliceConfiguration.class)) {
+				featurePackages.add(javaClass.getPackageName());
+			}
+		}
+		return featurePackages;
+	}
 
-				if (javaClass.toString().contains("ActivateClockCom")) {
-					System.err.println("w");
+	private static String findOwningFeaturePackage(String packageName, Set<String> featurePackages) {
+		String best = null;
+		for (String featurePackage : featurePackages) {
+			if (packageName.equals(featurePackage) || packageName.startsWith(featurePackage + ".")) {
+				if (best == null || featurePackage.length() > best.length()) {
+					best = featurePackage;
 				}
+			}
+		}
+		return best;
+	}
 
-				Pattern featurePattern = Pattern.compile(".*\\.features\\.([^.]+)");
-				java.util.regex.Matcher currentFeatureMatcher = featurePattern.matcher(javaClass.getPackageName());
+	private static DescribedPredicate<JavaClass> resideInFeaturePackages(Set<String> featurePackages) {
+		return new DescribedPredicate<>("reside in a feature package") {
+			@Override
+			public boolean test(JavaClass javaClass) {
+				return findOwningFeaturePackage(javaClass.getPackageName(), featurePackages) != null;
+			}
+		};
+	}
 
-				if (!currentFeatureMatcher.find()) {
-					return; // Not in a feature package
+	private static ArchCondition<JavaClass> dependOnClassesFromOtherFeaturePackages(Set<String> featurePackages) {
+		return new ArchCondition<>("depend on classes from other feature packages") {
+			@Override
+			public void check(JavaClass javaClass, ConditionEvents events) {
+				String currentFeature = findOwningFeaturePackage(javaClass.getPackageName(), featurePackages);
+				if (currentFeature == null) {
+					return;
 				}
 
-				String currentFeature = currentFeatureMatcher.group(1);
-
-				javaClass.getDirectDependenciesFromSelf().stream().filter(dependency -> {
-					String targetPackage = dependency.getTargetClass().getPackageName();
-					java.util.regex.Matcher targetMatcher = featurePattern.matcher(targetPackage);
-					if (!targetMatcher.find()) {
-						return false; // Target not in features package
-					}
-					String targetFeature = targetMatcher.group(1);
-					if (currentFeature.equals(targetFeature)) {
-						return false; // Same feature - allowed
-					}
-
-					return true;
-
-				}).forEach(dependency -> {
-					String message = "Class %s depends on %s from different feature".formatted(javaClass.getName(),
-							dependency.getTargetClass().getName());
-					events.add(SimpleConditionEvent.satisfied(dependency, message));
-				});
+				javaClass.getDirectDependenciesFromSelf().stream()
+						.filter(dependency -> {
+							String targetFeature = findOwningFeaturePackage(
+									dependency.getTargetClass().getPackageName(), featurePackages);
+							if (targetFeature == null) {
+								return false;
+							}
+							return !currentFeature.equals(targetFeature);
+						})
+						.forEach(dependency -> {
+							String message = "Class %s depends on %s from different feature package".formatted(
+									javaClass.getName(),
+									dependency.getTargetClass().getName());
+							events.add(SimpleConditionEvent.satisfied(dependency, message));
+						});
 			}
 		};
 	}