Add a runner function to make invoking rules easier and handle the allowEmptyShould=true case

Author: wakingrufus

nebula-archrules-core/build.gradle.kts

@@ -7,6 +7,7 @@ repositories {
 }
 dependencies {
     api("com.tngtech.archunit:archunit:1.4.1")
+    testImplementation("org.assertj:assertj-core:3.27.6")
 }
 testing {
     suites {
@@ -20,3 +21,6 @@ java {
         languageVersion = JavaLanguageVersion.of(11)
     }
 }
+dependencyLocking {
+    lockAllConfigurations()
+}

nebula-archrules-core/gradle.lockfile

@@ -1,8 +1,10 @@
 # This is a Gradle generated file for dependency locking.
 # Manual edits can break the build and are not advised.
 # This file is expected to be part of source control.
-com.tngtech.archunit:archunit:1.4.1=compileClasspath,testCompileClasspath,testRuntimeClasspath
+com.tngtech.archunit:archunit:1.4.1=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
+net.bytebuddy:byte-buddy:1.17.7=testCompileClasspath,testRuntimeClasspath
 org.apiguardian:apiguardian-api:1.1.2=testCompileClasspath
+org.assertj:assertj-core:3.27.6=testCompileClasspath,testRuntimeClasspath
 org.junit.jupiter:junit-jupiter-api:5.12.2=testCompileClasspath,testRuntimeClasspath
 org.junit.jupiter:junit-jupiter-engine:5.12.2=testRuntimeClasspath
 org.junit.jupiter:junit-jupiter-params:5.12.2=testCompileClasspath,testRuntimeClasspath
@@ -12,5 +14,5 @@ org.junit.platform:junit-platform-engine:1.12.2=testRuntimeClasspath
 org.junit.platform:junit-platform-launcher:1.12.2=testRuntimeClasspath
 org.junit:junit-bom:5.12.2=testCompileClasspath,testRuntimeClasspath
 org.opentest4j:opentest4j:1.3.0=testCompileClasspath,testRuntimeClasspath
-org.slf4j:slf4j-api:2.0.17=compileClasspath,testCompileClasspath,testRuntimeClasspath
+org.slf4j:slf4j-api:2.0.17=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
 empty=annotationProcessor,testAnnotationProcessor

nebula-archrules-core/src/main/java/com/netflix/nebula/archrules/core/NoClassesMatchedEvent.java

@@ -0,0 +1,33 @@
+package com.netflix.nebula.archrules.core;
+
+import com.tngtech.archunit.lang.ConditionEvent;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Custom event for representing a failure of allowEmptyShould in a non-exceptional way
+ */
+public class NoClassesMatchedEvent implements ConditionEvent {
+    public static final String NO_MATCH_MESSAGE = "no classes matched the required condition";
+
+    @Override
+    public boolean isViolation() {
+        return true;
+    }
+
+    @Override
+    public ConditionEvent invert() {
+        return this;
+    }
+
+    @Override
+    public List<String> getDescriptionLines() {
+        return List.of(NO_MATCH_MESSAGE);
+    }
+
+    @Override
+    public void handleWith(Handler handler) {
+        handler.handle(Collections.emptyList(), NO_MATCH_MESSAGE);
+    }
+}

nebula-archrules-core/src/main/java/com/netflix/nebula/archrules/core/Runner.java

@@ -0,0 +1,35 @@
+package com.netflix.nebula.archrules.core;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.EvaluationResult;
+
+public class Runner {
+    public static EvaluationResult check(ArchRule rule, JavaClasses classesToCheck) {
+        try {
+            return rule.evaluate(classesToCheck);
+        } catch (AssertionError e) {
+            // evaluate the rule again with more leniency so we can get the priority
+            final var result2 = rule.allowEmptyShould(true).evaluate(classesToCheck);
+            if (result2.hasViolation()) {
+                return result2;
+            } else {
+                ConditionEvents events = ConditionEvents.Factory.create();
+                events.add(new NoClassesMatchedEvent());
+                return new EvaluationResult(rule, events, result2.getPriority());
+            }
+        }
+    }
+
+    /**
+     * Check a rule against some classes.
+     * This can be invoked from the real Gradle plugin or unit tests for rules to ensure the same logic is observed there.
+     */
+    public static EvaluationResult check(ArchRule rule, Class<?>... classesToCheck) {
+        final var classes = new ClassFileImporter()
+                .importClasses(classesToCheck);
+        return check(rule, classes);
+    }
+}

nebula-archrules-core/src/test/java/com/netflix/nebula/archrules/core/RunnerTest.java

@@ -0,0 +1,65 @@
+package com.netflix.nebula.archrules.core;
+
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.Priority;
+import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
+import org.junit.jupiter.api.Test;
+
+import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleName;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RunnerTest {
+    @Test
+    public void test_pass() {
+        final var result = Runner.check(noDeprecatedRule, PassingClass.class);
+        assertThat(result.hasViolation()).isFalse();
+    }
+
+    @Test
+    public void test_fail() {
+        final var result = Runner.check(noDeprecatedRule, FailingClass.class);
+        assertThat(result.hasViolation()).isTrue();
+    }
+
+    @Test
+    public void test_fail_and_pass() {
+        final var result = Runner.check(noDeprecatedRule, PassingClass.class, FailingClass.class);
+        assertThat(result.hasViolation()).isTrue();
+        assertThat(result.getFailureReport().getDetails()).hasSize(1);
+    }
+
+    static class PassingClass {
+    }
+
+    @Deprecated
+    static class FailingClass {
+    }
+
+    private final ArchRule noDeprecatedRule = ArchRuleDefinition.classes().should()
+            .notBeAnnotatedWith(Deprecated.class);
+    private final ArchRule smokeTestRule = ArchRuleDefinition.priority(Priority.MEDIUM)
+            .classes().that(simpleName("SmokeTest"))
+            .should().beAnnotatedWith(Deprecated.class)
+            .allowEmptyShould(false);
+
+    static class SmokeTestFail {
+    }
+
+    @Deprecated
+    static class SmokeTest {
+    }
+
+    @Test
+    public void test_smoke_pass() {
+        final var result = Runner.check(smokeTestRule, SmokeTest.class);
+        assertThat(result.hasViolation()).isFalse();
+    }
+
+    @Test
+    public void test_smoke_fail() {
+        final var result = Runner.check(smokeTestRule, SmokeTestFail.class);
+        assertThat(result.hasViolation()).isTrue();
+        assertThat(result.getFailureReport().getDetails())
+                .contains(NoClassesMatchedEvent.NO_MATCH_MESSAGE);
+    }
+}